【设计模式】【结构型模式(Structural Patterns)】之外观模式(Facade Pattern)

1. 设计模式原理说明

外观模式(Facade Pattern) 是一种结构型设计模式,它提供了一个统一的接口,用来访问子系统中的一群接口。外观模式定义了一个高层接口,这个接口使得这一子系统更加容易使用。通过隐藏子系统的复杂性,外观模式简化了客户端对子系统的使用,提高了系统的易用性和降低了解耦程度。

主要角色
  1. Facade(外观):为子系统的类提供一个简化的接口。
  2. SubSystem Classes(子系统类):实现了子系统的功能,处理由 Facade 对象指派的工作。任何数目的子系统类都可以存在,它们不知道 Facade 的存在。

2. UML 类图及解释

UML 类图
复制代码
+-----------------+                +-----------------+
|     Facade      |                | SubSystemClassA |
|-----------------|                |-----------------|
| - subsystemA: SubSystemClassA |  | + operationA(): void|
| - subsystemB: SubSystemClassB |  +-----------------+
| + operation(): void          |  
| + subOperationA(): void      |  +-----------------+
| + subOperationB(): void      |  | SubSystemClassB |
+-----------------+            |  |-----------------|
                               |  | + operationB(): void|
                               |  +-----------------+
类图解释
  • Facade:提供了一个简化的接口,用来访问子系统中的多个类。它内部包含了对各个子系统类的引用,并负责协调这些子系统类之间的交互。
  • SubSystemClassASubSystemClassB:代表了子系统的不同部分,它们各自完成特定的功能。这些类对外部是不可见的,只有通过 Facade 提供的接口才能访问它们。

3. 代码案例及逻辑详解

Java 代码案例
复制代码
// 子系统类 A
class SubSystemClassA {
    public void operationA() {
        System.out.println("SubSystemClassA operationA");
    }
}

// 子系统类 B
class SubSystemClassB {
    public void operationB() {
        System.out.println("SubSystemClassB operationB");
    }
}

// 外观
class Facade {
    private SubSystemClassA subsystemA = new SubSystemClassA();
    private SubSystemClassB subsystemB = new SubSystemClassB();

    public void operation() {
        subsystemA.operationA();
        subsystemB.operationB();
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Facade facade = new Facade();
        facade.operation();
        // 输出:
        // SubSystemClassA operationA
        // SubSystemClassB operationB
    }
}
C++ 代码案例
复制代码
#include <iostream>

// 子系统类 A
class SubSystemClassA {
public:
    void operationA() {
        std::cout << "SubSystemClassA operationA" << std::endl;
    }
};

// 子系统类 B
class SubSystemClassB {
public:
    void operationB() {
        std::cout << "SubSystemClassB operationB" << std::endl;
    }
};

// 外观
class Facade {
private:
    SubSystemClassA subsystemA;
    SubSystemClassB subsystemB;

public:
    void operation() {
        subsystemA.operationA();
        subsystemB.operationB();
    }
};

// 客户端
int main() {
    Facade facade;
    facade.operation();
    // 输出:
    // SubSystemClassA operationA
    // SubSystemClassB operationB
    return 0;
}
Python 代码案例
复制代码
# 子系统类 A
class SubSystemClassA:
    def operationA(self):
        print("SubSystemClassA operationA")

# 子系统类 B
class SubSystemClassB:
    def operationB(self):
        print("SubSystemClassB operationB")

# 外观
class Facade:
    def __init__(self):
        self.subsystemA = SubSystemClassA()
        self.subsystemB = SubSystemClassB()

    def operation(self):
        self.subsystemA.operationA()
        self.subsystemB.operationB()

# 客户端
if __name__ == "__main__":
    facade = Facade()
    facade.operation()
    # 输出:
    # SubSystemClassA operationA
    # SubSystemClassB operationB
Go 代码案例
复制代码
package main

import "fmt"

// 子系统类 A
type SubSystemClassA struct{}

func (a *SubSystemClassA) OperationA() {
    fmt.Println("SubSystemClassA operationA")
}

// 子系统类 B
type SubSystemClassB struct{}

func (b *SubSystemClassB) OperationB() {
    fmt.Println("SubSystemClassB operationB")
}

// 外观
type Facade struct {
    subsystemA *SubSystemClassA
    subsystemB *SubSystemClassB
}

func NewFacade() *Facade {
    return &Facade{
        subsystemA: &SubSystemClassA{},
        subsystemB: &SubSystemClassB{},
    }
}

func (f *Facade) Operation() {
    f.subsystemA.OperationA()
    f.subsystemB.OperationB()
}

// 客户端
func main() {
    facade := NewFacade()
    facade.Operation()
    // 输出:
    // SubSystemClassA operationA
    // SubSystemClassB operationB
}

4. 总结

外观模式 是一种结构型设计模式,它提供了一个统一的接口,用来访问子系统中的一群接口。通过隐藏子系统的复杂性,外观模式简化了客户端对子系统的使用,提高了系统的易用性和降低了系统的耦合度。

主要优点
  1. 简化了客户端的使用:通过提供一个简单的接口,客户端无需关心子系统的内部细节,从而简化了客户端的代码。
  2. 解耦了客户端和子系统:客户端只需要依赖于外观,而不需要直接依赖于子系统中的各个类,从而降低了系统的耦合度。
  3. 提高了子系统的独立性:子系统可以独立地发展和变化,而不影响到外观和客户端。
主要缺点
  1. 不符合开闭原则:如果子系统发生变化,外观类也需要相应地进行修改。
  2. 可能会导致外观类过于臃肿:如果子系统的功能非常复杂,外观类可能会变得非常庞大,不易维护。
适用场景
  • 当需要为一个复杂的子系统提供一个简单接口时。
  • 当客户端需要与多个子系统交互,但只希望暴露有限的接口时。
  • 当需要减少系统之间或系统与其他系统之间的依赖关系时。
相关推荐
晨米酱5 小时前
JavaScript 中"对象即函数"设计模式
前端·设计模式
数据智能老司机10 小时前
精通 Python 设计模式——分布式系统模式
python·设计模式·架构
数据智能老司机11 小时前
精通 Python 设计模式——并发与异步模式
python·设计模式·编程语言
数据智能老司机11 小时前
精通 Python 设计模式——测试模式
python·设计模式·架构
数据智能老司机11 小时前
精通 Python 设计模式——性能模式
python·设计模式·架构
使一颗心免于哀伤11 小时前
《设计模式之禅》笔记摘录 - 21.状态模式
笔记·设计模式
数据智能老司机1 天前
精通 Python 设计模式——创建型设计模式
python·设计模式·架构
数据智能老司机1 天前
精通 Python 设计模式——SOLID 原则
python·设计模式·架构
烛阴1 天前
【TS 设计模式完全指南】懒加载、缓存与权限控制:代理模式在 TypeScript 中的三大妙用
javascript·设计模式·typescript
李广坤1 天前
工厂模式
设计模式