设计模式十八：mediator（中介者模式）——对象行为型模式

mediator（中介者模式）——对象行为型模式

 


1.意图
用一个中介对象来封装一系列的对象交互。中介者使不同对象不需要显式地相互引用，从而使其松散耦合，从而使得可以独立地改变他们之间的交互。

 

 

2.动机
面向对象设计鼓励将行为分部到各个对象中，这种分部可能会导致对象间有许多连接。在最坏的情况下，每个对象都知道其他所有的对象。
虽然将一个系统分隔成很多对象通常会增加可复用性，但是对象间的相互连接的激增又会降低其可复用性。
可以通过将集体行为封装在一个单独的中介者对象中以避免这个问题，中介者负责控制和协调对象间的交互。中介者充当一个中介以使组中的对象不再相互显式的引用。这些对象仅知道中介者，从而减少了相互连接的数目。

 


3.适用性
1）一组对象定义良好但是以复杂的方式进行通信。产生相互依赖的关系结构混乱而且难以理解
2）一个对象引用其他很多对象并且直接与这些对象通信，导致难以复用该对象
3）想定制一个分布在各个类中的行为，而又不想产生太多的子类

 

 

4.结构

 

 

 

 

 

 

参考：http://www.cnblogs.com/singlepine/archive/2005/10/30/265007.html

 

 

5.参与者
mediator中介者
中介者定义一个借口用于与各个同时对象通信
concreteMediator具体中介者
具体中介者通过协调各同事对象实现协作行为
了解并维护它的各个同事
colleague class同事类
每个同事类都知道它的中介者对象
每一个同事对象在需要与其他的同事通信的时候，与它的中介者通信

 

 

6.协作
同事向一个中介者对象发送和接收请求。中介者在各个同事之间适当的转发请求以实现协作。

 

 

7.效果
1）减少子类的生成
2）将各个colleague解耦
3）简化对象的协议
4）对对象如何让协作进行了抽象
5）使控制集中化

 

 

8.实现
1）忽略抽象的mediator类
当各个colleague仅仅与一个mediator类通信时，没有必要定义一个抽象的mediator类
2）colleague——mediator通信
当一个感兴趣的事件发生时，colleague必须与其mediator通信。

 

 

9.代码示例

 

#include<iostream>
#include<string>
using namespace std;

class company
{
public:
    company(string str)
    {
        name = str;
    }
    void setName(string str)
    {
        name = str;
    }
    string getName()
    {
        return name;
    }
    virtual void sale(){};
    virtual void buy(){};
private:
    string name;
};

class chinaCompany:public company
{
public:
    chinaCompany(string str):company(str){};
    void sale()
    {
        cout<<getName()<<" sale sth"<<endl;
    }
    void buy()
    {
        cout<<getName()<<" buy sth"<<endl;
    }
};

class AmericaCompany:public company
{
public:
    AmericaCompany(string str):company(str){};
    void sale()
    {
        cout<<getName()<<" sale sth"<<endl;
    }
    void buy()
    {
        cout<<getName()<<" buy sth"<<endl;
    }
};

class companyUnion
{
public:
    companyUnion()
    {
        for(int i=0;i<10;i++)
            list[i]=0;
        maxlen=0;
    }
    void join(company *c)
    {
        list[maxlen]=c;
        maxlen++;
        cout<<c->getName()<<" join the company union"<<endl;
    }
    int find(company *c)
    {
        for(int i=0;i<maxlen;i++)
        {
            if(c->getName() == list[i]->getName())
                return i;
        }
        return -1;
    }
    void business(company *from, company *to)
    {
        int source = find(from);
        int dest = find(to);
        if(source == dest)
        {
            cout<<"you can't sell goods to yourself"<<endl;
            return;
        }
        list[source]->sale();
        list[dest]->buy();
    }
private:
    company *list[10];
    int maxlen;
};

int main()
{
    company *huawei = new chinaCompany("huawei");
    company *zet = new chinaCompany("ZET");
    company *cisco = new AmericaCompany("cisco");
    company *at = new AmericaCompany("AT&T");

    companyUnion *wto = new companyUnion();
    wto->join(huawei);
    wto->join(zet);
    wto->join(cisco);
    wto->join(at);

    cout<<endl;
    wto->business(huawei, zet);
    cout<<endl;
    wto->business(huawei, cisco);
    cout<<endl;
    wto->business(huawei, huawei);
    cout<<endl;
    wto->business(at, zet);
    cout<<endl;
    wto->business(cisco, zet);
    cout<<endl;
    wto->business(at, cisco);
    system("pause");
    return 0;
}

运行结果：

 

 

 

10.相关模式
facade模式
与中介者的不同是他是对一个对象的子系统进行抽象，从而提供了一个更为方便的接口。它的协议是单向的，仅有facade对象向这个子系统提出请求，但反之则不行。相反的，mediator提供各个colleague对象不支持或不能支持的协作行为，且是双向的。
colleague可使用observer模式和mediator通信


 

posted @ 2012-05-21 16:41  w0w0  阅读(264)  评论(0)  编辑  收藏  举报