为什么要慎用中介者模式？

中介者模式的定义：

Define an object that encapsulates how a set of objects interact . Mediator promotes loose coupling by keeping objects from referring to each other explicitly.and it lets you vary their interaction independently.

用一个中介对象封装一系列的对象交互。中介者是个对象不需要显示的互相作用，从而使起耦合松散，而且嗯可以独立的改变他们之间的交互。

抽象中介者模型如下：

package com.kaisen.mainland.Text;

import lombok.Data;

/**
 * @author huzhibo
 * @Description: 通用抽象中介者
 * @date 2020/9/10 20:41
 */
@Data
public abstract class AbstractMediator {

    protected Colleague1 colleague1;
    protected Colleague2 colleague2;

    public AbstractMediator(){
        colleague1 =new Colleague1(this);
        colleague2 =new Colleague2(this);
    }
    public abstract void doSomeThing1();
    public abstract void doSomeThing2();
}

中介者实现：

package com.kaisen.mainland.Text;

/**
 * @author huzhibo
 * @Description: 中介者实现类
 * @date 2020/9/10 20:48
 */
public class ColleagueMediator extends AbstractMediator {
    @Override
    public void doSomeThing1() {
        super.colleague1.selfMethod1();
        super.colleague2.selfMethod2();
    }

    @Override
    public void doSomeThing2() {
        super.colleague1.selfMethod1();
        super.colleague2.selfMethod2();
    }
}

抽象同事类：

package com.kaisen.mainland.Text;

/**
 * @author huzhibo
 * @Description: 同事抽象类
 * @date 2020/9/10 20:49
 */
public abstract class AbstractColleague {
    public AbstractMediator mediator;
    public AbstractColleague(AbstractMediator mediator){
        this.mediator = mediator;
    }
}

同事实现类：

package com.kaisen.mainland.Text;

/**
 * @author huzhibo
 * @Description: 同事类1
 * @date 2020/9/10 20:42
 */
public class Colleague1 extends AbstractColleague {
    public Colleague1(AbstractMediator mediator) {
        super(mediator);
    }
    public void selfMethod1(){
        System.out.println("同事1自有的业务逻辑");
    }
    public void depMethod1(){
        System.out.println("同事1自有的依赖方法");
        super.mediator.doSomeThing1();
    }
}
package com.kaisen.mainland.Text;

/**
 * @author huzhibo
 * @Description: 同事类2
 * @date 2020/9/10 20:42
 */
public class Colleague2 extends AbstractColleague{
    public Colleague2(AbstractMediator mediator) {
        super(mediator);
    }
    public void selfMethod2(){
        System.out.println("同事2自有的业务逻辑");
    }
    public void depMethod2(){
        System.out.println("同事2自有的依赖方法");
        super.mediator.doSomeThing1();
    }
}

切记，抽象中介者一定要有空参构造中，空参构造传输两个对象。

中介者模式比较简单，就是把多个对象中的公共方法提升到中介者中完成，并可以由对象完成控制，体现了依赖倒置的原则。但是同事中介者模式是一个很忌讳滥用的模式，滥用之后不仅不会优化代码，反而使得中介者类十分冗余。

优点：解耦合，把多个互相依赖的类变成一对一依赖的类，网状依赖关系转化为星状依赖关系，更加便于维护。

缺点：过分滥用中介者模式会使中介者实现类十分庞大，所有的方法都需要修改中介者实现类。维护复杂。

成也萧何败也萧何，中介者模式出现时为了维护便捷，统一管理，但是一旦滥用会造成测试复杂，维护成本及高。