设计模式---接口隔离模式之门面模式（Façade）

前提：接口隔离模式

在组建构建过程中，某些接口之间直接的依赖常常会带来很多问题、甚至根本无法实现。采用添加一层间接接口（稳定的），来隔离本来相互紧密关联的接口是一种常见的解决方案。

典型模式：

门面模式：Façade，
代理模式：Proxy，
适配器模式：Adapter，
中介者模式：Mediator

一：门面模式（外观模式）

推文：外观模式 Facade Pattern

（一）概念

Facade模式也叫外观模式，是由GoF提出的23种设计模式中的一种。
Facade模式为一组具有类似功能的类群，比如类库，子系统等等，提供一个一致的简单的界面。这个一致的简单的界面被称作facade。

为子系统中统一一套接口

（二）动机

上述方案A的问题在于组件的客户和组件中的各种复杂的子系统有了过多的耦合，随着外部客户程序和子系统的演化，这种过多的耦合面临很多变化的挑战。

如何简化外部客户程序和系统间的交互接口？如何将外部客户程序的演化和内部子系统的变化之间的依赖相互解耦。

（三）系统间耦合的复杂度

（四）模式定义

为子系统中的一组接口提供一个一致（稳定）的界面，Facade模式定义了一个高层接口，这个接口使得这一子系统更加容易使用（复用）。
                                                                                  --《设计模式》Gof

（五）结构（没有特定的模式）

不同场景，变化相差较大

（六）要点总结： （将子系统的变化限制在一个范围内）

1.从客户程序的角度来看， Façade 模式简化了整个组件系统的接口。对于内部和外部客户程序来说， Façade 模式实现了一种解耦的效果——即内部的子系统的任何变化不会影响到 Façade 接口的变化。

2.Façade 设计模式更注重从架构的层次去看待整个系统，而不是单个类的层次。Façade 很多时候更是一种架构设计模式。

3.Façade 设计模式并非是一个集装箱，可以任意的放入任何多个对象。Facade模式中组件的内部应该是“相互耦合关系比较大的一系列组件”，而不是简单的功能集合，以便能够实现松耦合，高内聚的特性。

（七）案例实现：子系统接口统一

#include <iostream>
using namespace std;

//子系统组成，各个部分关系较大的一系列组件
class SystemA
{
public:
    void doThing()
    {
        cout << "systemA do..." << endl;
    }
};

class SystemB
{
public:
    void doThing()
    {
        cout << "SystemB do..." << endl;
    }
};

class SystemC
{
public:
    void doThing()
    {
        cout << "SystemC do..." << endl;
    }
};

class Facade
{
private:
    SystemA* a;
    SystemB* b;
    SystemC* c;
public:
    Facade()
    {
        a = new SystemA();
        b = new SystemB();
        c = new SystemC();
    }

    ~Facade()
    {
        delete[] a;
        delete[] b;
        delete[] c;
    }

    void doThing()    //接口提供稳定，降低耦合，提高内聚
    {    //统一接口中没有必须按照某种步骤，不要把建造者模式混淆
        a->doThing();
        b->doThing();
        c->doThing();
    }
};

void main()
{
    Facade* f = new Facade();
    f->doThing();
    delete f;

    system("pause");
    return;
}

（七）案例实现：基金购买方案

#include <iostream>
using namespace std;

class Fund
{
public:
    virtual void purchase() = ;
    virtual ~Fund(){}
};

class ForeignExchange :public Fund
{
public:
    virtual void purchase()
    {
        cout << "purchase foreign exchange" << endl;
    }
};

class Futures :public Fund
{
public:
    virtual void purchase()
    {
        cout << "purchase futures" << endl;
    }
};

class Shares :public Fund
{
public:
    virtual void purchase()
    {
        cout << "purchase shares" << endl;
    }
};

class NationalDebt :public Fund
{
public:
    virtual void purchase()
    {
        cout << "purchase national debt" << endl;
    }
};

class PurFacade
{
private:
    ForeignExchange* fe;
    Shares* s;
    Futures* f;
    NationalDebt* nd;
public:
    PurFacade()
    {
        fe = new ForeignExchange();
        s = new Shares();
        f = new Futures();
        nd = new NationalDebt();
    }

    void Interface1()
    {
        fe->purchase();
        s->purchase();
    }

    void Interface2()
    {
        fe->purchase();
        f->purchase();
    }

    void Interface3()
    {
        fe->purchase();
        nd->purchase();
    }

    //...多种接口
};

void main()
{
    PurFacade* pf = new PurFacade();

    pf->Interface1();
    pf->Interface3();

    system("pause");
    return;
}