[A].总结6.接口隔离：门面模式，代理模式，适配器模式，中介者模式

声明：本栏目的 [A] 系列的学习笔记，学习对象为 B 站授课视频 C++设计模式（李建忠），参考教材为《设计模式：可复用面向对象软件的基础》。本栏目 [A] 系列文章中的图件和笔记，部份来自上述资源。

从封装变化角度对模式分类！：

• 组件协作
• 单一职责
• 对象创建
• 对象性能
• 接口隔离
  在组件构建过程中，某些接口之间直接的依赖常常会带来很多问题、甚至根本无法实现。采用添加一层间接（稳定）接口，来隔离本来互相紧密关联的接口是一种常见的解决方案。
  典型模式
  • 门面模式 Facade
  • 代理模式 Proxy
  • 适配器模式 Adapter
  • 中介者模式 Mediator
• 状态变化
• 数据结构
• 行为变化
• 领域问题

门面模式 Facade

• 子系统内部与客户系统产生很多紧耦合的对象，如果不加处理，系统会非常的散乱，如上A方案。B方案，有个间接层 Facade，将客户系统与子系统隔离，客户系统 和 子系统 都只与 Facade 打交道。
• 动机：上述A方案的问题在于组件的客户和组件中各种复杂的子系统有了过多的耦合，随着外部客户程序和子系统的演化，这种过多的耦合面临很多变化的挑战。
• 如何简化外部客户系统和系统之间的交互接口？如何将外部客户程序的演化和内部子系统的变化之间的依赖相互解耦？
• 定义：为子系统中的一组接口提供一个一致（稳定）的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用（复用）。
  

代理模式 Proxy

定义：为其他对象提供一种代理以控制（隔离，使用接口）对这个对象的访问。

• 模式结构：如上图，接口是 subject，实际的对象是 RealSubject，client 通过接口 subject 去 创造 RealSubject 的对象，但是由于访问控制，安全方面，性能优化或者分布式方面的考虑，那么client 可能需要先访问 Proxy ，先做一下很复杂的工作。
• 场景举例：客户端 ClientApp （创建）访问 对象RealSubject 。
• （1）直接访问如下：

class ISubject{
public:
    virtual void process();
};

class RealSubject: public ISubject{  // 直接访问 realsubject
public:
    virtual void process(){
        //....
    }
};

class ClientApp{
    ISubject* subject;
public:
    ClientApp(){
        subject=new RealSubject(); // 直接访问 realsubject
    }
    void DoTask(){
        //...
        subject->process();
        //....
    }
};

• （2）通过代理层间接访问 RealSubject ：

class ISubject{
public:
    virtual void process();
};

//Proxy的设计
class SubjectProxy: public ISubject{

public:
    virtual void process(){
        //对RealSubject的一种间接访问
        //做一些安全控制，性能提升等工作
        // ...
    }
};

class ClientApp{
    ISubject* subject;
public:

    ClientApp(){
        subject=new SubjectProxy();  // 访问 proxy
    }

    void DoTask(){
        //...
        subject->process(); // proxy内部间接访问realsubject。
        //....
    }
};

• 注意 代理类 SubjectProxy 和实际类 RealSubject 的基类一致，且内部成员函数名称也是一致的，使得客户端访问接口，感觉是一样的访问行为。
• 代理模式的主要目的是通过增加间接层，来实现一些不为外界所知的功能，如性能优化等。

适配器模式 Adapter

• 定义：将一个类的接口转换成客户希望的另一个接口。adpater模式使得原本由于接口不兼容而不能一起工作的那些类 可以一起工作。
  

//目标接口（新接口）
class ITarget{
public:
    virtual void process()=0;
};
//遗留接口（老接口）
class IAdaptee{
public:
    virtual void foo(int data)=0;
    virtual int bar()=0;
};
//遗留类型
class OldClass: public IAdaptee{
    //....
};

//对象适配器
class Adapter: public ITarget{ //继承
protected:
    IAdaptee* pAdaptee;//组合
public:
    Adapter(IAdaptee* pAdaptee){
        this->pAdaptee=pAdaptee;
    }
    virtual void process(){
        int data=pAdaptee->bar();
        pAdaptee->foo(data);
    }
};

//类适配器
// public继承公有接口，符合父类的接口规范。
// protected是实现继承，意思是我继承你是为了使用你的实现方法，不需要符合你的接口规范。
class Adapter: public ITarget, 
               protected OldClass{ //多继承
//...
}

int main(){
    IAdaptee* pAdaptee=new OldClass();

    /// 将一个旧的class 给 适配器，然后就可以将适配器当成新的类使用。
    ITarget* pTarget=new Adapter(pAdaptee);
    pTarget->process();
}
/// C++ STL中 stack 和 queue就是适配器，他们能将旧的类 deque，转成新的类使用。
class stack{
    deqeue container;
    //...
};

class queue{
    deqeue container;
	//...
};

• 适配器分为对象适配器和类适配器。类适配器采用多继承，继承了老的遗留接口，不好不推荐。对象适配器采用对象组合，将老的遗留接口作为成员变量，更具灵活性。他们的目的都是使用老的遗留接口，构建新的成员函数适配新目标接口。
  

中介者模式 Mediator

• 定义：用一个中介对象来封装（封装变化）一系列的对象交互。中介者使得各个对象不需要显式的相互引用（编译时依赖 —> 运行时依赖），从而使其耦合松散（管理变化），而且可以独立的改变他们之间的交互。
  
• 如上图，具体实现类1和具体实现类2 直接互不依赖，但是都依赖具体中介者类，中介者类又与实现类双向依赖。核心思想就是对于多个对象，a,b,c,d,e,他们之间互相依赖，关系复杂。中介者模式加入一个中介者类 M，a 如果要依赖 c，不需要直接依赖 c, 而是依赖 M，M 依赖 c，M中集中管理多个对象之间的依赖关系。