设计模式——中介者模式

在阎宏博士的《JAVA与模式》一书中开头是这样描述调停者（Mediator）模式的：调停者模式是对象的行为模式。调停者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显引用。从而使它们可以较松散地耦合。当这些对象中的某些对象之间的相互作用发生改变时，不会立即影响到其他的一些对象之间的相互作用。从而保证这些相互作用可以彼此独立地变化。

中介者模式（Mediator Pattern）也称为调停者模式，属于行为型模式。通过中介类来完成各个类之间的通讯，解绑各个类之间的耦合，而且可以独立地改变它们之间的交互。中介者模式主要适用在网状结构的对象关系中，将它们之间关系变为星状结构，所有对象都只跟中介者对象进行通讯，相互之间没有直接关系，通过中介者类来集中控制对象的交互关系。

中介者模式.png

中介者模式结构

UML图

MediatorPattern.png

中介者模式组成角色

• 抽象中介者角色（Mediator）：定义同事对象到中介者对象的接口，主要方法是一个或多个事件方法。
• 具体中介者角色（ConcreteMediator）：实现了抽象中介者所声明的事件方法。具体中介者知晓所有的具体同事类，并负责具体的协调各同事对象的交互关系。
• 抽象同事类角色（Colleague）：定义中介者角色到同事角色之间的接口，同事对象只知道有中介者不知道是否有其它同事。
• 具体同事类角色（ConcreteColleague）：具体同事类角色继承抽象同事类，实现自己的业务，在需要与其他同事通信的时候，就与持有的中介者通信，中介者会负责与其他的同事交互。

案例演示

举一个比较常见的例子，在工作中小组会议要求组内每个人参与，在以前，我们可能是把组内的人挨个通知一次“下午要开会了”。非常麻烦，现在我们使用中介者模式，只需要在通讯录中发一个开会通知，由这个中介者将该消息传递给对应人员。

定义抽象中介者角色

interface Notification {
    /**
     * 同事角色通知中介者发生改变了
     */
    public void notifyChanged(Colleague colleague);
}

在这里定义一个方法，用来同事角色通知中介者角色发生改变。

定义具体中介者角色

class TeamMeeting implements Notification{
    private Colleague jackColleague,lucyColleague,lindaColleague;
    
    
    public void setJackColleague(Colleague jackColleague) {
        this.jackColleague = jackColleague;
    }


    public void setLucyColleague(Colleague lucyColleague) {
        this.lucyColleague = lucyColleague;
    }


    public void setLindaColleague(Colleague lindaColleague) {
        this.lindaColleague = lindaColleague;
    }


    @Override
    public void notifyChanged(Colleague colleague) {
        if(colleague instanceof JackColleague){
            lucyColleague.handleMessage();
            lindaColleague.handleMessage();
        }else if(colleague instanceof LucyColleague){
            jackColleague.handleMessage();
            lindaColleague.handleMessage();
        }else{
            lucyColleague.handleMessage();
            jackColleague.handleMessage();
        }
    }
}

在具体中介者中，定义了需要包含的同事角色的对象，然后实现数据改变通知接口。

定义抽象同事角色

abstract class Colleague {
    protected Notification notification;

    public Colleague(Notification notification) {
        super();
        this.notification = notification;
    }
    
    /**
     * 处理中介者发送过来的消息
     */
    public abstract void handleMessage();
    
    /**
     * 同事角色发送消息
     * @param message
     */
    public abstract void sendMessage(String message);
}

在抽象角色中定义了发送消息接口和处理中介者发送消息的接口。

定义具体角色

/**
 * 同事Jack
 * @author Iflytek_dsw
 *
 */
class JackColleague extends Colleague{

    public JackColleague(Notification notification) {
        super(notification);
    }
    
    /**
     * Jack发送消息
     * @param message
     */
    @Override
    public void sendMessage(String message){
        System.out.println("Jack发送通知：" + message);
        notification.notifyChanged(this);
    }

    @Override
    public void handleMessage() {
        System.out.println("Jack接收到通知");
    }
}

/**
 * 同事Lucy
 * @author Iflytek_dsw
 *
 */
class LucyColleague extends Colleague{

    public LucyColleague(Notification notification) {
        super(notification);
    }
    
    /**
     * Jack发送消息
     * @param message
     */
    @Override
    public void sendMessage(String message){
        System.out.println("Lucy发送通知：" + message);
        notification.notifyChanged(this);
    }
    
    @Override
    public void handleMessage() {
        System.out.println("Lucy接收到通知");
    }
}

/**
 * 同事LinDa
 * @author Iflytek_dsw
 *
 */
class LinDaColleague extends Colleague{

    public LinDaColleague(Notification notification) {
        super(notification);
    }
    
    /**
     * Jack发送消息
     * @param message
     */
    @Override
    public void sendMessage(String message){
        System.out.println("LinDa发送通知：" + message);
        notification.notifyChanged(this);
    }
    
    @Override
    public void handleMessage() {
        System.out.println("LinDa接收到通知");
    }
}

客户端

public class Client {

    /**
     * @param args
     */
    public static void main(String[] args) {
        //首先创建中介者角色
        TeamMeeting notification = new TeamMeeting();
        
        //创建同事角色
        Colleague jackColleague = new JackColleague(notification);
        Colleague lucyColleague = new LucyColleague(notification);
        Colleague lindaColleague = new LinDaColleague(notification);
        
        notification.setJackColleague(jackColleague);
        notification.setLucyColleague(lucyColleague);
        notification.setLindaColleague(lindaColleague);
        
        //Jack发送会议通知
        jackColleague.sendMessage("下午三点开会");
    }
}

执行结果

Jack发送通知：下午三点开会
Lucy接收到通知
LinDa接收到通知

总结

中介者模式的优点

• 松散耦合，中介者模式把不同的同事对象之间的关系交互封装到中介类中，从而使得同事角色之间耦合度降低，这样就达到降低耦合的效果，同事对象可以独立变化使用，不相互干扰。
• 集中控制交互，将多个同事角色对象的交互封装到中介者中进行集中管理，使得这些交互改变的时候只需要修改中介者类就可以了，使系统具有良好的扩展性。
• 多对多关系变成一对多关系，没有使用中介者模式的时候，同事对象之间的关系通常是多对多的，引入中介者对象以后，中介者对象和同事对象的关系通常变成双向的一对多，这会让对象的关系更容易理解和实现。

中介者模式缺点
过度集中化。如果同事对象的交互非常多，而且比较复杂，当这些复杂性全部集中到中介者的时候，会导致中介者对象变得十分复杂，而且难于管理和维护。