【设计模式】结构型-门面模式

最新推荐文章于 2024-07-26 23:39:00 发布
最新推荐文章于 2024-07-26 23:39:00 发布
阅读量963 收藏 14
点赞数 37
分类专栏： 设计模式篇 文章标签： 设计模式 java
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/learnerdl/article/details/139362134
版权

前言

在软件开发中，设计模式是解决特定问题的经验总结，为开发者提供了一种可复用的解决方案。其中，门面模式（Facade Pattern）是一种结构型模式，旨在为复杂系统提供简化的接口，使客户端与系统之间的交互更加简单。

一、复杂的系统

// 子系统 A
class SubSystemA {
    public void operationA() {
        // 子系统 A 的操作
    }
}

// 子系统 B
class SubSystemB {
    public void operationB() {
        // 子系统 B 的操作
    }
}

// 子系统 C
class SubSystemC {
    public void operationC() {
        // 子系统 C 的操作
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        SubSystemA subSystemA = new SubSystemA();
        SubSystemB subSystemB = new SubSystemB();
        SubSystemC subSystemC = new SubSystemC();

        // 客户端需要分别调用三个子系统的操作
        subSystemA.operationA();
        subSystemB.operationB();
        subSystemC.operationC();
    }
}

在上面的例子中，客户端需要知道每个子系统的具体操作方法，并且直接调用它们。如果子系统的接口发生变化，客户端代码也需要相应地进行修改，这就违反了开闭原则。此外，如果有新的子系统加入或现有子系统的行为需要扩展，客户端代码可能需要进行大量的修改，这带来了未知的风险。

复杂的系统可能会有以下问题：

  1. 系统复杂性增加：客户端需要了解和处理多个子系统的接口，增加了学习和使用的难度。
  2. 代码可维护性降低：直接与多个子系统交互会使得代码耦合度增加，难以维护和扩展。
  3. 代码重复：不同的客户端可能需要重复编写相同的逻辑来处理子系统的交互。

二、门面模式

门面模式（Facade Pattern）也被称为外观模式是一种结构型设计模式，它提供了一个统一的接口，用于访问系统中的一组接口或子系统。门面模式通过将复杂的系统分解为多个子系统，并为这些子系统提供一个统一的门面，从而隐藏了系统的复杂性，使得客户端可以更轻松地使用系统的功能。

门面模式的特点：

  1. 简化接口： 门面模式通过提供一个简化的接口，隐藏了系统内部复杂的结构和实现细节，使得客户端可以更轻松地使用系统功能。
  2. 解耦： 门面模式可以帮助将客户端与系统的各个子系统解耦。客户端只需与门面对象进行交互，而不需要直接与各个子系统进行通信，从而降低了系统的耦合度。
  3. 提高易用性： 门面模式提供了一个统一的接口供客户端使用，使得客户端无需了解系统的内部结构和复杂性，只需调用门面类提供的方法即可完成相应的操作，从而提高了系统的易用性。
  4. 增强安全性： 通过门面模式，可以限制客户端对系统的访问，只暴露必要的接口给客户端使用，从而增强了系统的安全性，防止客户端直接访问系统中的敏感信息或方法。
  5. 提高可维护性： 由于门面模式将系统的复杂性封装起来，使得系统更易于维护。如果系统的内部结构发生变化，只需修改门面而不影响客户端，从而降低了系统的维护成本。

三、门面模式的核心组成部分

门面模式的核心组成包括以下几个要素：

  1. 门面（Facade）： 门面是门面模式的核心部分，它提供了一个简单的接口，用于隐藏系统中复杂的子系统或组件的实现细节。客户端通过与门面对象交互来访问系统的功能，而无需了解系统内部的结构和实现。
  2. 子系统（Subsystems）： 子系统是构成系统的各个模块或组件，负责实际的业务逻辑和功能实现。门面模式通过与子系统交互来完成客户端的请求。子系统可以是单个对象，也可以是一组相关的对象。
  3. 客户端（Client）： 客户端是使用门面模式的应用程序的一部分，它通过与门面对象交互来访问系统的功能。客户端不需要直接与系统中的子系统进行交互，而是通过门面对象间接地与子系统进行通信，从而简化了客户端的代码。

在这里插入图片描述

这个类图表示了门面模式的结构，其中包括客户端（Client）、门面（Facade）以及两个子系统（SubSystemA 和 SubSystemB）。客户端通过与门面对象进行交互来访问系统的功能，而门面对象则负责与各个子系统进行通信和协调。

四、运用门面模式

场景假设：计算机的启动包括了多个复杂的子系统，比如 BIOS（基本输入/输出系统）、操作系统加载、设备初始化等。门面模式可以很好地用来简化这个过程，让客户端无需了解启动过程中的复杂细节，只需通过一个接口来启动计算机。

  1. 确定子系统： 首先，需要确定系统中的各个子系统，即系统中具有复杂功能或业务逻辑的模块或组件。这些子系统通常由多个类组成，彼此之间存在一定的依赖关系。

    // 子系统 - BIOS
class BIOS {
    public void powerOn() {
        System.out.println("BIOS: Power on self-test (POST)...");
    }
}

// 子系统 - 操作系统
class OperatingSystem {
    public void load() {
        System.out.println("Operating System: Loading...");
    }
}

// 子系统 - 设备初始化
class DeviceInitialization {
    public void initialize() {
        System.out.println("Device Initialization: Initializing devices...");
    }
}

  2. 设计门面： 接下来，设计一个门面类，用于封装这些子系统，并提供一个简化的接口供客户端使用。门面类的职责是将客户端的请求委派给系统中的各个子系统进行处理，客户端只需通过门面类来与系统进行交互，而无需了解系统内部的复杂结构。

    // 门面类 - 计算机启动门面
class ComputerStartupFacade {
    private BIOS bios;
    private OperatingSystem os;
    private DeviceInitialization deviceInit;

    // 构造方法，初始化子系统对象
    public ComputerStartupFacade() {
        this.bios = new BIOS();
        this.os = new OperatingSystem();
        this.deviceInit = new DeviceInitialization();
    }

    // 启动计算机的方法，对外提供的简化接口
    public void startComputer() {
        System.out.println("Computer Startup: Starting...");
        bios.powerOn(); // 调用 BIOS 子系统的启动自检方法
        deviceInit.initialize(); // 调用设备初始化子系统的初始化方法
        os.load(); // 调用操作系统子系统的加载方法
        System.out.println("Computer Startup: Ready for use.");
    }
}

  3. 编写客户端代码： 最后，编写客户端代码，使用门面类来完成所需的操作，而不需要直接与子系统进行交互。客户端通过调用门面类提供的方法来访问系统的功能，从而实现了对系统的简化访问。

    // 客户端
public class Client {
    public static void main(String[] args) {
        // 使用门面类启动计算机
        ComputerStartupFacade computerFacade = new ComputerStartupFacade();
        computerFacade.startComputer();
    }
}

在使用了门面模式之后，客户端不再直接与各个子系统交互，而是通过门面类的方法来进行操作。这样做有几个好处：

  1. 简化客户端的使用：客户端只需要知道门面类的接口，而不需要了解各个子系统的细节。
  2. 降低耦合度：门面类封装了子系统的交互，减少了客户端与子系统之间的直接依赖。
  3. 提高代码的可维护性：如果子系统的实现发生变化，只需要在门面类中进行修改，客户端代码可以保持不变。

五、门面模式的应用场景

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

  1. 简化复杂系统的使用：当子系统变得复杂且包含多个相互依赖的类时，门面模式可以提供一个简单的接口，使得外部调用者无需理解复杂的内部工作机制即可使用子系统。

    // 子系统类
class ComplexSystem {
    public void complexMethod() { /* 复杂操作 */ }
}

// 门面类
class SimpleInterface {
    private ComplexSystem complexSystem = new ComplexSystem();

    public void simpleMethod() {
        complexSystem.complexMethod();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        SimpleInterface facade = new SimpleInterface();
        facade.simpleMethod(); // 客户端只需调用简单方法
    }
}

  2. 统一接口：门面模式可以将多个子系统的接口整合成一个统一的接口，为用户提供更简单的访问方式，从而提高用户体验。

    // 子系统类
class SubSystemOne {
    public void methodOne() { /* 方法一 */ }
}
class SubSystemTwo {
    public void methodTwo() { /* 方法二 */ }
}

// 门面类
class UnifiedInterface {
    private SubSystemOne one = new SubSystemOne();
    private SubSystemTwo two = new SubSystemTwo();

    public void unifiedMethod() {
        one.methodOne();
        two.methodTwo();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        UnifiedInterface facade = new UnifiedInterface();
        facade.unifiedMethod(); // 通过统一接口调用多个子系统方法
    }
}

  3. 降低耦合度：通过创建门面，可以降低客户端和子系统之间的直接依赖关系，使得子系统的变更对客户端影响最小。

    // 子系统类
class SubSystemA {
    public void operationA() { /* 操作A */ }
}
class SubSystemB {
    public void operationB() { /* 操作B */ }

// 门面类
class Facade {
    private SubSystemA a = new SubSystemA();
    private SubSystemB b = new SubSystemB();

    public void operation() {
        a.operationA();
        b.operationB();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.operation(); // 客户端通过门面类降低与子系统的耦合
    }
}

  4. 性能优化：在网络通信中，通过将多个接口调用替换为一个门面接口调用，可以减少网络通信成本，提高应用程序的响应速度。

    // 子系统类
class PerformanceSubsystem {
    public void complexCalculation() { /* 复杂计算 */ }
}

// 门面类
class PerformanceFacade {
    private PerformanceSubsystem subsystem = new PerformanceSubsystem();

    public void optimizePerformance() {
        subsystem.complexCalculation();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        PerformanceFacade facade = new PerformanceFacade();
        facade.optimizePerformance(); // 通过门面类优化性能
    }
}

  5. 解决分布式事务问题：在需要执行多个操作且这些操作需要在同一个事务中完成时，门面模式可以封装这些操作，确保它们在同一事务中一起执行，从而简化分布式事务的处理。

    // 子系统类
class TransactionSubsystem {
    public void startTransaction() { /* 开始事务 */ }
    public void commitTransaction() { /* 提交事务 */ }
}

// 门面类
class TransactionFacade {
    private TransactionSubsystem transactionSubsystem = new TransactionSubsystem();

    public void performTransaction() {
        transactionSubsystem.startTransaction();
        // 执行事务相关操作
        transactionSubsystem.commitTransaction();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        TransactionFacade facade = new TransactionFacade();
        facade.performTransaction(); // 通过门面类处理分布式事务
    }
}

  6. 安全性：门面可以作为一个访问层，控制对子系统的访问，增强安全性。

    // 子系统类
class SecuritySubsystem {
    public void checkSecurity() { /* 安全检查 */ }
}

// 门面类
class SecurityFacade {
    private SecuritySubsystem securitySubsystem = new SecuritySubsystem();

    public void ensureSecurity() {
        securitySubsystem.checkSecurity();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        SecurityFacade facade = new SecurityFacade();
        facade.ensureSecurity(); // 通过门面类增强安全性
    }
}

  7. 遗留系统的整合：对于遗留系统或第三方库，门面模式可以提供一个更现代、简化的接口，使得新系统能够更容易地与旧系统或第三方库进行交互。

    // 遗留子系统类
class LegacySubsystem {
    public void legacyOperation() { /* 遗留操作 */ }
}

// 门面类
class IntegrationFacade {
    private LegacySubsystem legacySubsystem = new LegacySubsystem();

    public void integrateSystem() {
        legacySubsystem.legacyOperation();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        IntegrationFacade facade = new IntegrationFacade();
        facade.integrateSystem(); // 通过门面类整合遗留系统
    }
}

  8. 多个系统交互：当有多个系统需要交互时，门面模式可以提供一个共同的接口，使得系统间的交互更加清晰和简单。

    // 多个子系统类
class SystemOne {
    public void actionOne() { /* 行动一 */ }
}
class SystemTwo {
    public void actionTwo() { /* 行动二 */ }

// 门面类
class InteractionFacade {
    private SystemOne one = new SystemOne();
    private SystemTwo two = new SystemTwo();

    public void interact() {
        one.actionOne();
        two.actionTwo();
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        InteractionFacade facade = new InteractionFacade();
        facade.interact(); // 通过门面类处理多个系统的交互
    }
}

六、小结

门面模式是一种用于简化复杂系统的设计模式，它通过提供简单的接口隐藏了系统的复杂性，使得客户端能够更轻松地使用系统。通过将系统的各个子系统封装起来，门面模式可以帮助降低系统的耦合度，并提高系统的可维护性和可扩展性。在设计软件系统时，我们可以考虑使用门面模式来简化系统的接口，提高系统的易用性和可维护性。

推荐阅读

  1. Spring 三级缓存
  2. 深入了解 MyBatis 插件：定制化你的持久层框架
  3. Zookeeper 注册中心：单机部署
  4. 【JavaScript】探索 JavaScript 中的解构赋值
  5. 深入理解 JavaScript 中的 Promise、async 和 await
DC1020
关注
  • 37
    点赞
  • 踩
  • 14
    收藏
    觉得还不错? 一键收藏
  • 2
    评论
专栏目录
c++设计模式-结构型模式-外观模式
06-13
c++设计模式-结构型模式-外观模式；qt工程；c++简单源码； 外观（Facade）模式又叫作门面模式，是一种通过为多个复杂的子系统提供一个一致的接口，而使这些子系统更加容易被访问的模式。该模式对外有一个统一接口，...
设计模式原理与应用之结构型模式.pptx
09-28
结构型模式是设计模式的一种分类，它关注如何组合类和对象，构建更大的结构。本篇主要讨论了七种结构型模式：Adapter、Bridge、Composite、Decorator、Façade、Flyweight和Proxy。 1. **Adapter模式**： - 适配器...
灸哥讲解结构型设计模式
01-17
总结，灸哥讲解的结构型设计模式涵盖了门面模式、组合模式、装饰器模式、适配器模式和享元模式，这些都是在后端开发中，尤其是在JAVA语言中非常重要的设计模式。理解并灵活运用这些模式，能够帮助开发者编写出更加...
7.设计模式-门面模式1
08-03
门面（Facade）模式是一种设计模式，它在软件工程中被广泛使用，目的是为了提供一个更简单、更统一的接口来访问复杂的子系统。通过门面模式，客户端（调用者）无需直接与子系统中的多个组件交互，而是只需要与门面...
设计模式之门面模式.docx
09-28
门面模式，作为设计模式的一种，旨在为复杂的子系统提供一个简洁统一的接口，从而简化客户端与子系统之间的交互。这种模式由三个主要角色构成：门面角色、子系统角色和客户角色。门面角色是核心，它理解子系统的功能...
12. Hibernate 模板设计模式
这是一个web全栈开发的博客，取其精华去其糟粕，争取让大家一看就懂，一学就会，一用就成~
07-22 1258
如何运用模板设计模式重构 Hibernate 操作流程；持久化对象与序列化接口；OOP中有一个编码原则 ：写仅写一次。翻译过来就是，不要重复，要重用。答案是：使用模板设计模式进一步封装Hibernate的操作。在真实项目中，Hibernate仅仅只是完成项目中的一部分工作，需要和其它，如Spring等框架联合工作，一起承担整体项目的开发。Spring框架中就提供的有Hibernate模板对象。一个常规的、频繁的操作代码中，大部分代码不需要变动，只有小部分代码需要根据需求变动。
设计模式实战：日志系统的设计与实现
最新发布
qq_40254606的博客
07-26 386
通过本项目，我们综合应用了单例模式、适配器模式和桥接模式，解决了日志系统的设计需求。通过这些模式，我们实现了系统模块的解耦和灵活扩展，使得代码结构更加清晰、易于维护。
【设计模式】建造者模式
weixin_61144851的博客
07-23 913
这些设计模式提供了一种在创建对象的同时隐藏创建逻辑的方式，而不是使用 new 运算符直接实例化对象。这使得程序在判断针对某个给定实例需要创建哪些对象时更加灵活。：这些模式关注对象之间的组合和关系，旨在解决如何构建灵活且可复用的类和对象结构。：这些模式关注对象之间的通信和交互，旨在解决对象之间的责任分配和算法的封装。
C# 设计模式分类
語衣的个人博客
07-23 876
创建型模式主要关注对象的创建过程，包括如何实例化对象，并隐藏实例化的细节。结构型模式主要关注类和对象的组合，以形成更大的结构。行为型模式主要关注对象之间的通信和职责分配。
设计模式的作用、场景以及示例【快速入门，体验拉满，按需使用】
Dream的博客
07-22 698
设计模式（Design pattern）：是针对设计问题的通用解决方案。 使用设计模式：可以把它应用到特定的应用中，用于解决相似的问题。 使用设计模式是为了可重用代码、让代码更容易被他人理解、保证代码可靠性。 真正理解什么是设计模式，就是要透彻理解OO的四大要素：封装、继承、多态和关联。其中核心是封装的概念。
js 优雅的实现模板方法设计模式
qq_43985303的博客
07-24 298
在JavaScript中，优雅地实现模板方法设计模式通常意味着我们要遵循一些最佳实践，如清晰地定义算法的骨架（模板方法），并确保子类能够灵活地扩展或修改这些算法中的特定步骤。此外，由于JavaScript的类和继承是基于原型的，因此这种实现方式也充分利用了JavaScript的继承机制，使得代码更加符合JavaScript的编程习惯。优雅性：通过提供默认实现，避免了在子类中必须实现所有方法的强制性要求，从而提高了代码的优雅性。灵活性：子类可以自由地选择覆盖哪些钩子方法，以及覆盖后的行为是什么。
6.3 面向对象技术-设计模式
m0_38066007的博客
07-26 401
设计模式
DP学习——状态模式
huibin.yun的博客
07-22 521
学而时习之，温故而知新。
DP学习——外观模式
huibin.yun的博客
07-24 268
学而时习之，温故而知新。
设计模式-策略模式
我这个代码你能看懂吗？
07-22 563
在Java中实现策略模式，可以通过定义一个策略接口和多个具体策略类，然后在上下文类中使用这些策略。
C++20之设计模式（19）：空对象
weixin_51332735的博客
07-26 435
空对象
【软考】设计模式之生成器模式
王佑辉的博客
07-26 352
1.造者模式所创建的产品一般具有较多的共同点，其组成部分相似，如果产品之间的差异性很大，则不适合使用建造者模式，因此其使用范围受到一定的限制。3.当一个类的构造函数包含多个参数，或者这些参数是相互依赖的，或者创建对象的步骤很多时，使用生成器模式可以简化对象的创建过程。（Product）角色：表示被构建的复杂对象。3.当一个对象需要被构建成不同的表示时，使用生成器模式可以轻松地通过不同的生成器来创建不同的表示。5.当一个对象需要被构建成不同的表示时，使用生成器模式可以轻松地通过不同的生成器来创建不同的表示。
设计模式13-单件模式
qq_41810539的博客
07-24 868
面向对象很好的解决了抽象的问题，但是必不可免的要付出一定的代价（类空间的重复分配等）。对于通常情况来讲，面向对象的成本大多都可以忽略不计。但某些情况面向对象所在的成本必须谨慎处理。设计模式中的对象性能模式是指那些专注于提高系统性能、优化资源使用和管理的设计模式。这些模式通过有效的对象创建、共享、复用和管理策略，减少内存占用、提高运行效率，从而提升整体系统性能。保证一个类仅有一个实力，并提供一个该实例的全局访问点。线程不安全版本：简单但在多线程环境下不安全。线程安全版本（锁代价高）
设计模式-适配器模式
qq_25699299的博客
07-22 490
适配器模式（Adapter Pattern）是一种软件设计模式，它能使接口不兼容的两个类可以协同工作。该模式的核心是转换接口，将一个类的接口转换成客户端期望的另一个接口。在C#中，适配器模式可以通过继承或者组合的方式实现。这里使用了组合的方式，的接口，这样客户端就可以通过。类型的实例，并且实现了。
灸哥解读：结构型设计模式详解
"灸哥讲解结构型设计模式，包括门面模式、组合模式、装饰器模式、适配器模式、享元模式、代理模式和桥接模式，详细介绍了每个模式的定义、使用原因、实现方法以及优缺点和解决方案。" 在软件设计中，结构型设计模式...
评论 2
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值