设计模式之中介者模式

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

一、中介者模式

1.1 为什么使用中介者模式？

在软件开发中，对象和对象之间存在着大量的关联关系，导致系统的结构变得复杂，可扩展性降低。举例来看，下图所示的各个国家之间的关系图，倘若再加入一个新的国家，需要和其相关联的国家进行连接，变得很复杂。

按照中介者模式的思想，我们加入一个联合国的中介者：

由网状结构变成星型结构，提高系统整体的扩展性，这里面就体现了中介者模式,其UML图如下：

中介者模式由以下部分组成：

抽象中介者（Mediator）: 定义了同事对象到中介者对象之间的接口。

具体中介者（ConcreteMediator）: 实现抽象中介者的方法，它需要知道所有的具体同事类，同时需要从具体的同事类那里接收信息，并且向具体的同事类发送信息。

抽象同事类（Colleague）: 实现同事类之间的公共功能。

具体同事类（ConcreteColleague）: 每个具体同事类都只需要知道自己的行为即可，但是他们都需要认识中介者。

代码部分：

interface Mediator{
    void change(Colleague colleague);
}

abstract class Colleague{
    private Mediator mediator;

    protected Colleague(Mediator mediator) {
        this.mediator = mediator;
    }

    public Mediator getMediator() {
        return mediator;
    }

    public abstract  void someOperation();
}

class ConcreteColleagueA extends Colleague{


    protected ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }

    public void someOperation(){
        System.out.println("我是同事A");;
    }
}

class ConcreteColleagueB extends Colleague{


    protected ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }

    public void someOperation(){
        System.out.println("我是同事B");;
    }
}

class ConcreteMediator implements Mediator{

    private Colleague colleague;

    public void setColleague(Colleague colleague) {
        this.colleague = colleague;
    }

    @Override
    public void change(Colleague colleague) {
        colleague.someOperation();
    }
}

客户端调用：

二、案例分析

我们以开篇联合国的例子，研究一下中介者模式：

定义中介者–联合国家组织抽象类

 abstract  class  TheUnitedNations{
    public abstract void constact(String message,Country country);
}

具体联合国：

class ConcreteMediator extends TheUnitedNations{

    private China china;
    private USA usa;
    private Russia russia;

    public China getChina() {
        return china;
    }

    public void setChina(China china) {
        this.china = china;
    }

    public USA getUsa() {
        return usa;
    }

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

    public Russia getRussia() {
        return russia;
    }

    public void setRussia(Russia russia) {
        this.russia = russia;
    }

    @Override
    public void constact(String message, Country country) {
        System.out.println("我是"+country.getName()+",我想说"+message);
    }
}

国家抽象类：

abstract class Country{
    private String name;
    //持有中介者对象的引用，因为每个同事类都应该知道中介者对象
    private TheUnitedNations mediator;

    protected Country(String name ,TheUnitedNations mediator) {
        this.mediator = mediator;
        this.name = name;
    }

    public TheUnitedNations getMediator() {
        return mediator;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
}

具体国家类：

class China extends Country{

    public China(String name, TheUnitedNations mediator) {
        super(name, mediator);
    }

    public void someOperation(String message){
        super.getMediator().constact(message,this);
    }
}


class USA extends Country{

    public USA(String name, TheUnitedNations mediator) {
        super(name, mediator);
    }

    public void someOperation(String message){
        super.getMediator().constact(message,this);
    }
}

class Russia extends Country{

    public Russia(String name, TheUnitedNations mediator) {
        super(name, mediator);
    }

    public void someOperation(String message){
        super.getMediator().constact(message,this);
    }
}

故事上演：

public class Test {
    public static void main(String[] args) {
        ConcreteMediator cm = new ConcreteMediator();
        China c = new China("中国",cm);
        USA usa = new USA("美国",cm);
        Russia russia = new Russia("俄罗斯",cm);
        cm.setRussia(russia);
        cm.setChina(c);
        cm.setUsa(usa);
        c.someOperation("我是发展中国家");
        usa.someOperation("我是世界警察，我爱维护和平");
        russia.someOperation("战斗民族，能动手就.....");
    }
}

运行结果（代码亲测，可以通过）：

代码地址：Mediator

三、模式结语

中介者模式的优点：

• 简化了对象之间的关系，将系统的各个对象之间的相互关系进行封装，将各个同事类解耦，使系统成为松耦合系统。

• 减少了子类的生成。

• 可以减少各同事类的设计与实现。

中介者模式的适用场景：

• 系统中对象之间存在比较复杂的引用关系，导致他们之间的依赖关系结构混乱而且难以复用该对象。

• 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。

欢迎大家评论留言，点击查看更多设计模式。