中介者模式（Mediator Pattern）

Posted 2021-07-23 顧棟

文章目录

• 中介者模式（Mediator Pattern）
• • 中介者模式的定义
  • 中介者模式的优点
  • 中介者模式的缺点
  • 中介者模式的结构
  • 中介者模式的实现
  • • 一般实现
  • 中介者模式的适用场景

中介者模式（Mediator Pattern）

中介者模式的定义

用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又叫调停模式，它是迪米特法则的典型应用。

中介者模式的优点

1. 类之间各司其职，符合迪米特法则。
2. 降低了对象之间的耦合性，使得对象易于独立地被复用。
3. 将对象间的一对多关联转变为一对一的关联，提高系统的灵活性，使得系统易于维护和扩展。

中介者模式的缺点

中介者模式将原本多个对象直接的相互依赖变成了中介者和多个同事类的依赖关系。当同事类越多时，中介者就会越臃肿，变得复杂且难以维护。

中介者模式的结构

中介者模式包含以下主要角色。

1. 抽象中介者（Mediator）角色：定义统一的接口，用于各同事角色之间的通信，提供了同事对象注册与转发同事对象信息的抽象方法。
2. 具体中介者（Concrete Mediator）角色：具体中介者角色通过协调各同事角色实现协作行为，因此它必须依赖于各个同事角色。
3. 抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
4. 具体同事类（Concrete Colleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。
   每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种行为叫做自发行为（Self-Method），与其他的同事类或中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法（Dep-Method）。

中介者模式的实现

一般实现

/**
 * 抽象中介者类
 */
public abstract class Mediator {
    /**
     * 定义同事类
     */
    protected ConcreteColleague1 c1;
    protected ConcreteColleague2 c2;

    /**
     * 通过getter/setter方法把同事类注入进来
     */
    public ConcreteColleague1 getC1() {
        return c1;
    }

    public void setC1(ConcreteColleague1 c1) {
        this.c1 = c1;
    }

    public ConcreteColleague2 getC2() {
        return c2;
    }

    public void setC2(ConcreteColleague2 c2) {
        this.c2 = c2;
    }

    /**
     * 中介者模式的业务逻辑
     */
    public abstract void doSomething1();

    /**
     * 中介者模式的业务逻辑
     */
    public abstract void doSomething2();
}

/**
 * 具体中介者类
 */
public class ConcreteMediator extends Mediator {

    @Override
    public void doSomething1() {
        super.c1.selfMethod1();
    }

    @Override
    public void doSomething2() {
        super.c2.selfMethod2();
    }
}

/**
 * 抽象同事类
 */
public abstract class Colleague {
    protected Mediator mediator;

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

/**
 * 具体同事类1
 */
public class ConcreteColleague1 extends Colleague {
    /**
     * 通过构造函数传递中介者
     */
    public ConcreteColleague1(Mediator mediator) {
        super(mediator);
    }

    /**
     * 自有方法 self-method
     */
    public void selfMethod1() {
        //处理自己的业务逻辑
        System.out.println("ConcreteColleague1 selfMethod1");
    }

    /**
     * 依赖方法 dep-method
     */
    public void depMethod1() {
        //自己不能处理的业务逻辑，委托给中介者处理
        System.out.println("ConcreteColleague1 转发请求");
        super.mediator.doSomething2();
    }
}

/**
 * 具体同事类2
 */
public class ConcreteColleague2 extends Colleague {
    /**
     * 通过构造函数传递中介者
     */
    public ConcreteColleague2(Mediator mediator) {
        super(mediator);
    }

    /**
     * 自有方法 self-method
     */
    public void selfMethod2() {
        //处理自己的业务逻辑
        System.out.println("ConcreteColleague2 selfMethod2");
    }

    /**
     * 依赖方法 dep-method
     */
    public void depMethod2() {
        // 自己不能处理的业务逻辑，委托给中介者处理
        System.out.println("ConcreteColleague2 转发请求");
        super.mediator.doSomething1();
    }
}

public static void main(String[] args) {
    Mediator mediator = new ConcreteMediator();
    ConcreteColleague1 c1 = new ConcreteColleague1(mediator);
    mediator.setC1(c1);
    ConcreteColleague2 c2 = new ConcreteColleague2(mediator);
    mediator.setC2(c2);
    c1.depMethod1();
    c2.depMethod2();
}

中介者模式的适用场景

• 当对象之间存在复杂的网状结构关系而导致依赖关系混乱且难以复用时。
• 当想创建一个运行于多个类之间的对象，又不想生成新的子类时。

---

本文主要参考：

1. 小傅哥的《重学Java模式》
2. 《C语言中文网》设计模式的相关内容
3. 《设计模式之禅》第二版 秦小波