外观模式

约 2073 字大约 7 分钟

设计模式结构型模式

2025-06-20

1. 一句话概括

外观模式是一种结构型设计模式，它为子系统中的一组接口提供一个统一的、简化的入口。它定义了一个高层接口，使得子系统更加易于使用。

2. 生活中的比喻：一键启动家庭影院

想象一下，你有一套复杂的家庭影院系统，包括：DVD播放机、投影仪、音响、幕布和灯光。

没有外观模式时，你想看一场电影，需要进行一系列复杂的操作：

打开灯光，并调暗。
放下幕布。
打开投影仪。
将投影仪切换到DVD输入模式。
打开音响。
将音响设置为环绕声模式。
打开DVD播放机。
放入DVD光盘。
按下播放键。

这一系列操作非常繁琐，你需要了解每个设备的功能并按正确的顺序操作它们。

使用外观模式后，你可以创建一个“智能遥控器”（这就是外观 Facade），上面只有一个按钮：“观看电影”。

当你按下这个按钮时，遥控器内部已经编程好了，它会替你完成上面所有的9个步骤。你（客户端）不再需要关心内部的复杂细节，只需要与这个简单的“观看电影”接口交互即可。

这个“智能遥控器”就是外观，它简化了与整个家庭影院子系统（Subsystem）的交互。

3. 解决的问题：降低客户端与复杂子系统之间的耦合

在软件系统中，我们常常会遇到一些功能复杂的模块或库（子系统），它们由许多个类组成，类与类之间有着复杂的依赖关系。

问题：

使用困难：客户端（调用方）为了完成一个简单的任务，可能需要了解子系统内部的很多类和它们的交互方式，这增加了客户端的复杂性。
紧密耦合：客户端代码与子系统中的多个类直接绑定。如果子系统将来进行重构或升级（比如换了一个新的DVD播放机类），所有使用到它的客户端代码都需要修改。

外观模式的解决方案：引入一个外观类（Facade Class），它作为客户端和子系统之间的“中间人”。

客户端只与外观类交互。
外观类负责理解子系统的复杂逻辑，并将客户端的请求委托给子系统中正确的对象进行处理。

4. 外观模式的结构与参与者

外观模式的结构非常简单，主要包含三个角色：

Facade (外观)
- 这是模式的核心。
- 它知道需要与哪些子系统类进行交互来满足客户端的请求。
- 它将客户端的请求代理给相应的子系统对象。
- 它为客户端提供了一个简化的、高层的接口。
Subsystem Classes (子系统类)
- 实现子系统的具体功能。
- 处理由 Facade 对象指派的任务。
- 关键点：子系统类并不知道外观的存在，它们可以被独立使用。外观模式只是在它们之上增加了一个简化的层。
Client (客户端)
- 通过调用 Facade 的接口来与子系统进行交互。
- 由于 Facade 的存在，客户端不需要直接与复杂的子系统打交道。

5. Java 代码示例（家庭影院）

步骤1: 创建子系统类 (Subsystem Classes)

// 子系统类 1: DVD播放机
public class DvdPlayer {
    public void on() { System.out.println("DVD Player on"); }
    public void off() { System.out.println("DVD Player off"); }
    public void play(String movie) { System.out.println("DVD Player playing \"" + movie + "\""); }
}

// 子系统类 2: 投影仪
public class Projector {
    public void on() { System.out.println("Projector on"); }
    public void off() { System.out.println("Projector off"); }
    public void wideScreenMode() { System.out.println("Projector in widescreen mode (16x9 aspect ratio)"); }
}

// 子系统类 3: 灯光
public class TheaterLights {
    public void dim(int level) { System.out.println("Theater Ceiling Lights dimming to " + level + "%"); }
    public void on() { System.out.println("Theater Ceiling Lights on"); }
}

// 子系统类 4: 幕布
public class Screen {
    public void up() { System.out.println("Theater Screen going up"); }
    public void down() { System.out.println("Theater Screen going down"); }
}

步骤2: 创建外观类 (Facade)

外观类持有所有子系统对象的引用，并提供简化的方法。

public class HomeTheaterFacade {
    // 组合了所有子系统组件
    private DvdPlayer dvd;
    private Projector projector;
    private TheaterLights lights;
    private Screen screen;

    public HomeTheaterFacade(DvdPlayer dvd, Projector projector, TheaterLights lights, Screen screen) {
        this.dvd = dvd;
        this.projector = projector;
        this.lights = lights;
        this.screen = screen;
    }

    // 提供一个简单的方法来完成一系列复杂操作
    public void watchMovie(String movie) {
        System.out.println("Get ready to watch a movie...");
        lights.dim(10);
        screen.down();
        projector.on();
        projector.wideScreenMode();
        dvd.on();
        dvd.play(movie);
    }

    // 提供另一个简单的方法
    public void endMovie() {
        System.out.println("\nShutting movie theater down...");
        lights.on();
        screen.up();
        projector.off();
        dvd.off();
    }
}

步骤3: 客户端调用

客户端现在只需要与 HomeTheaterFacade 交互。

public class FacadePatternDemo {
    public static void main(String[] args) {
        // 1. 准备好所有子系统组件
        DvdPlayer dvd = new DvdPlayer();
        Projector projector = new Projector();
        Screen screen = new Screen();
        TheaterLights lights = new TheaterLights();

        // 2. 创建外观对象，并将组件传入
        HomeTheaterFacade homeTheater = new HomeTheaterFacade(dvd, projector, lights, screen);

        // 3. 使用简单的接口来操作
        homeTheater.watchMovie("Inception");
        homeTheater.endMovie();
    }
}

输出结果:

Get ready to watch a movie...
Theater Ceiling Lights dimming to 10%
Theater Screen going down
Projector on
Projector in widescreen mode (16x9 aspect ratio)
DVD Player on
DVD Player playing "Inception"

Shutting movie theater down...
Theater Ceiling Lights on
Theater Screen going up
Projector off
DVD Player off

可以看到，客户端代码非常简洁，完全不知道背后复杂的调用流程。

6. 优缺点

优点

降低了客户端的复杂性：客户端无需了解子系统的内部结构，只需与外观交互。
实现了客户端与子系统之间的解耦：当子系统内部发生变化时，只要外观的接口不变，客户端代码就无需修改。
提高了子系统的独立性和可移植性：子系统本身不依赖于外观，可以被其他部分复用。
提供了更好的系统分层：外观模式是构建分层系统的有效手段，每一层都可以为上一层提供一个外观，从而简化层与层之间的依赖。

缺点

不符合开闭原则：如果需要为子系统增加新的行为，可能需要修改外观类的源代码。
可能变成“上帝对象”（God Object）：如果一个外观类承载了过多的功能，它本身可能会变得非常庞大和复杂，难以维护。
不阻止直接访问子系统：外观模式只是提供了一个便捷的入口，它并不限制客户端直接去调用子系统的类（当然，这也可以看作是一种灵活性）。

7. 适用场景

当你需要为一个复杂的子系统提供一个简单的接口时。
当你想将客户端与子系统的实现解耦时。
当你需要构建一个分层结构，并希望简化层与层之间的通信时。例如，Service层可以作为DAO层的外观，供Controller层调用。
当你使用的第三方库过于复杂，希望封装它，提供更简洁的API给自己的系统使用时。

8. 与其他模式的比较

与适配器模式（Adapter Pattern）的区别：
- 意图不同：外观模式旨在简化接口，而适配器模式旨在转换接口以兼容不同的类。
- 封装性：外观封装了整个子系统，而适配器只封装了一个对象。
与代理模式（Proxy Pattern）的区别：
- 接口：代理模式提供与原对象相同的接口，并在此基础上增加额外的控制（如权限、懒加载）；外观模式提供一个不同且更简单的接口。
与中介者模式（Mediator Pattern）的区别：
- 通信方式：外观模式是单向的，客户端通过外观调用子系统，子系统不知道外观的存在；中介者模式是多向的，它协调一组对象（同事类）之间的复杂交互，同事类之间通过中介者通信，并且知道中介者的存在。

希望这个详细的介绍能帮助你理解外观模式的精髓！