设计模式十一：facade（外观）——对象结构型模式

最新推荐文章于 2025-09-08 14:13:53 发布

weixin_30555125

最新推荐文章于 2025-09-08 14:13:53 发布

阅读量62

点赞数

CC 4.0 BY-SA版权

文章标签：设计模式

原文链接：http://www.cnblogs.com/w0w0/archive/2012/05/20/2509461.html

本文深入探讨了外观（Facade）设计模式的核心概念、适用场景及其如何简化系统使用过程。通过实例分析，展示了如何利用外观模式降低客户端与复杂子系统间的耦合度，以及在不同情况下的优势。

facade（外观）——对象结构型模式

1.意图
为子系统中的一组接口提供一个一致的界面，facade定义了一个高层接口，这个接口使得这一子系统更加容易使用。

2.动机
将一个系统划分为若干个子系统有利于降低系统的复杂性，一个常见的设计目标是使子系统之间的通信和相互依赖关系达到最小。达到该目标的途径之一就是引入一个facade对象，为子系统中比较一般的设施提供了一个单一而简单的界面。

3.适用性
1）当你要为一个复杂子系统提供一个简单接口时，子系统往往因为不断演化而变得越来越复杂，大多数模式使用时都会产生更多更小的类。这使得子系统更具可重用性，也更容易对子系统进行定制，但是这也给那些不需要定制子系统的用户带来困难。
facade定制了一个简单的缺省视图，这对大多数用户已经足够，而那些需要更多定制性的用户可以直接越过facade层。
2）客户程序与抽象类的实现部分之间存在着很大的依赖性。引入facade将这个子系统与客户以及其他子系统分离，可以提高系统的可移植性。
3）当你需要构建一个层次结构的子系统时，使用facade模式定义子系统中每层的入口点，如果子系统时相互依赖的，那么你可以让他们仅通过facade进行通信，就可以简化他们之间的依赖关系

4.结构

参考：http://www.cnblogs.com/god_bless_you/archive/2010/06/08/1753652.html

5.参与者
facade
知道哪些子系统类负责处理请求
将客户的请求代理给适当的子系统对象
subsystem classes
实现子系统的功能
处理由facade对象指派的任务
没有facade的任何相关信息，即没有指向facade的指针

6.协作
客户程序通过发送请求给facade的方式与子系统通信，facade将这些消息转发给适当的子系统对象。尽管是子系统中的有关对象在做实际工作，但是facade模式本身也必须将他的接口转换成子系统的接口。
使用facade的客户程序不需要直接访问子系统对象。

7.效果
优点：
1）对客户屏蔽子系统组件，因而减少了客户处理的对象的数目并且使得子系统使用起来更加方便。
2）实现子系统与客户之间的松耦合关系，而子系统内部往往是紧耦合的。
3）如果需要，并不限制应用使用子系统类，可以在易用性和通用性之间做出选择。

8.实现
1）降低客户和子系统之间的耦合度
用抽象类实现facade而他具体的子类对应于不同的子系统实现，可以进一步降低客户与子系统的耦合度。
另一种方法是用不同的子系统对象配置facade对象。为定制facade，仅需要对它的子系统对象进行替换即可。
2）公共子系统类与私有子系统类

9.代码示例

#include<iostream>
using namespace std;

class wheel
{
    public:
    void run()
    {
        cout<<"a wheel running"<<endl;
    }
    void stop()
    {
        cout<<"a wheel stop"<<endl;
    }
};
class engin
{
    public:
    void run()
    {
        cout<<"a engin running"<<endl;
    }
    void stop()
    {
        cout<<"a engin stop"<<endl;
    }
};

class driver
{
    public:
    driver(string d)
    {
        driverName = d;
    }
    void run()
    {
        cout<<driverName<<" starts the car"<<endl;
    }
    void stop()
    {
        cout<<driverName<<" stops the car"<<endl;
    }

private:
    string driverName;
};

class car
{
    public:
    car(string str)
    {
        name = str;
        for(int i=0;i<4;i++)
        {
            wheels[i] = new wheel();
        }
        en = new engin();
    }
    string getName()
    {
        return name;
    }

    wheel *wheels[4]；
    engin *en;
private:
    string name;
};

class carFacade
{
    public:
    carFacade(string cName, string dName)
    {
        c = new car(cName);
        d = new driver(dName);
    }
    void run()
    {
        cout<<"a car name: "<<c->getName()<<endl;
        d->run();
        c->en->run();
        for(int i = 0;i<4;i++)
        {
            c->wheels[i]->run();
        }
    }
    void stop()
    {
        cout<<"a car name: "<<c->getName()<<endl;
        d->stop();
        c->en->stop();
        for(int i = 0;i<4;i++)
        {
            c->wheels[i]->stop();
        }
    }

private:
    car *c;
    driver *d;
};

int main()
{
    carFacade *c = new carFacade("BMW","w0w0");
    c->run();
    c->stop();
    
    carFacade *cc = new carFacade("Benz","unknowName");
    cc->run();
    cc->stop();
    return 0;
}

10.相关模式
abstractFactory可以与facade模式一起使用以提供一个接口，这一接口可以用来以一种子系统独立的方式创建子系统对象，abstractFactory也可以代替facade模式隐藏那些与平台相关的类。
mediator与facade的相似之处是，他抽象了一些已有的类的功能。mediator的目的是对同事之间的任意通讯进行抽象，通常几种不属于任何一个对象的功能。同事的对象知道中介者并与他通信，而不是直接与其他同类对象通信。
而facade仅对子系统的接口进行抽象，不定义新功能，子系统也不知道facade的存在。

转载于:https://www.cnblogs.com/w0w0/archive/2012/05/20/2509461.html