中介者模式——网状依赖的解耦

Demo 地址： https://github.com/ooblee/HelloDesignPattern

1. 定义

中介者模式(Mediator Pattern)：用一个中介对象（中介者）来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

针对依赖关系复杂的对象的引用关系做了一次调整，把对象间的依赖抽象出一个中介者来统一处理。

整个模型由复杂的网状依赖简化为星型依赖。

2. 设计

中介者的主要角色有：

• 抽象中介者（Mediator），定义与各同事对象通信的接口。
• 具体中介者（Concrete Mediator），实现接口，对同事进行中转和协调。
• 抽象同事类（Colleague），定义同事类的应用方法，维持就抽象中介者的引用，用来与抽象中介者通信。
• 具体同事类（Concrete Colleague），实现抽象同事类的方法。

整体类图如下：

这里举一个简单的模型。

抽象中介者，集合所有同事类需要依赖其他同事执行的方法。

public interface Mediator {

    void helloAB();

    void helloBC();

    void helloAC();
}

具体中介者，引用所有的对象，并且在方法中处理依赖关系的调用。

public class ConcreteMediator implements Mediator {

    private ColleagueA colleagueA;
    private ColleagueB colleagueB;
    private ColleagueC colleagueC;

    public ConcreteMediator() {

    }

    public void addColleague(ColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void addColleague(ColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    public void addColleague(ColleagueC colleagueC) {
        this.colleagueC = colleagueC;
    }

    public void helloAB() {
        colleagueA.helloA();
        colleagueB.helloB();
    }

    public void helloBC() {
        colleagueB.helloB();
        colleagueC.helloC();
    }

    public void helloAC() {
        colleagueA.helloA();
        colleagueC.helloC();
    }
}

抽象同事类，引用中介者，暴露接口给实现的同事类使用。

public class Colleague {

    private Mediator mediator;

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

    protected Mediator getMediator() {
        return mediator;
    }
}

具体同事类，实现业务逻辑，涉及到对其他同事的调用，使用中介者来完成。

比如这里的同事 A。

public class ColleagueA extends Colleague {

    public ColleagueA(Mediator mediator) {
        super(mediator);
    }

    public void hello() {
        System.out.println("A 执行");
        helloA();
        getMediator().helloBC();
        System.out.println();
    }

    public void helloA() {
        System.out.println("hello A.");
    }
}

使用的方式：

public class TestMediator {

    public static void main(String[] args) {

        // 创建中介者
        ConcreteMediator mediator = new ConcreteMediator();

        // 创建同事
        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB = new ColleagueB(mediator);
        ColleagueC colleagueC = new ColleagueC(mediator);

        // 注入依赖
        mediator.addColleague(colleagueA);
        mediator.addColleague(colleagueB);
        mediator.addColleague(colleagueC);

        // 执行方法
        colleagueA.hello();
        colleagueB.hello();
        colleagueC.hello();
    }
}

3. 应用

中介者主要的职责：

• 结构上进行中转，同事之间的通信通过中介者进行中转。
• 行为上进行协调，封装好交互的逻辑，同事只需要发起请求，而不需要指明中介者怎么做。

应用场景：

• 网状的依赖关系，系统结构复杂，耦合度高。
• 一个对象引用多个对象并且进行通信。这样该对象难以在其他系统中使用。
• 通过中间类来封装子类的行为。希望修改或增加组件，不会对旧代码产生影响。

4. 特点

4.1. 优势

• 简化对象的交互，由一对多来优化多对多，由网状结构转为星型结构。
• 解耦，各个对象通过中介者解耦，可以独立变化而不互相影响。
• 中心化，把对象中分散的行为集中在中介者中，可复用行为。

4.2. 缺点

• 中介者包含大量对象的交互，会变得非常复杂。后续维护会是很大的一个挑战。