【设计模式详解】外观模式：简化复杂系统接口的大门，一键式接入，无忧使用 C++代码详解实现

前言：

        今天一起来聊一聊结构型设计模式：外观模式

一、原理及C++代码示例

外观模式是一种结构型设计模式，它提供了一个统一的接口，用于访问子系统中的一组接口。外观模式隐藏了子系统的复杂性，并为客户端提供了一个更简单的接口，以便于使用子系统。这种模式涉及一个单一的类，该类提供了一个简单的接口，用于与子系统中的一组接口进行交互。

在外观模式中，有一个外观类，它封装了与客户端交互所需的接口。这个外观类知道子系统中的类，并将客户端的请求委托给适当的子系统对象。

以下是一个C++的外观模式示例：

#include <iostream>

// 子系统A
class SubsystemA {
public:
    void operationA() {
        std::cout << "SubsystemA operation\n";
    }
};

// 子系统B
class SubsystemB {
public:
    void operationB() {
        std::cout << "SubsystemB operation\n";
    }
};

// 外观类
class Facade {
private:
    SubsystemA subsystemA;
    SubsystemB subsystemB;

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

int main() {
    Facade facade;
    facade.operation();
    return 0;
}

在这个示例中，Facade 类充当外观类，封装了 SubsystemA 和 SubsystemB 的操作，并为客户端提供了一个简单的接口。客户端只需调用 Facade 类的 operation 方法，而不需要了解底层子系统的复杂性。

二、结构图

外观模式的结构图如下所示：

-----------------------------------------
|               Client                  |
-----------------------------------------
      |                               |
      |                               |
-----------------------------------------
|               Facade                  |
-----------------------------------------
| - subsystem1: Subsystem1             |
| - subsystem2: Subsystem2             |
| - subsystem3: Subsystem3             |
-----------------------------------------
      |                               |
-----------------------------------------
|               Subsystem1              |
-----------------------------------------
| + operation1()                       |
-----------------------------------------
      |                               |
-----------------------------------------
|               Subsystem2              |
-----------------------------------------
| + operation2()                       |
-----------------------------------------
      |                               |
-----------------------------------------
|               Subsystem3              |
-----------------------------------------
| + operation3()                       |
-----------------------------------------

三、使用场景：

外观模式通常适用于以下场景：

1. 当需要为复杂子系统提供一个简单接口时，可以使用外观模式。这样客户端就不需要了解子系统的复杂性。
2. 当希望将子系统与客户端解耦时，可以使用外观模式。外观模式可以隐藏子系统的实现细节，从而降低了客户端和子系统之间的依赖性。
3. 当需要对子系统进行重构时，可以使用外观模式。外观模式可以帮助我们逐步重构复杂的子系统，而不会对客户端产生影响。

下面分别给出在这些场景下的C++示例代码：

场景一：为复杂子系统提供一个简单接口

// 复杂子系统
class Subsystem {
public:
    void operation1() {
        std::cout << "Subsystem operation1\n";
    }
    void operation2() {
        std::cout << "Subsystem operation2\n";
    }
    void operation3() {
        std::cout << "Subsystem operation3\n";
    }
};

// 外观类
class Facade {
private:
    Subsystem subsystem;

public:
    void operation() {
        subsystem.operation1();
        subsystem.operation2();
        subsystem.operation3();
    }
};

int main() {
    Facade facade;
    facade.operation();
    return 0;
}

场景二：将子系统与客户端解耦

// 子系统A
class SubsystemA {
public:
    void operationA() {
        std::cout << "SubsystemA operation\n";
    }
};

// 子系统B
class SubsystemB {
public:
    void operationB() {
        std::cout << "SubsystemB operation\n";
    }
};

// 外观类
class Facade {
private:
    SubsystemA subsystemA;
    SubsystemB subsystemB;

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

int main() {
    Facade facade;
    facade.operation();
    return 0;
}

场景三：对子系统进行重构

// 子系统A
class SubsystemA {
public:
    void operationA() {
        std::cout << "SubsystemA operation\n";
    }
};

// 子系统B
class SubsystemB {
public:
    void operationB() {
        std::cout << "SubsystemB operation\n";
    }
};

// 外观类
class Facade {
private:
    SubsystemA subsystemA;
    SubsystemB subsystemB;

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

int main() {
    Facade facade;
    facade.operation();
    return 0;
}

四、优缺点：

外观模式具有以下优点和缺点：

优点：

1. 简化了客户端与子系统之间的交互。客户端只需要与外观类进行交互，而不需要了解子系统的复杂性。
2. 减少了客户端与子系统之间的依赖关系。客户端只依赖于外观类，而不需要直接依赖于子系统。
3. 提高了子系统的灵活性和可维护性。外观模式可以隐藏子系统的实现细节，使得子系统的修改和维护更加容易。

缺点：

1. 可能会导致外观类变得过于庞大。如果子系统非常复杂，外观类可能会变得庞大，难以维护和理解。
2. 不符合开闭原则。当需要添加新的子系统或者修改现有子系统时，可能需要修改外观类，违反了开闭原则。

总体来说，外观模式可以帮助我们简化复杂系统的接口，降低客户端与子系统之间的耦合度，但在设计时需要注意避免外观类变得过于庞大，以及遵循开闭原则。

      4
  
              +---+ 
              |   | 
              |   | 3                       3 
              |   | 
              |   +---+                   ----- 
              |       |                   |   | 
            2 |       |                 2 |   |     2 
              |       |                   |   | 
          +---+       |               ----+   |   +---+ 
          |           |               |       |   |   | 
        1 |           | 1           1 |       | 1 |   | 1 
          |           |               |       |   |   | 
      +---+           +---+       +---+       +---+   +---+       +----
      |                   |       |                       |       |    |
    0 |                   | 0   0 |                       | 0       |    |
      |                   |       |                       |       |    |
  +---+                   +-------+                       +---+---+----+---+
  
    0   1   2   3   4   5   6   7   8   9  10  11  12  13  14  15 16   17  18