大话设计模式读书笔记——中介者模式

---

1. 中介者模式

1.1 概念

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

1.2 案例代码

1.2.1 UMl类图

1.2.2 抽象同事类和对应的子类

Colleague叫作抽象同事类，而ConcreteColleague是具体同事类，每个具体同事只知道自己的行为，而不了解其他同事类的情况，但他们却都认识中介者对象。

public abstract class Colleague {
    protected Mediator mediator;
    //构造方法，得到中介者对象
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
}

public class ConcreteColleague1 extends Colleague{
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

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

    public void notify(String message){
        System.out.println("同事1得到消息："+message);
    }
}

public class ConcreteColleague2 extends Colleague{
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

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

    public void notify(String message){
        System.out.println("同事2得到消息："+message);
    }
}

1.2.3 抽象中介者类

Mediator是抽象中介者，定义了同事对象到中介者对象的接口

public abstract class Mediator {
    //定义一个抽象的发送消息方法，得到同事对象和发送消息
    public abstract void send(String message,Colleague colleague);
}

1.2.4 具体中介者类

ConcreteMediator是具体中介者对象，实现抽象类的方法，它需要知道所有具体同事类，并从具体同事接收消息，向具体同事对象发出命令。

public class ConcreteMediator extends Mediator{
    private ConcreteColleague1 colleague1;
    private ConcreteColleague2 colleague2;

    public void setColleague1(ConcreteColleague1 colleague1) {
        this.colleague1 = colleague1;
    }

    public void setColleague2(ConcreteColleague2 colleague2) {
        this.colleague2 = colleague2;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleague1){
            colleague2.notify(message);
        }else{
            colleague1.notify(message);
        }
    }
}

1.2.4 客户端代码

        ConcreteMediator m = new ConcreteMediator();

        ConcreteColleague1 c1 = new ConcreteColleague1(m);
        ConcreteColleague2 c2 = new ConcreteColleague2(m);

        m.setColleague1(c1);
        m.setColleague2(c2);

        c1.send("吃过饭了吗");
        c2.send("没有呢，你打算请客？");

1.2.5 小结

由于有了Mediator，使得ConcreteColleague1和ConcreteColleague2在发送消息和接收信息时其实是通过中介者来完成的，这就减少了它们之间的耦合度

2. 需求

请使用中介者模式实现这个场景：美国和伊拉克之间的对话都是通过联合国安理会作为中介来完成。

3. 代码版本1.0（中介者模式实现）

3.1 UML类图

3.2 国家类和对应的子类

public abstract class Country {
    protected UnitedNations unitedNations;

    public Country(UnitedNations unitedNations) {
        this.unitedNations = unitedNations;
    }
}

public class USA extends Country{
    public USA(UnitedNations unitedNations) {
        super(unitedNations);
    }

    public void declare(String message){
        this.unitedNations.declare(message,this);
    }

    public void getMessage(String message){
        System.out.println("美国获取对方消息："+message);
    }
}

public class Iraq extends Country{
    public Iraq(UnitedNations unitedNations) {
        super(unitedNations);
    }

    public void declare(String message){
        this.unitedNations.declare(message,this);
    }

    public void getMessage(String message){
        System.out.println("伊拉克获取对方消息："+message);
    }
}

3.3 联合国机构类

//中介者类
public abstract class UnitedNations {
    //声明
    public abstract void declare(String message,Country country);
}

3.4 联合国安理会

public class UnitedNationsSecurityCouncil extends UnitedNations{
    private USA usa;
    private Iraq iraq;

    public void setUsa(USA usa) {
        this.usa = usa;
    }

    public void setIraq(Iraq iraq) {
        this.iraq = iraq;
    }

    @Override
    public void declare(String message, Country country) {
        if (country==this.usa){
            this.iraq.getMessage(message);
        }else if(country==this.iraq){
            this.usa.getMessage(message);
        }
    }
}

3.5 客户端代码

     UnitedNationsSecurityCouncil UNSC = new UnitedNationsSecurityCouncil();

     USA usa = new USA(UNSC);
     Iraq iraq = new Iraq(UNSC);

     UNSC.setUsa(usa);
     UNSC.setIraq(iraq);

     usa.declare("不准研制核武器，否则发动战争");
     iraq.declare("我们没有核武器，也不怕侵略");

4.中介者模式优缺点

优点：

1. Mediator的出现减少了各个Colleague的耦合，使得可以独立地改变和复用各个Colleague类和Mediator
2. 由于把对象如何协作进行了抽象，将中介作为一个独立的概念并将其封装在一个对象中，这样关注的对象就从对象各自本身的行为转移到它们之间的交互上来，也就是站在一个更宏观的角度去看待系统。

缺点：

1. ，由于ConcreteMediator控制了集中化，于是就把交互复杂性变为中介者的复杂性，这就使得中介者会变得比任何一个ConcreteColleague都复杂。