Mediator - 中介者模式

定义

用一个中介对象来封装一系列的对象的交互。中介者使各对象不需要显示地相互使用，从而使其耦合松散，而且可以独立的改变他们之间的交互。

案例

比如有一个图像界面，在界面上有一个输入框LineEdit，有个一个列表框ListBox，有一个按钮Button。当输入框LineEdit没有内容的时候，按钮是灰显，不可用的，当在LineEdit输入了正确的选项后，ListBox也会跳转到改选项，Button被激活，可以操作。同样ListBox也可以选择不同的选项，改变LineEdit的内容，当Button可以使用的时候可以删除被选中的选项，这样各个窗口间有比较强的依赖关系，可以通过将集体行为封装在一个单独的中介者Mediator对象中来避免这个问题：

Mediator定义了中介类的一个接口：

   
   
class Mediator {
public:
    virtual void showDialog() = 0;
    virtual void widgetChanged(Widget*) = 0;
protected:
     Mediator();
     virtual void createWidgets() = 0;
};

Widget是所有窗口类的基类：

   
   
class Widget {
public:
    Widget(Mediator* mediator) { m_mediator = mediator; }
    virtual void changed(){ }
    Mediator* mediator() const { return m_mediator; }
private:
    Mediator* m_mediator; 
};

LineEdit类是一个文字输入窗口类：

   
   
class LineEdit : public Widget {
public:
    LineEdit(Mediator*);
    virtual void changed();
    void setText(const string& text);
    string text() const;
private:
    string m_text;
};
void LineEdit::changed() 
{
    mediator()->widgetChanged(this);
}

Button和ListBox都是继承自Widget的类，并实现了自己独有的操作。

现在创建一个DialogMediator类把所有的窗口类联系起来：

   
   
class DialogMediator : public Mediator {
public:
    virtual void widgetChanged(Widget* widget);
    virtual void showDialog();
protected:
    virtual void createWidgets();
private:
    LineEdit* m_lineEdit;
    ListBox* m_listBox;
    Button* m_button;
};
void DialogMediator::createWidgets()
{
    m_lineEdit = new LineEdit();
    ...
}
void DialogMediator::widgetChanged(Widget* widget)
{
    if(widget == m_lineEdit)
    {
        m_listBox->setSelection(m_lineEdit->text());
        m_button->setEnable(true);
    }
    else if(m_listBox)
    {
        m_lineEdit->setText(m_listBox->getSeletion());
        m_button->setEnable(true);
    }
    else
    {
        m_lineEdit->setText("");
        m_listBox->setSelection(lastOne);
    }
}

    
    
DialogMediator mediator;
mediator.createWidgets();
mediator.showDialog();

适用性

• 一组对象以定义良好但是通过复杂的方式进行通信，产生的依赖结构混乱
• 一个对象引用其他很多对象并且直接与这些对象进行通信，导致难以复用该对象
• 想定制一个分布在多个类中的行为，而不想生成太多的子类

优缺点

1. 减少了子类的生成
2. 将各个类进行了解耦
3. 简化了对象协议，一对多的关系易于理解
4. 对对象如何协作进行了抽象
5. 使控制集中化，使得中介者类自身庞大，难于维护