门面模式

<image>

门面模式（facade pattern），也翻译为外观模式，是软件工程中常用的一种软件设计模式，它为子系统中的一组界面提供一个统一的高层界面，使得子系统更容易使用。

## 概述

门面模式是面向对象程序设计中常用的一个设计模式。门面的概念类似于一个建筑学中的立面，门面作为一个前端接口来屏蔽更复杂的底层或结构代码。门面模式可以用来:

- 通用简化的API屏蔽与更复杂的内部组件和结构, 以提高软件库的可读性和可用性。
- 为更通用的功能提供上下文特定的接口。
- 在广泛更新重构单层系统或紧密耦合的软件系统, 提供一个简化的启动点，更有利于更多的松耦合代码。

当一个系统非常复杂或难以理解时，开发人员通常会使用门面设计模式，因为该系统有许多相互依赖的类，或者因为其源代码不可用。门面模式隐藏了更大系统的复杂性，为客户端提供了一个更简单的接口。通常会涉及到一个wrapper包含客户端所需的一组成员的。这些成员代表门面的客户端访问系统并隐藏实现细节。

## 结构

<image>

Facade：这个门面类为子系统中Packages 1、2、3提供一个共同的对外界面（接口）

Clients：客户对象通过一个门面界面读写子系统中各界面的数据资源。

Packages：客户可以通过门面界面读取的内部库。

## 示例

这是一个抽象的范例。一个客户“you”通过门面界面“computer”获取计算机内部复杂的系统信息。

### C++

下面是C++的例子：

```cpp
import std;

using std::string;
using std::string_view;

class CPU {
private:
    // ...
public:
    void freeze() {
        // ...
    }

    void jump(long position) {
        // ...
    }

    void execute() {
        // ...
    }
};

class HardDrive {
private:
    // ...
public:
    string read(long lba, int size) {
        // ...
    }
};

class Memory {
private:
    // ...
public:
    void load(long position, string_view data) {
        // ...
    }
};

class ComputerFacade {
private:
    CPU cpu;
    Memory memory;
    HardDrive hardDrive;

    const long bootAddress;
    const long bootSector;
    const int sectorSize;
public:
    ComputerFacade(long bootAddress, long bootSector, int sectorSize):
        bootAddress{bootAddress}, bootSector{bootSector}, sectorSize{sectorSize} {}

    void start() {
        cpu.freeze();
        memory.load(bootAddress, hardDrive.read(bootSector, sectorSize));
        cpu.jump(bootAddress);
        cpu.execute();
    }
};

int main(int argc, char* argv[]) {
    ComputerFacade computer(/* parameters here */);
    computer.start();
}
```

### Java

```java
/* Complex parts */
class CPU {
	public void freeze() { ... }
	public void jump(long position) { ... }
	public void execute() { ... }
}

class Memory {
	public void load(long position, byte[] data) {
		...
	}
}

class HardDrive {
	public byte[] read(long lba, int size) {
		...
	}
}

/* Façade */
class Computer {
	public void startComputer() {
		cpu.freeze();
		memory.load(BOOT_ADDRESS, hardDrive.read(BOOT_SECTOR, SECTOR_SIZE));
		cpu.jump(BOOT_ADDRESS);
		cpu.execute();
	}
}

/* Client */
class You {
	public static void main(String[] args) {
		Computer facade = new Computer();
		facade.startComputer();
	}
}
```

### C#

```csharp
// Facade pattern -- Structural example 
using System;

namespace DoFactory.GangOfFour.Facade.Structural {
    // Mainapp test application 
    class MainApp {
        public static void Main() {
            Facade facade = new Facade();
            facade.MethodA();
            facade.MethodB();
            // Wait for user 
            Console.Read();
        }
    }

    // "Subsystem ClassA" 
    class SubSystemOne {
        public void MethodOne() {
            Console.WriteLine(" SubSystemOne Method");
        }
    }

    // Subsystem ClassB" 
    class SubSystemTwo {
        public void MethodTwo() {
            Console.WriteLine(" SubSystemTwo Method");
        }
    }

    // Subsystem ClassC" 
    class SubSystemThree {
        public void MethodThree() {
            Console.WriteLine(" SubSystemThree Method");
        }
    }

    // "Facade" 
    class Facade {
        SubSystemOne one;
        SubSystemTwo two;
        SubSystemThree three;
        public Facade() {
            one = new SubSystemOne();
            two = new SubSystemTwo();
            three = new SubSystemThree();
        }
        public void MethodA() {
            Console.WriteLine("\nMethodA() ---- ");
            one.MethodOne();
            two.MethodTwo();
        }
        public void MethodB() {
            Console.WriteLine("\nMethodB() ---- ");
            two.MethodTwo();
            three.MethodThree();
        }
    }
} 
```

### Python

下面是Python的例子，这里的类可以放置在不同的模块或包之中，这里将如下所有硬件有关的类都保存入当前工作目录下的文件`hardware.py`之中：

```python
class CPU():
    def freeze(self): pass
    def jump(self, position): pass
    def execute(self): pass

class Memory():
    def load(self, position, data): pass

class HardDrive():
    def read(self, lba, size): pass
```

接着导入这个模块并使用其中的类：

```python
from hardware import CPU, Memory, HardDrive

class Computer():
    def __init__(self, *, cpu, mem, hd):
        self.cpu = cpu
        self.mem = mem
        self.hd = hd
    def start_computer(self):
        self.cpu.freeze();
		self.mem.load('BOOT_ADDRESS',
		    self.hd.read('BOOT_SECTOR', 'SECTOR_SIZE'))
		self.cpu.jump('BOOT_ADDRESS');
		self.cpu.execute();

facade = Computer(cpu=CPU(), mem=Memory(), hd=HardDrive())
facade.start_computer()
```