设计模式（十三）—— 中介模式

中介模式定义

定义一个对象来封装一系列对象的交互，中介者模式使各个对象之间不需要相互引用，从而使得其松耦合，而且用户可以独立地改变他们之间的交互。

中介模式通用类图：

Mediator抽象中介者角色：抽象中介者角色定义一个接口用于与各同事（Colleague）对象通信。
Concrete Mediator具体中介者角色：通过协调各同事角色实现协作行为，因此他必须依赖各个同事角色。
Colleague 同事角色：每一个同事角色都知道中介者角色，而且与其他同事角色通信的时候，一定通过中介者角色协作。

定义抽象中介者

/**
 * @author xiaosen
 * @date 2019/4/24 17:24
 * @description
 */
public abstract class Mediator {
    public abstract void doSomething(Colleagure colleagure, String message);


}

定义抽象Colleagure

/**
 * @author xiaosen
 * @date 2019/4/24 17:29
 * @description
 */
public abstract class Colleagure {

    protected Mediator mediator;

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

定义具体的同事类

/**
 * @author xiaosen
 * @date 2019/4/24 17:31
 * @description
 */
public class ColleagureA extends Colleagure {

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

    public void doSelfthing(String message){
        System.out.println("ColleagureA receive message = " + message);
    }

    public void doMediaThing(){
        mediator.doSomething(this,"do ColleagureA mediator thing !");
    }
}

public class ColleagureB extends Colleagure {

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

    public void doSelfthing(String message){
        System.out.println("ColleagureB receive message = " + message);
    }

    public void doMediaThing(){
        mediator.doSomething(this,"do ColleagureB mediator thing !");
    }
}

定义具体中介者

/**
 * @author xiaosen
 * @date 2019/4/24 17:37
 * @description
 */
public class ConcreteMediator extends Mediator {
    private ColleagureA colleagureA;
    private ColleagureB colleagureB;

    public ColleagureA getColleagureA() {
        return colleagureA;
    }

    public void setColleagureA(ColleagureA colleagureA) {
        this.colleagureA = colleagureA;
    }

    public ColleagureB getColleagureB() {
        return colleagureB;
    }

    public void setColleagureB(ColleagureB colleagureB) {
        this.colleagureB = colleagureB;
    }

    @Override
    public void doSomething(Colleagure colleagure, String message) {
        if (colleagure==colleagureA){
            colleagureB.doSelfthing(message);
        }else {
            colleagureA.doSelfthing(message);
        }
    }
}

测试main方法

public class Main {

    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        ColleagureA colleagureA = new ColleagureA(mediator);
        ColleagureB colleagureB = new ColleagureB(mediator);
        mediator.setColleagureA(colleagureA);
        mediator.setColleagureB(colleagureB);
        colleagureA.doMediaThing();
        colleagureB.doMediaThing();


    }
}

// 输出：
// ColleagureB receive message = do ColleagureA mediator thing !
// ColleagureA receive message = do ColleagureB mediator thing !

优点

中介中模式简化了对象之间的相互交互，它用中介者和同事的一对多交互替代了原来同事类之间的多对多的交互，一对多关系更容易理解、维护和扩展，将原本难以理解的网状结构换成相对接单的星状结构。
可将各个同事类对象进行解耦。中介者有利于各同事之间的耦合，可以独立地改变和复用各个同事类和中介者。
可以减少子类的生成。

缺点

在具体中介中包含了大量的同事类之间的交互细节，可能会使具体中介者非常复杂，使得系统难以维护。

使用场景

系统中对象之间存在复杂的引用关系，系统结构混乱难以理解。
一个对象由于引用了其他很多对象并且直接和这戏对象进行通信，导致难以复用该对象。

本文代码GitHub

欢迎关注公众号：
公众号微信