Orange Ink

深浅模式

聚合搜索平台项目 ​

门面模式（Facade Pattern）详解 ​

1. 定义 ​

门面模式（Facade Pattern）是一种结构型设计模式，它提供了一个统一的接口，用于访问子系统中的一组接口。这个模式通过定义一个高层接口（Facade），隐藏子系统的复杂性，从而降低客户端与子系统之间的耦合性，使客户端更容易使用子系统。

2. 核心思想 ​

  • 简化客户端使用子系统的方式：客户端不需要直接与子系统的多个模块交互，而是通过门面类进行访问。
  • 降低耦合度：客户端代码不直接依赖子系统的具体实现，而是依赖门面类，从而减少了代码之间的耦合。
  • 隐藏系统复杂性：子系统的复杂逻辑对外部不可见，外部只需要调用门面类的接口即可。

3. 应用场景 ​

门面模式适用于以下场景：

  1. 简化子系统的使用：子系统包含多个模块或接口，提供一个简单的访问方式。
  2. 降低耦合：避免外部代码直接依赖子系统的实现，便于后续的维护和升级。
  3. 统一接口：为复杂的子系统提供统一的访问接口，方便客户端调用。

4. 结构 ​

门面模式通常由以下几个部分组成：

  • Facade（门面类）：提供统一的对外接口，隐藏子系统的复杂性。
  • Subsystem（子系统）：实现系统的实际功能，每个子系统都可以独立工作。
  • Client（客户端）：使用门面类来与子系统交互，而不是直接访问子系统的各个模块。

类图：

plain
diff


复制编辑
+---------------------+
|      Client        |
+---------------------+
         |
         v
+---------------------+
|      Facade        |  (门面类)
+---------------------+
| + operationA()     |
| + operationB()     |
+---------------------+
         |
         v
--------------------------------------
|        Subsystem1       Subsystem2  |
|  + method1()             + method2()|
|  + method3()             + method4()|
--------------------------------------

5. 示例代码 ​

场景： 假设我们要开发一个家庭影院系统，它由多个子系统（音响、投影仪、播放器等）组成，用户可以通过门面类 HomeTheaterFacade 进行一键式操作。

plain
java


复制编辑
// 子系统1：播放器
class Player {
    public void on() {
        System.out.println("播放器已开启");
    }
    public void play() {
        System.out.println("播放电影");
    }
    public void off() {
        System.out.println("播放器已关闭");
    }
}

// 子系统2：投影仪
class Projector {
    public void on() {
        System.out.println("投影仪已开启");
    }
    public void focus() {
        System.out.println("投影仪对焦中");
    }
    public void off() {
        System.out.println("投影仪已关闭");
    }
}

// 子系统3：音响
class Speaker {
    public void on() {
        System.out.println("音响已开启");
    }
    public void setVolume(int level) {
        System.out.println("音量设置为：" + level);
    }
    public void off() {
        System.out.println("音响已关闭");
    }
}

// 门面类
class HomeTheaterFacade {
    private Player player;
    private Projector projector;
    private Speaker speaker;

    public HomeTheaterFacade(Player player, Projector projector, Speaker speaker) {
        this.player = player;
        this.projector = projector;
        this.speaker = speaker;
    }

    public void watchMovie() {
        System.out.println("准备播放电影...");
        projector.on();
        projector.focus();
        player.on();
        player.play();
        speaker.on();
        speaker.setVolume(10);
        System.out.println("电影开始播放！");
    }

    public void endMovie() {
        System.out.println("关闭家庭影院...");
        player.off();
        projector.off();
        speaker.off();
        System.out.println("家庭影院已关闭！");
    }
}

// 客户端调用
public class Main {
    public static void main(String[] args) {
        Player player = new Player();
        Projector projector = new Projector();
        Speaker speaker = new Speaker();

        HomeTheaterFacade homeTheater = new HomeTheaterFacade(player, projector, speaker);
        homeTheater.watchMovie(); // 一键启动
        homeTheater.endMovie();   // 一键关闭
    }
}

运行结果：

plain
复制编辑
准备播放电影...
投影仪已开启
投影仪对焦中
播放器已开启
播放电影
音响已开启
音量设置为：10
电影开始播放！
关闭家庭影院...
播放器已关闭
投影仪已关闭
音响已关闭
家庭影院已关闭！

6. 优缺点 ​

优点 ​

  1. 简化接口：隐藏了子系统的复杂性，为客户端提供了更直观的调用方式。
  2. 降低耦合度：客户端不直接依赖子系统的具体实现，便于系统扩展和维护。
  3. 提高代码可读性：让系统的调用流程更加清晰，符合“高内聚、低耦合”的设计原则。

缺点 ​

  1. 增加类数量：引入了额外的门面类，会增加类的数量，可能导致代码量增加。
  2. 不易扩展：如果门面类提供的方法不能满足需求，需要修改门面类，可能会影响多个客户端。

7. 与其他设计模式的关系 ​

  • 与适配器模式（Adapter）：

    • 门面模式是为子系统提供一个更友好的接口，而适配器模式是为了让两个不兼容的接口可以协同工作。

  • 与中介者模式（Mediator）：

    • 门面模式强调对子系统的封装，客户端只与门面类交互，而中介者模式用于组件之间的解耦，组件通过中介者进行通信。

8. 总结 ​

门面模式是软件开发中常用的模式之一，特别适用于需要简化系统接口、降低模块之间耦合度的场景。它能够让复杂的系统对外表现得更加简单，提高代码的可维护性和可读性。适当地使用门面模式，可以让代码更加清晰，减少不必要的依赖关系。

适配器模式（Adapter Pattern）详解 ​

1. 定义 ​

适配器模式（Adapter Pattern） 是一种 结构型设计模式，它的作用是将一个接口转换成客户端期望的另一个接口，使得原本不兼容的接口可以一起工作。适配器模式类似于“插座转换器”，它可以让不兼容的对象协同工作，而无需修改它们的源代码。

2. 适配器模式的核心思想 ​

  1. 解决接口不兼容问题：适配器模式的主要作用是使不兼容的接口可以一起工作。
  2. 对已有代码进行适配：适配器模式可以在不修改原有代码的情况下，增加新功能，使其能够与现有系统兼容。
  3. 提供代码复用：通过适配器，可以让已有的类在新的环境下复用，而不必修改其实现。

3. 适配器模式的应用场景 ​

适配器模式适用于以下情况：

  1. 已有的类和新需求不兼容，但又无法修改已有类的源码。
  2. 希望复用已有的类，但其接口与现有系统不匹配。
  3. 希望统一多个类的接口，以便于系统处理。

4. 适配器模式的结构 ​

适配器模式包含以下几个核心角色：

  • 目标接口（Target）：客户端期望使用的接口。
  • 适配者（Adaptee）：需要适配的类，通常是已有的、与目标接口不兼容的类。
  • 适配器（Adapter）：适配器实现目标接口，并将请求转换为适配者能够处理的形式。
  • 客户端（Client）：调用目标接口的对象，它使用适配器来间接调用适配者的方法。

类图：

img

5. 适配器模式的实现方式 ​

适配器模式有两种常见实现方式：

  1. 类适配器模式（基于继承，使用 Java 的 extends 关键字）
  2. 对象适配器模式（基于组合，使用 Java 的成员变量）

6. 示例代码 ​

场景： 假设我们有一个旧的 Adaptee 类，它有一个 specificRequest() 方法，而客户端希望调用 request() 方法。我们使用适配器模式来解决这个问题。

方式一：类适配器模式（基于继承） ​

java
// 目标接口（Target）
interface Target {
    void request(); // 客户端期望的方法
}

// 适配者（Adaptee）：已有的类，但接口不兼容
class Adaptee {
    public void specificRequest() {
        System.out.println("适配者中的 specificRequest() 方法被调用");
    }
}

// 适配器（Adapter）：继承适配者并实现目标接口
class Adapter extends Adaptee implements Target {
    @Override
    public void request() {
        System.out.println("适配器在适配...");
        specificRequest(); // 调用适配者的方法
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Target target = new Adapter();
        target.request(); // 通过适配器调用适配者的方法
    }
}

输出结果：

plain
适配器在适配...
适配者中的 specificRequest() 方法被调用

方式二：对象适配器模式（基于组合） ​

java
// 目标接口（Target）
interface Target {
    void request();
}

// 适配者（Adaptee）
class Adaptee {
    public void specificRequest() {
        System.out.println("适配者中的 specificRequest() 方法被调用");
    }
}

// 适配器（Adapter）：使用组合方式
class Adapter implements Target {
    private Adaptee adaptee; // 组合适配者

    public Adapter(Adaptee adaptee) {
        this.adaptee = adaptee;
    }

    @Override
    public void request() {
        System.out.println("适配器在适配...");
        adaptee.specificRequest(); // 调用适配者的方法
    }
}

// 客户端代码
public class Main {
    public static void main(String[] args) {
        Adaptee adaptee = new Adaptee();
        Target target = new Adapter(adaptee);
        target.request(); // 通过适配器调用适配者的方法
    }
}

输出结果：

plain
适配器在适配...
适配者中的 specificRequest() 方法被调用

7. 适配器模式的优缺点 ​

优点 ​

✅ 提高代码复用：适配器模式让已有的类可以在新的系统中使用，而不需要修改其代码。 ✅ 解耦代码：适配器模式将目标接口与具体实现解耦，使代码更加灵活。 ✅ 符合开闭原则：可以在不修改已有代码的情况下进行扩展。

缺点 ​

❌ 增加系统复杂度：增加了额外的类和对象，可能使系统变得更复杂。 ❌ 性能开销：适配器模式通常需要额外的调用层，可能会影响性能（但通常影响不大）。

8. 适配器模式 vs. 其他模式 ​

设计模式适配器模式的区别
门面模式（Facade）门面模式是提供一个新的接口来简化访问，而适配器模式是转换现有接口以实现兼容性。
装饰器模式（Decorator）装饰器模式用于增强对象功能，而适配器模式用于接口转换。
桥接模式（Bridge）桥接模式将抽象部分和实现部分分离，而适配器模式主要用于让已有的类适配新接口。

9. 适配器模式的实际应用 ​

  1. Java IO 体系
    • InputStreamReader 适配 InputStream，让字节流转换成字符流。
    • OutputStreamWriter 适配 OutputStream，让字符流转换成字节流。
  1. Spring 框架
    • HandlerAdapter 适配不同的 Controller 处理请求，使它们能够兼容 DispatcherServlet。
  1. 数据库驱动
    • JDBC 通过适配器模式使得不同数据库厂商的驱动能够使用相同的 Connection、Statement 等接口。

10. 总结 ​

适配器模式是让不兼容的接口能够协同工作的模式，它常用于已有系统的兼容性改造，让旧代码适配新需求。它有类适配器（基于继承）和对象适配器（基于组合）两种实现方式，各有优缺点。在实际开发中，对象适配器更加常见，因为它遵循合成复用原则，更加灵活。

如果你有具体的使用场景需要分析或更深入的理解，欢迎交流！ 😊

Copyright © 2025-present Evan You