设计模式[21]-中介者模式-Mediator Pattern

1.中介者模式简介

中介者模式(Mediator Pattern)模式是是行为型(Behavioral)设计模式，用一个中介对象，来封装一系列对象的交互；中介者使各个对象不需要显示地互相引用，从而使耦合松散，而且可以独立地改变它们之间的交互。

对于一台电脑而言，CPU、显卡、声卡、硬盘等，都通过主板连接，它们之间的交互行为，也通过主板来实现。在这个例子中，主板就是中介者，CPU、内存等电脑配件就是松散耦合的对象。

在既往的企业应用系统整合中，ESB（企业服务总线 Enterprise Service Bus）也承担了中介者的角色。

如果不使用中介者模式，各个系统模块，或者说各个类之间，互相依赖，就会形成一个复杂的网装结构；使用了中介者模式，系统就变成了结构清晰的星形结构。

网状和星型.png

中介者模式一共有四种角色：

(1) Mediator（抽象中介者）：定义一个接口，用于各同事对象之间进行通信。

(2) ConcreteMediator（具体中介者）：是抽象中介者的子类，维持了多个同事类的引用，并协调各同事类的协作行为。

(3) Colleague（抽象同事类）：定义具体同事类的公共方法，维持了一个抽象中介者的引用，使得各子类可以和中介者通信。

(4)ConcreteColleague(具体同事类）：是抽象同事类的子类，只需要知道自己的行为即可，不需要孩子到其它同事的行为，但是它们都得认识中介者。

2. 中介者模式举例

序号	类名	角色	说明
1	Mediator	Mediator	抽象中介者
2	FanState	ConcreteMediator	具体中介者
3	AbstractColleague	Colleague	抽象同事类
4	FirstColleague	ConcreteColleague	具体同事类
5	SecondColleague	ConcreteColleague	具体同事类
6	MediatorMain	客户端	演示调用

Mediator.png

1. Mediator 抽象中介者类

/**
 * 抽象中介者
 */
public abstract class Mediator {

    /**
     * 一个示例操作
     *
     * @param colleague 发送消息的同事类
     * @param message 消息内容
     */
    public abstract void operate(AbstractColleague colleague, String message);

}

2. ConcreteMediator 具体中介者

/**
 *具体中介者
 */
public class ConcreteMediator extends Mediator {
    // 持有的具体同事类
    private FirstColleague firstColleague;
    private SecondColleague secondColleague;

    @Override
    public void operate(AbstractColleague colleague, String message) {
        // 同事类之间的交互通过中介者进行。
        // 这里只演示了两个同事类。
        if(colleague == firstColleague){
            secondColleague.receive(message);
        } else if(colleague == secondColleague) {
            firstColleague.receive(message);
        }
    }

    public void setFirstColleague(FirstColleague firstColleague) {
        this.firstColleague = firstColleague;
    }

    public void setSecondColleague(SecondColleague secondColleague) {
        this.secondColleague = secondColleague;
    }
}

3. AbstractColleague，抽象同事类

/**
 * 抽象同事类，如果具体的同事类之间没有公共的行为，其实可以不用抽象同事类。
 */
public abstract class AbstractColleague {

    // 持有中介者对象。
    protected Mediator mediator;

    // 构造器方式，注入中介者对象。
    public AbstractColleague(Mediator mediator) {
        this.mediator = mediator;
    }

    // 设值方式，注入中介者对象。
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

}

4. FirstColleague，具体同事类

/**
 * 具体同事类
 */
public class FirstColleague extends AbstractColleague{

    public FirstColleague(Mediator mediator) {
        super(mediator);
    }
    // 向中介者发送消息。
    public void send(String message){
        super.mediator.operate(this,message);
    }
    // 从中介者接收到的消息。
    public void receive(String message){
        System.out.println("First Colleague 收到消息：" + message);
    }
}

**5.SecondColleague，具体同事类 **

/**
 * 具体同事类
 */
public class SecondColleague extends AbstractColleague {

    public SecondColleague(Mediator mediator) {
        super(mediator);
    }
    // 向中介者发送消息。
    public void send(String message) {
        super.mediator.operate(this, message);
    }
    // 从中介者接收到的消息。
    public void receive(String message) {
        System.out.println("Second Colleague 收到消息：" + message);
    }
}

4. MediatorMain 演示类

public class MediatorMain {

    public static void main(String[] args){
        // 把同事类注册到中介者
        ConcreteMediator mediator = new ConcreteMediator();
        FirstColleague firstColleague = new FirstColleague(mediator);
        SecondColleague secondColleague = new SecondColleague(mediator);
        mediator.setFirstColleague(firstColleague);
        mediator.setSecondColleague(secondColleague);
        // 同事类之间通过中介者交互
        firstColleague.send("Hello World");
        secondColleague.send("Word Count");
    }
}

结果输出

Second Colleague 收到消息：Hello World
First Colleague 收到消息：Word Count

3. 总结

中介者模式简化了系统结构，从复杂的网状结构，变成了清晰的星型结构，从而简化了对象之间的交互，使得各同事对象可以各自的独立变化； 但是，中介者的角色就很重了，逻辑也很复杂。

中介者模式和代理模式

代理模式中，一个代理只代表一个主题对象，代理者和主题对象之间是一对一的关系；中介者模式中，中介者和同事对象是一对多的关系。

代理模式中，客户端仅知道代理者，不知道具体的主题对象（被代理的对象）；而且，客户端可以通过代理者访问具体的主题对象，主题对象不能通过代理者访问客户端。中介者模式中，不同的同事对象之间，均可以通过中介者互相访问。

（完）