C++设计模式——Facade外观模式
一，外观模式简介
外观模式是一种结构型设计模式， 又称为门面模式，也是一种基于创建对象来实现的模式，为子系统中的各组接口的使用提供了统一的访问入口。
外观模式对外提供了一个对象，让外部客户端(Client)对子系统的访问都是基于该对象来完成，这个对象被称为外观对象(Facade Object)，外观对象为子系统的访问提供了一个简单而且统一的入口。
客户端只需要关注Facade提供的对外接口的用法，而不需要关注子系统之间的复杂交互等细节。
举个例子，用户在电话购物的时候，可以不需要知道货物的流动和仓库处理等细节，只需要拨电话然后下单。
二，外观模式的结构
1.外观对象(Facade)：它的底层封装了系统的各个子模块，向用户屏蔽了底层的复杂结构，在内部调用各种子系统的函数，对外提供一些简化的接口。
2.子系统对象(SubSystem)：是组成复杂系统的各个独立模块，它们各自实现特定的功能，然后被Facade统一调用。
对应UML类图：
代码实现：
#include <iostream>
#include <vector>
using namespace std;
class SubSystem {
public:
virtual void operation() = 0;
};
class SubSystem_A: public SubSystem{
public:
void operation_A() {
cout << "Exec operation_A from SubSystem_A" << endl;
}
void operation() override {
operation_A();
}
};
class SubSystem_B: public SubSystem{
public:
void operation_B() {
cout << "Exec operation_B from SubSystem_B" << endl;
}
void operation() override {
operation_B();
}
};
class SubSystem_C: public SubSystem{
public:
void operation_C() {
cout << "Exec operation_C from SubSystem_C" << endl;
}
void operation() override {
operation_C();
}
};
class Facade {
private:
std::vector<SubSystem*> subsystems;
public:
Facade() {
subsystems.push_back(new SubSystem_A);
subsystems.push_back(new SubSystem_B);
subsystems.push_back(new SubSystem_C);
}
~Facade() {
for (auto* subsystem : subsystems) {
delete subsystem;
}
}
void executeOperations() {
for (auto& subsystem : subsystems) {
subsystem->operation();
}
}
};
int main() {
Facade facade;
facade.executeOperations();
return 0;
}
运行结果：
Exec operation_A from SubSystem_A
Exec operation_B from SubSystem_B
Exec operation_C from SubSystem_C
三，外观模式的应用场景
系统集成：当多个组件或服务接口需要被统一管理和使用时，借助外观模式构建一个统一的入口。
API升级：当API升级时，为了兼容旧版本的API接口的使用，创建一个外观模式的对象，既可以对外提供新的API接口，又向后兼容旧的API接口。
开发第三方库或框架：针对大型的库或者框架的开发，为了简化用户的使用，隐藏底层实现，对外提供一个简单且统一的接口。
组件整合：为了让项目中兼容不同架构和使用方式的组件时，使用外观模式来规范化组件的调用方式。
四，外观模式的优缺点
外观模式的优点：
1.减少了需要客户端关注和处理的对象数，简化了接口的使用方式。
2.实现了子系统和客户端之间的解耦，使子系统的变更不会影响到客户端的调用方法。
3.降低了大型软件的编译难度，简化了大型软件在不同平台之间的移植过程。
4.对外提供接口的同时，可以针对单个子系统实现单独的优化和升级。
5.避免了客户端对内部底层逻辑的影响和破坏。
6.促进了子系统的模块化和可重用性。
外观模式的缺点：
1.对底层的过度包装会增加性能开销。
2.如果设计的不合理，会使重构变得有难度。
3.如果存在访问共享资源的情况，代码的编写不够严谨时，相同层次的子系统和子系统之间可能会互相影响。
4.子系统和子系统之间可能包含相同的功能，导致代码冗余。
五，代码实战
Demo1：模拟计算机的集成
#include <iostream>
#include <string>
//subSystem
class Monitor {
public:
void turnOn() {
std::cout << "Monitor turned on.\n";
}
void turnOff() {
std::cout << "Monitor turned off.\n";
}
};
//subSystem
class Keyboard {
public:
void pressKey(int keyCode) {
std::cout << "Pressed key: " << keyCode << ".\n";
}
};
//subSystem
class CPU {
public:
void start() {
std::cout << "CPU started.\n";
}
void stop() {
std::cout << "CPU stopped.\n";
}
};
//Facade
class Computer {
private:
Monitor monitor;
Keyboard keyboard;
CPU cpu;
public:
Computer() {}
void turnOnAndStart() {
monitor.turnOn();
keyboard.pressKey(13);
cpu.start();
}
void shutDown() {
cpu.stop();
monitor.turnOff();
}
};
int main() {
Computer myComputer;
myComputer.turnOnAndStart();
myComputer.shutDown();
return 0;
}
运行结果：
Monitor turned on.
Pressed key: 13.
CPU started.
CPU stopped.
Monitor turned off.
Demo1：模拟汽车的集成
#include <iostream>
// Subsystem 1
class Engine {
public:
void Start()
{
std::cout << "Engine started" << std::endl;
}
void Stop()
{
std::cout << "Engine stopped" << std::endl;
}
};
// Subsystem 2
class Lights {
public:
void TurnOn() {
std::cout << "Lights on" << std::endl;
}
void TurnOff(){
std::cout << "Lights off" << std::endl;
}
};
// Facade
class Car {
private:
Engine engine;
Lights lights;
public:
void StartCar()
{
engine.Start();
lights.TurnOn();
std::cout << "Car is ready to drive" << std::endl;
}
void StopCar()
{
lights.TurnOff();
engine.Stop();
std::cout << "Car has stopped" << std::endl;
}
};
int main()
{
Car car;
car.StartCar();
car.StopCar();
return 0;
}
运行结果：
Engine started
Lights on
Car is ready to drive
Lights off
Engine stopped
Car has stopped
六，参考阅读
https://www.geeksforgeeks.org/facade-method-c-design-patterns/
https://sourcemaking.com/design_patterns/facade
https://refactoringguru.cn/design-patterns/facade
腾讯云开发者
