二十二、行为型-通过中间类-中介者（Meditor）模式

现在我们来学习第三种设计模式行为型的第四种通过中间类的第二种中介者模式。所谓中介者模式就是用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

为什么要用中介者模式

有时候我们的类太多，类与类之间的调用也很频繁，这样子的话最终会导致耦合紧密，牵一发而动全身，比如房东和租客，房东有房子，那么他要出租就要亲自去找租客，租客要租房也必须亲自去找房东。又比如计算机之间的通信，如果每个计算机直接跟要通信的计算机通信，如果有一百台计算机，那么每个计算机都要持有其他99台计算机的引用，如果有一万台就炸了，所以我们会有一个中央处理器，你们每个计算机都跟我交互，我来处理你们之间的关系，也就是最后由网状变成了星状图。随手画了一个丑晕的图：

UML如下

Mediator：中介抽象类
ConcreteMediator：具体中介类，接收具体的同事类的消息，向具体的同事类发送消息
Colleague：抽象同事类，将中介者引入。
ConcreteColleague：具体同事类（多个同事）

下面举一个房东、中介、租客的例子

租客和房东必须持有中介者的引用，并且必须在中介者上注册，源码如下

1、抽象同事类:User

public abstract class User {
    private Mediator mediator;
    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }
    public Mediator getMediator() {
        return mediator;
    }
    public abstract void constact(String message) ;
}

2、具体同事类：FangDong、ZuKe

/**
 * 房东
 * @author suibibk.com
 */
public class FangDong extends User{
    @Override
    public void constact(String message) {
        getMediator().constact(message, this);
    }
    public void getMessage(String message) {
        System.out.println("房东收到消息："+message);
        System.out.println("房东回答。我这里有房子");
    }
}

/**
 * 租客
 * @author suibibk.com
 */
public class ZuKe extends User{
    @Override
    public void constact(String message) {
        getMediator().constact(message, this);
    }
    public void getMessage(String message) {
        System.out.println("租客收到消息："+message);
        System.out.println("租客回答我需要租房子");
    }
}

3、中介抽象类：Mediator

public abstract class Mediator {
    public abstract void constact(String message,User user);
}

4、具体中介类:ConcreteMediator

public class ConcreteMediator extends Mediator{
    private FangDong fangdong;
    private ZuKe zuke;
    //必须先在中介里注册
    public void setFangdong(FangDong fangdong) {
        this.fangdong = fangdong;
    }
    public void setZuke(ZuKe zuke) {
        this.zuke = zuke;
    }
    public FangDong getFangdong() {
        return fangdong;
    }
    public ZuKe getZuke() {
        return zuke;
    }
    @Override
    public void constact(String message, User user) {
        System.out.println("获取信息："+message);
        if(fangdong==user) {
            //来询问的是房东，那么我就去问问租客要不要租房
            zuke.getMessage("我是中介，需要租房么？");
        }
        if(zuke==user) {
            //来询问的是房东，那么我就去问问租客要不要租房
            fangdong.getMessage("我是中介，请问有房子出租么？");
        }
    }
}

5、测试类Test

public class Test {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        FangDong  fd = new FangDong();
        ZuKe zk = new ZuKe();
        //向中介注册
        fd.setMediator(mediator);
        mediator.setFangdong(fd);
        zk.setMediator(mediator);
        mediator.setZuke(zk);
        fd.constact("我这里有房子，有人要租房么");
        zk.constact("我要租房子，有人要出租么");
    }
}

运行测试类输出如下结果：

获取信息：我这里有房子，有人要租房么
租客收到消息：我是中介，需要租房么？
租客回答我需要租房子
获取信息：我要租房子，有人要出租么
房东收到消息：我是中介，请问有房子出租么？
房东回答。我这里有房子

上面的例子完美的实现了中介者模式，房东和租客之间没有任何联系。

总结

优点： 1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。
缺点：中介者会庞大，变得复杂难以维护。
哈，越到后面写笔记越随便了，都不是太认真，可能觉得设计模式系列笔记快结束了，就想着早点结束，这样可不行，得好好反省。不过这个模式这么简单，应该能够理解的。