行为型设计模式之中介者模式

中介者模式

中介者模式又称为调解者模式或调停者模式，属于行为型模式。它用一个中介对象封装系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使它们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立的变化。其核心思想是，通过中介者解耦系统各层次对象的直接耦合，层次对象的对外依赖通信统统交由中介者转发。

中介者模式通过提供一个中介类，将系统各层次对象间的多对多关系变成一对多关系，将复杂的网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可扩展性的作用。

应用场景

当多个类相互耦合，形成了网状结构，则可以考虑使用中介者模式进行优化。

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

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

飞行器驾驶员之间不会通过相互沟通来决定下一架降落的飞机。 所有沟通都通过控制塔台进行。

主要角色

1.抽象中介者(Mediator)

定义统一的接口，用于各同事角色之间的通信

2.具体中介者(ConcreteMediator)

从具体的同事对象接收消息，向具体同事对象发出命令，协调各同事间的协作

3.抽象同事类(Colleague)

每一个同事对象均需要依赖中介者角色，与其他同事间通信时，交由中介者进行转发协作

4.具体同事类(ConcreteColleague)

负责实现自发行为（Self-Method),转发依赖方法

优缺点

优点：

1.减少类间依赖，将多对多依赖转化成了一对多，降低了类间耦合；

2.类间各司其职，符合迪米特法则。

缺点：

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

基本使用

创建抽象中介者

public abstract class Mediator {
    protected ConcreteColleagueA colleagueA;
    protected ConcreteColleagueB colleagueB;

    public void setColleageA(ConcreteColleagueA colleague) {
        this.colleagueA = colleague;
    }

    public void setColleageB(ConcreteColleagueB colleague) {
        this.colleagueB = colleague;
    }

    // 中介者业务逻辑
    public abstract void transferA();

    public abstract void transferB();
}

创建具体中介者

public class ConcreteMediator extends Mediator {
    /**
     * 由具体同事类A，向具体同事对象B发出指令
     */
    @Override
    public void transferA() {
        this.colleagueB.selfMethodB();
    }

    /**
     * 由具体同事类B，向具体同事对象A发出指令
     */
    @Override
    public void transferB() {
        this.colleagueA.selfMethodA();
    }
}

创建抽象同事类

public abstract class Colleague {
    protected Mediator mediator;

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

创建具体同事类

public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
        this.mediator.setColleageA(this);
    }

    /**
     * 自有方法
     */
    public void selfMethodA() {
        System.out.println( this.getClass().getSimpleName()+ "收到中介协作通知，selfMethodA自有方法执行");
    }

    /**
     * 依赖方法
     */
    public void depMethodA() {
        System.out.println( this.getClass().getSimpleName()+ " depMethodA通知中介者进行转发协作");
        // 中介者进行转发协作
        this.mediator.transferA();
    }
}

public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
        this.mediator.setColleageB(this);
    }

    /**
     * 自有方法
     */
    public void selfMethodB() {
        System.out.println(this.getClass().getSimpleName() + "收到中介协作通知，selfMethodB自有方法执行");
    }

    /**
     * 依赖方法
     */
    public void depMethodB() {
        System.out.println(this.getClass().getSimpleName() + " depMethodB通知中介者进行转发协作");
        // 中介者进行转发协作
        this.mediator.transferB();
    }
}

客户端执行

    public static void main(String[] args) {
        // 创建抽象中介者
        Mediator mediator = new ConcreteMediator();
        // 具体同事类
        ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
        ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
        // 中介者进行转发协作,A转发给B
        colleagueA.depMethodA();
        System.out.println("-------------------------");
        // 中介者进行转发协作,B转发给A
        colleagueB.depMethodB();
    }

ConcreteColleagueA depMethodA通知中介者进行转发协作
ConcreteColleagueB收到中介协作通知，selfMethodB自有方法执行
-------------------------
ConcreteColleagueB depMethodB通知中介者进行转发协作
ConcreteColleagueA收到中介协作通知，selfMethodA自有方法执行