中介者模式

Mediator Patterns

GoF定义：定义一个对象来处理一组对象的交互。中介者模式通过避免对象之间互相引用提高了解耦程度，允许用户独立改变它们各自的交互操作

概念

中介者是负责一组对象交互的。它会追踪各个对象之间的交流记录。系统中的其它对象也知道有这个中介者的存在，当它们想和其它的对象交互时，也需要通过中介者。使用这个模式的优点就是可以避免对象之间的直接交互并且降低耦合度

例子

现实世界：在机场中，所有的飞机在起飞之前都要进行组件（互相依赖）的检查，确保安全状态起飞。此外，每个飞行员都需要和不同机场的航站楼交流，然而他一般不需要和另一个机场的另一个飞行员交流，此时航站楼就是中介者的角色
代码世界：在表单提交的场景中，用户需要提交用户id、密码、email等信息，如果在实现中，当用户提供的id正确才能继续输密码，如果id、密码正确才能提供一些其它的认证信息，一旦任何一个信息不满足验证，那么提交按钮就不可用。这个逻辑的实现可以通过中介者模式实现

展示

这个场景中有三个类实现了Friend接口，其中有一个老板和两个员工。老板希望有人给他发消息时他可以收到，且他要给员工发消息，员工也可以马上收到。这里消息的传递就是通过中介者完成的

代码

public class MediatorPatternEx
{
    public static void main(String[] args)
    {
        System.out.println("***Mediator Pattern Demo***\n");
        ConcreteMediator m = new ConcreteMediator();
        Friend1 Amit= new Friend1("Amit", m);
        Friend2 Sohel = new Friend2("Sohel", m);
        Boss Raghu = new Boss("Raghu", m);
        m.setFriend1(Amit);
        m.setFriend2(Sohel);
        m.setBoss(Raghu);
        Amit.send("[Amit here]Good Morrning. Can we discuss the mediator pattern?");
        Sohel.send("[Sohel here]Good Morning.Yes, we can discuss now.");
        Raghu.send("\n[Raghu here]:Please get back to work quickly");
    }
}

/**
 * 所有的中介者都需要有发送信息的能力
 */
abstract class Mediator
{
    abstract public void send(Friend friend, String message);
}

class ConcreteMediator extends Mediator
{
    private Friend1 friend1;
    private Friend2 friend2;
    private Boss boss;

    public void setFriend1(Friend1 friend1)
    {
        this.friend1 = friend1;
    }

    public void setFriend2(Friend2 friend2)
    {
        this.friend2 = friend2;
    }

    public void setBoss(Boss boss)
    {
        this.boss = boss;
    }

    @Override
    public void send(Friend friend, String message)
    {
        if (friend == friend1)
        {
            friend2.notify(message);
            boss.notify(message);
        }
        else if (friend == friend2)
        {
            friend1.notify(message);
            boss.notify(message);
        }
        else
        {
            friend1.notify(message);
            friend2.notify(message);
        }
    }
}

abstract class Friend
{
    public String name;
    protected Mediator mediator;

    public Friend(Mediator mediator)
    {
        this.mediator = mediator;
    }
}

class Friend1 extends Friend
{
    public Friend1(String name, Mediator mediator)
    {
        super(mediator);
        this.name = name;
    }

    public void send(String message)
    {
        this.mediator.send(this, message);
    }

    public void notify(String message)
    {
        System.out.println("Amit gets message: "+ message);
    }
}

class Friend2 extends Friend
{
    public Friend2(String name, Mediator mediator)
    {
        super(mediator);
        this.name = name;
    }

    public void send(String message)
    {
        this.mediator.send(this, message);
    }

    public void notify(String message)
    {
        System.out.println("Sohel gets message: "+ message);
    }
}

class Boss extends Friend
{
    public Boss(String name, Mediator mediator)
    {
        super(mediator);
        this.name = name;
    }

    public void send(String message)
    {
        this.mediator.send(this, message);
    }

    public void notify(String message)
    {
        System.out.println("\nBoss sees message: " + message);
        System.out.println("");
    }
}

Note

1. 当我们要观察对象之间复杂的交互过程可以使用这个模式，且对象之间的交互通过这个模式变得更简单
2. 这个模式减少了系统中子类的数量（我理解这里的意思是，如果没有中介者对象，那么各个对象的通信可能会制造很多通信接口类），降低了耦合度
3. 多对多关系被一对多关系替代，提高可读性
4. 这个模式可以在中心（中介者）做控制
5. 难以维护

思考

这个模式书中的例子确实很好理解。即中介者就是做对象之间的消息转发的，当然同时可以记录所有的通信信息，相当于是中央控制的设计思想