《设计模式入门》 23.中介者模式

定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

我们接触最多的情况就比如是在ORM框架中，中间层负责了应用层与数据库层的交互，将应用层与数据库层解耦，比如mybaties的应用。

中介者模式一般分类四类：

1. 抽象中介者（Mediator）角色：它是中介者的接口，提供了同事对象注册与转发同事对象信息的抽象方法。
2. 具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个 List 来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
3. 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
4. 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互

=========================================================================

我们来简单的使用中介者模式来模拟联合国作为中介，调停俄罗斯和乌克兰的冲突：

首先定义一个抽象中介者：

package BehavioralPatterns.MediatorPattern;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Mediator.java
 * @Description 抽象中介者
 * @createTime 2022年03月18日 15:32:00
 */
public abstract class Mediator {
    /**
     * 交流方法
     * @param message 交流信息
     * @param country 国家
     */
    public abstract void declare(String message, Country country);
}

然后定义一个国家类，并申明中介者：

package BehavioralPatterns.MediatorPattern;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Country.java
 * @Description 国家类
 * @createTime 2022年03月18日 15:35:00
 */
public class Country {
    /**
     * 中介者
     */
    protected Mediator mediator;

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

创建俄罗斯和乌克兰集成国家类：

俄罗斯：

package BehavioralPatterns.MediatorPattern;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Russia.java
 * @Description 俄罗斯
 * @createTime 2022年03月18日 15:37:00
 */
public class Russia extends Country{
    public Russia(Mediator mediator) {
        super(mediator);
    }

    /**
     * 交流方法
     * @param message 消息
     */
    public void declare(String message){
        mediator.declare(message,this);
    }

    /**
     * 获取消息
     * @param message 其他国家传来的消息
     */
    public void getMessage(String message){
        System.out.println("俄罗斯获得消息： "+message);
    }
}

乌克兰：

package BehavioralPatterns.MediatorPattern;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName Ukraine.java
 * @Description TODO
 * @createTime 2022年03月18日 15:41:00
 */
public class Ukraine extends Country{
    public Ukraine(Mediator mediator) {
        super(mediator);
    }
    /**
     * 交流方法
     * @param message 消息
     */
    public void declare(String message){
        mediator.declare(message,this);
    }

    /**
     * 获取消息
     * @param message 其他国家传来的消息
     */
    public void getMessage(String message){
        System.out.println("乌克兰获得消息： "+message);
    }
}

创建一个中介者：联合国

package BehavioralPatterns.MediatorPattern;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName TheUnitedNations.java
 * @Description 联合国
 * @createTime 2022年03月18日 15:42:00
 */
public class TheUnitedNations extends Mediator{
    private Russia russia;
    private Ukraine ukraine;

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

    public void setUkraine(Ukraine ukraine) {
        this.ukraine = ukraine;
    }

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

联合国实现了乌克兰的俄罗斯的沟通，并且解耦了两个类。

 测试一下 ：

package BehavioralPatterns.MediatorPattern;

/**
 * @author Zeyu Wan
 * @version 1.0.0
 * @ClassName MediatorTest.java
 * @Description TODO
 * @createTime 2022年03月18日 15:44:00
 */
public class MediatorTest {
    public static void main(String[] args) {
        TheUnitedNations unitedNations = new TheUnitedNations();

        Russia russia = new Russia(unitedNations);
        Ukraine ukraine = new Ukraine(unitedNations);

        unitedNations.setRussia(russia);
        unitedNations.setUkraine(ukraine);

        russia.declare("放弃基辅，赶快投降");
        ukraine.declare("北约爸爸们会救我的");
    }
}

 

优点：

• 降低了对象之间的耦合性，使得对象易于独立地被复用。
• 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

缺点：

• 当同事类太多时，中介者的职责将很大，它会变得复杂而庞大，以至于系统难以维护