定义 (Definition)

‘Facade’ pattern is a structural design pattern which improves the structure of a large system¹. Structural pattern is useful for making independent developed systems work together.

立面模式 是一种结构设计模式，可改善大型系统的结构¹。 结构模式对于使独立开发的系统协同工作非常有用。

The ‘Facade’ pattern defines an object representing a subsystem. This object is an interface that will take the responsibility to interact with the subsystem.

“外观”模式定义了一个代表子系统的对象。 该对象是一个接口，将负责与子系统进行交互。

[1] A system is composed of subsystems. A subsystem contains an interface and encapsulates classes. A class contains states and operations.

[1]一个系统由子系统组成。 子系统包含一个接口并封装类。 一个类包含状态和操作。

我们什么时候应该使用这种模式？ (When should we use this pattern?)

提供到复杂子系统的简单接口 (To provide a simple interface to a complex subsystem)

This pattern should be used when it is possible to provide a simpler interface than the one provided by the existing subsystem. A complex subsystem needs to work in a specific way in order to work correctly. Moving this complexity to an interface simplifies the use of its functionalities. This interface, called a facade, hides the complexity from the client.

当可以提供比现有子系统提供的接口更简单的接口时，应使用此模式。 复杂的子系统需要以特定的方式工作才能正常工作。 将此复杂性移至接口可简化其功能的使用。 这个称为外观的界面向客户端隐藏了复杂性。

使子系统与客户端和其他子系统分离 (To decouple the subsystem from clients and other subsystems)

This pattern should be used when a system has many dependent¹ subsystems. It decouples their implementation details. It reduces dependencies and makes the code easier to use, understand, maintain and test.

当系统具有多个从属子系统时，应使用此模式。 它解耦了它们的实现细节。 它减少了依赖性，并使代码更易于使用，理解，维护和测试。

定义子系统的入口点 (To define an entry point to a subsystem)

This pattern should be used when subsystems are interdependent². Instead of exposing a client to a library, a framework, or a set of classes and their APIs, the facade pattern only exposes a simple unified API. Subsystems implement functionalities without knowing about the facade. They interact with each other within the system. So, the implementation details from the subsystems can change without impacting the facade API. It does not need any changes since a facade deals with interfaces and not implementations. It adds a layer of abstraction (the entry point) to improve the usability, readability and architecture of the code.

当子系统相互依赖²时，应使用此模式。 外观模式没有将客户端暴露给库，框架或一组类及其API，而是仅公开了一个简单的统一API。 子系统在不了解外观的情况下实现功能。 它们在系统内相互交互。 因此，子系统的实现细节可以更改，而不会影响Facade API。 因为外观处理接口而不是实现，所以不需要任何更改。 它增加了一个抽象层(入口点)以提高代码的可用性，可读性和体系结构。

[1] Dependent subsystems mean that a system has a dependency/reference on another system.

[1]依赖子系统是指一个系统对另一个系统具有依赖/引用。

[2] Interdependent subsystems mean that a system relies on another system in order to work.

[2]相互依赖的子系统意味着一个系统依赖于另一个系统才能工作。

我们应该如何使用这种模式？ (How should we use this pattern?)

A client communicates with a subsystem through a facade. It is a simple interface that delegates the work to the appropriate subsystem.

客户端通过立面与子系统进行通信。 这是一个简单的界面，可将工作委托给相应的子系统。

If the subsystem classes can be highly-decoupled, following the Single Responsibility Principle and applying design patterns, we end up with a lot of smaller and smaller components. It makes them more reusable and easier to customize. However, depending on the number of components and the complexity of the task to achieve, it becomes harder and harder to use them.️ It might be difficult for the client to complete the task. The reason why we use the facade pattern is because it provides a simple view of the subsystem to the client.

如果子系统类可以高度分离，遵循“ 单一职责原则”并应用设计模式，那么最终我们会得到越来越小的组件。 它使它们更可重用且更易于自定义。 但是，取决于组件的数量和要完成的任务的复杂性，使用它们变得越来越难。️客户可能很难完成任务。 我们使用外观模式的原因是因为它为客户端提供了子系统的简单视图。

具体例子 (Concrete example)

Let’s say we have a home theater system that controls devices such as a DVD player, a projector… Here is the UML diagram reflecting the structure above.

假设我们有一个家庭影院系统，可以控制DVD播放器，投影仪等设备。这是反映上述结构的UML图。

We have a complex system with multiple classes interacting with each other. Before having a facade, the client had to directly interact with all of the appropriate functionalities/classes in order to start a movie for example. An analogy is to think about the facade as a remote controller.

我们有一个复杂的系统，其中多个类相互交互。 在拥有立面之前，客户必须直接与所有适当的功能/类进行交互才能开始播放电影。 类推是将立面视为遥控器。

实作 (Implementation)

To implement the facade, we create a facade object with subsystem objects.

为了实现外观，我们创建带有子系统对象的外观对象。

“立面”实施 (‘Facade’ Implementation)

class HomeTheaterFacade {private let amp: Amplifierprivate let tuner: Tunerprivate let dvd: DvdPlayerprivate let cd: CdPlayerprivate let projector: Projectorprivate let lights: TheaterLightsprivate let screen: Screenprivate let popper: PopcornPopper    init(_ amp: Amplifier,_ tuner: Tuner,_ dvd: DvdPlayer,_ cd: CdPlayer,_ projector: Projector,_ lights: TheaterLights,_ screen: Screen,_ popper: PopcornPopper) {self.amp = ampself.tuner = tunerself.dvd = dvdself.cd = cdself.projector = projectorself.lights = lightsself.screen = screenself.popper = popper    }    // MARK: Facade methods   func watchMovie(movie: String) {        print("Get ready to watch a movie...")        popper.on()        popper.pop()        lights.dim(10)        screen.down()        projector.on()        projector.wideScreenMode()        amp.on()        amp.setDvd(dvd)        amp.setSurroundSound()        amp.setVolume(5)        dvd.on()        dvd.play(movie)    }        // other methods here}

We compose our facade through constructor injection to give the facade all of the components it needs from the subsystem.

我们通过构造函数注入来构造外观，从而为外观提供子系统需要的所有组件。

客户实施 (Client Implementation)

// instantiate components herelet homeTheater = HomeTheaterFacade(amp, tuner, dvd, cd, projector, lights, screen, popper)homeTheater.watchMovie(movie: "Raiders of the Lost Ark")

Here, the client communicates with the subsystem through a simplified interface while another client can still fully use the functionality of the subsystem.

在这里，客户端通过简化的界面与子系统通信，而另一个客户端仍可以完全使用子系统的功能。

在操场上运行代码 (Run code in a Playground)

Here is an Online Swift Playground so an Xcode Playground does not have to be created in order to test this implementation of the ‘Facade’ pattern. Then, copy the code below that corresponds with the full implementation of the ‘Facade’ pattern for our home theater system.

这是一个在线Swift Playground，因此不必为了测试“ Facade”模式的实现而创建Xcode Playground。 然后，复制下面与家庭影院系统“门面”模式的完整实现相对应的代码。

class Amplifier {var tuner: Tunervar dvdPlayer: DvdPlayervar cdPlayer: CdPlayer    init(tuner: Tuner,         dvdPlayer: DvdPlayer,         cdPlayer: CdPlayer) {self.tuner = tunerself.dvdPlayer = dvdPlayerself.cdPlayer = cdPlayer    }    func on() {         print("Amplifier on")     }    func setDvd(_ dvd: DvdPlayer) {        print("Amplifier setting DVD player")     }    func setSurroundSound() {        print("Amplifier surround sound on")     }    func setVolume(_ volume: Int) {        print("Amplifier setting volume to \(volume)")     }    // other Amplifier methods...}class DvdPlayer {var movie: String = ""    func on() {         print("DVD Player on")     }    func play(_ movie: String) { self.movie = movie        print("DVD PLayer playing \"\(movie)\"")    }    // other DvdPlayer methods...}class TheaterLights {func dim(_ level: Int) {         print("Theater Ceiling Lights dimming to \(level)%")     }    func on() {         print("Theater Ceiling Lights on")     }    // other TheaterLights methods...}class Projector {var dvdPlayer: DvdPlayer    init(dvdPlayer: DvdPlayer) {self.dvdPlayer = dvdPlayer    }    func on() {         print("Projector on")     }    func wideScreenMode() {         print("Projector in widescreen mode (16x9 aspect ratio)")     }    // other Projector methods...}class Tuner {    // Tuner methods...}class Screen {func down() {         print("Theater Screen going down")     }    // other Screen methods...}class PopcornPopper {func on() {        print("Popcorn Popper on")     }    func pop() {         print("Popcorn Popper popping popcorn!")     }    // other PopcornPopper methods...}class CdPlayer {    // CdPlayer methods...}class HomeTheaterFacade {private let amp: Amplifierprivate let tuner: Tunerprivate let dvd: DvdPlayerprivate let cd: CdPlayerprivate let projector: Projectorprivate let lights: TheaterLightsprivate let screen: Screenprivate let popper: PopcornPopper    init(_ amp: Amplifier,_ tuner: Tuner,_ dvd: DvdPlayer,_ cd: CdPlayer,_ projector: Projector,_ lights: TheaterLights,_ screen: Screen,_ popper: PopcornPopper) {self.amp = ampself.tuner = tunerself.dvd = dvdself.cd = cdself.projector = projectorself.lights = lightsself.screen = screenself.popper = popper    }    // MARK: Facade methods    func watchMovie(movie: String) {        print("Get ready to watch a movie...")        popper.on()        popper.pop()        lights.dim(10)        screen.down()        projector.on()        projector.wideScreenMode()        amp.on()        amp.setDvd(dvd)        amp.setSurroundSound()        amp.setVolume(5)        dvd.on()        dvd.play(movie)    }    // other methods here...}// instantiate components herelet tuner = Tuner()let dvd = DvdPlayer()let cd = CdPlayer()let amp = Amplifier(tuner: tuner, dvdPlayer: dvd, cdPlayer: cd)let projector = Projector(dvdPlayer: dvd)let screen = Screen()let lights = TheaterLights()let popper = PopcornPopper()let homeTheater = HomeTheaterFacade(amp, tuner, dvd, cd, projector, lights, screen, popper)homeTheater.watchMovie(movie: "Raiders of the Lost Ark")

Finally, paste and run the code.

最后，粘贴并运行代码。