Façade门面(外观)模式

动机(Motivation)

客户和组件中各种复杂的子系统有过多的耦合
如何简化外部客户程序和系统间的交互接口？如何解耦？

模式定义

为子系统中的一组接口提供一个一致(稳定)的界面，Façade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用(复用)。
——《设计模式》GoF

要点总结

从客户程序角度来看，Façade模式简化了整个组件系统的接口，对于组件内部与外部的客户程序来说，达到了一种”解耦“的效果——内部子系统的任何变化不会影响到Façade接口的变化。
Façade设计模式更注重架构的层次去看整个系统，而不是单个类的层次。Façade很多时候是一种架构设计模式。
Façade设计模式并非一个集装箱，可以任意地放进任何多个对象。Façade模式组件中的内部应该是”相互耦合关系比较大的一系列组件“，而不是一个简单的功能集合。

外观设计模式有助于隐藏系统的内部复杂性，并通过一个简化的接口向客户端暴露必要的部分

门面模式示例图

例子

# -*- coding: utf-8 -*-
from multiprocessing import Process
import os

class State(object):
    restart = 0
    zombie = 1
    new = 2
    running = 3


class Server(object):
    def __init__(self):
        pass

    def __str__(self):
        return self.name

    def boot(self):
        pass


class FileServer(Server):
    def __init__(self):
        '''初始化文件服务进程要求的操作'''
        self.name = 'FileServer'
        self.state = State.new

    def boot(self):
        print('booting the {}'.format(self))
        '''启动文件服务进程要求的操作'''
        self.state = State.running

    def kill(self, restart=True):
        print('Killing {}'.format(self))
        '''终止文件服务进程要求的操作'''
        self.state = State.restart if restart else State.zombie

    def create_file(self, user, name, permissions):
        '''检查访问权限的有效性、用户权限等'''
        print("trying to create the file '{}' for user '{}' with permissions{}".format(name, user, permissions))


class ProcessServer(Server):
    def __init__(self):
        '''初始化进程服务进程要求的操作'''
        self.name = 'ProcessServer'
        self.state = State.new

    def boot(self):
        print('booting the {}'.format(self))
        '''启动进程服务进程要求的操作'''
        self.state = State.running

    def kill(self, restart=True):
        print('Killing {}'.format(self))
        '''终止进程服务进程要求的操作'''
        self.state = State.restart if restart else State.zombie

    def create_process(self, user, name):
        '''检查用户权限和生成PID等'''
        print("trying to create the process '{}' for user '{}'".format(name, user))


class OperatingSystem(object):
    '''外观'''
    def __init__(self):
        self.fs = FileServer()
        self.ps = ProcessServer()

    def create_file(self, user, name, permissions):
        fs_process = Process(target=self._process_create_file, args=(user, name, permissions))
        fs_process.start()

    def _process_create_file(self, user, name, permissions):
        print('create file in process id:', os.getpid())
        self.fs.boot()
        return self.fs.create_file(user, name, permissions)

    def create_process(self, user, name):
        ps_process = Process(target=self._process_create_process, args=(user, name))
        ps_process.start()

    def _process_create_process(self, user, name):
        print('create_process in process id:', os.getpid())
        self.ps.boot()
        return self.ps.create_process(user, name)


def main():
    # 门面模式版本
    operate = OperatingSystem()
    operate.create_file('foo', 'hello', '-rw-r-r')
    operate.create_process('bar', 'ls /tmp')


if __name__ == '__main__':
    main()

输出：

('create file in process id:', 10745)
booting the FileServer
trying to create the file 'hello' for user 'foo' with permissions-rw-r-r
('create_process in process id:', 10746)
booting the ProcessServer
trying to create the process 'ls /tmp' for user 'bar'

外观类OperatingSystem起到了很好的隔离作用。create_file和create_process运行在不同的进程，但是客户端调用无需关心。
FileServer或ProcessServer变化时，只需要更改OperatingSystem即可，客户端调用保持稳定。
多进程multiprocessing的使用参考python多进程