设计模式之中介者模式

Mediator design pattern

中介者模式的概念、中介者模式的结构、中介者模式的优缺点、中介者模式的使用场景、中介者模式的实现示例、中介者模式的源码分析

---

1、中介者模式的概念

  中介者模式，又称调停模式，即定义一个中介者来封装原有多个对象之间的依赖关系，且可以独立改变它们之间的交互，以降低对象之间的耦合度。其是迪米特法则的典型应用。

2、中介者模式的结构

• 抽象中介者：定义关联关系注册和转发关联事件的行为。
• 具体中介者：实现抽象中介者，实现其定义的关联关系注册和转发关联关系的行为，其声明了一个关联者列表，用来维护注册进来的关联者。
• 抽象关联者：定义接受关联事件和发送关联事件的行为。
• 具体关联者：实现抽象关联者，实现其定义的接受关联事件和发送关联事件的行为，其持有一个抽象中介者的引用，发送关联事件的实现实际上是委托给抽象中介者的引用实现的。

3、中介者模式的优缺点

• 优点：
  • 松散耦合。通过中介者，降低了个关联对象之间的耦合度。
  • 集中控制交互：多个关联对象之间的交互，被封装在中介者对象中，使得这些交互行为发生变化时，只需要修改或者扩展中介者对象即可。
  • 一对多关联转变为一对一关联。中介者对象的引入，使得关联对象之间的关系更容易理解和实现。
• 缺点：
  • 当关联者类太多时，中介者的职责将很大，会变得复杂而庞大，以助于系统难以维护。

4、中介者模式的使用场景

• 当系统中对象之间存在复杂的引用，系统结构混乱且难以理解时。
• 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

5、中介者模式的实现示例

抽象中介者：

public interface Mediator {

    /**
     * 注册关联关系
     * @param relation
     */
    void registerRelation(Relation relation);

    /**
     * 转发关联事件
     * @param relation
     * @param message
     */
    void relay(Relation relation, String message);
}

具体中介者：

public class ConcreteMediator implements Mediator {

    private List<Relation> relations;

    public ConcreteMediator() {
        this.relations = new ArrayList<>();
    }

    @Override
    public void registerRelation(Relation relation) {
        if (!this.relations.contains(relation)) {
            relation.setMediator(this);
            this.relations.add(relation);
        }
    }

    @Override
    public void relay(Relation relation, String message) {
        for (Relation relation1 : this.relations) {
            if (!relation.equals(relation1)) {
                relation1.receive(relation, message);
            }
        }
    }
}

抽象关联者：

public abstract class Relation {

    protected String name;

    protected Mediator mediator;

    public Relation(String name) {
        this.name = name;
    }

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public String getName() {
        return name;
    }

    /**
     * 接受事件
     * @param relation
     * @param message
     */
    public abstract void receive(Relation relation, String message);

    /**
     * 发送事件
     * @param message
     */
    public abstract void send(String message);
}

具体关联者一：

public class OneRelation extends Relation {

    public OneRelation(String name) {
        super(name);
    }

    @Override
    public void receive(Relation relation, String message) {
        System.out.println(this.name + " 接受到了 " + relation.getName() + " 的消息 " + message);
    }

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

具体关联者二：

public class TwoRelation extends Relation {

    public TwoRelation(String name) {
        super(name);
    }

    @Override
    public void receive(Relation relation, String message) {
        System.out.println(this.name + " 接受到了 " + relation.getName() + " 的消息 " + message);
    }

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

测试：

public class MediatorTest {

    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();

        mediator.registerRelation(new OneRelation("zed"));
        mediator.registerRelation(new TwoRelation("fizz"));
        mediator.registerRelation(new TwoRelation("ahri"));

        Relation relation = new OneRelation("Ashe");
        mediator.registerRelation(relation);

        relation.send("别杀了 给条活路吧!");

    }
}

测试结果：

zed 接受到了 Ashe 的消息 别杀了 给条活路吧!
fizz 接受到了 Ashe 的消息 别杀了 给条活路吧!
ahri 接受到了 Ashe 的消息 别杀了 给条活路吧!

6、中介者模式的源码分析

404