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

发布于:2024-11-29 ⋅ 阅读:(19) ⋅ 点赞:(0)

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:提供了一个简化的接口,用来访问子系统中的多个类。它内部包含了对各个子系统类的引用,并负责协调这些子系统类之间的交互。
  • SubSystemClassA 和 SubSystemClassB:代表了子系统的不同部分,它们各自完成特定的功能。这些类对外部是不可见的,只有通过 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. 可能会导致外观类过于臃肿:如果子系统的功能非常复杂,外观类可能会变得非常庞大,不易维护。
适用场景
  • 当需要为一个复杂的子系统提供一个简单接口时。
  • 当客户端需要与多个子系统交互,但只希望暴露有限的接口时。
  • 当需要减少系统之间或系统与其他系统之间的依赖关系时。