18.中介者模式

中介者模式是用一个中介对象来封装一系列的对象交互，中介者使得各个对象不需要显示的互相调用，使其耦合松散，而且可以独立的改变他们之间的交互

本来的情况是客户找houseMaster，houseMaster找wife，这样一层一层追下去，现在全部交给中介来做

 

 

 

 

 

 抽象同事类

/**
 * @author wuyimin
 * @create 2021-07-29 9:56
 * @description 同事的抽象类
 */
public abstract class AbstractColleague {
    protected AbstractMediator mediator;

    public AbstractColleague(AbstractMediator mediator) {
        this.mediator = mediator;
    }

    public void setMediator(AbstractMediator mediator) {
        this.mediator = mediator;
    }
    //每个人自己要做的事情
    public abstract void self();
    //要通知别的类做的事情
    public abstract void notifyOthers();
}

同事实现类(省略B)

/**
 * @author wuyimin
 * @create 2021-07-29 10:00
 * @description 同事类A
 */
public class ColleagueA extends AbstractColleague {
    public ColleagueA(AbstractMediator mediator) {
        super(mediator);
    }

    @Override
    public void self() {
        System.out.println("A同学--->正在做自己分类的事");
    }

    @Override
    public void notifyOthers() {
        System.out.println("A同学通知了B同学--->老板来了，赶紧做事");
        mediator.execute("ColleagueB","self");
    }
}

客户端和中介实现类

public class ConcreteMediator extends AbstractMediator {
    @Override
    public void execute(String name, String method) {
        //分内做事
        if (method.equals("self")) {
            if (name.equals("ColleagueA")) {
                AbstractColleague colleagueA = super.hashtable.get("ColleagueA");
                colleagueA.self();
            } else {
                AbstractColleague colleagueB = super.hashtable.get("ColleagueB");
                colleagueB.self();
            }
            //通知
        } else {
            if (name.equals("ColleagueA")) {
                AbstractColleague colleagueA = super.hashtable.get("ColleagueA");
                colleagueA.notifyOthers();
            } else {
                AbstractColleague colleagueB = super.hashtable.get("ColleagueB");
                colleagueB.notifyOthers();
            }
        }
    }

    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB=new ColleagueB(mediator);
        mediator.add("ColleagueA",colleagueA);
        mediator.add("ColleagueB",colleagueB);
        colleagueA.self();
        colleagueA.notifyOthers();
    }

}

具体中介者类Mediator中的execute()方法中现在就有一堆冗长的判断代码了。虽然可以把它分解并增加到Mediator类中的其它private方法中，但是具体的业务逻辑是少不了的。

所以，在解耦同事类之间的联系的同时，中介者自身也不免任务过重，因为几乎所有的业务逻辑都交代到中介者身上了，这就是中介者模式的不足之处。

对上面的例子还可以进行如下优化(并非针对不足进行优化)：

 

抽象同事类

public abstract class AbstractColleague {
    protected AbstractMediator mediator;
//去掉构造函数中直接使用中介的方法，改为用set注册
//    public AbstractColleague(AbstractMediator mediator) {
//        this.mediator = mediator;
//    }

    public void setMediator(AbstractMediator mediator) {
        this.mediator = mediator;
    }
    //每个人自己要做的事情
    public abstract void self();
    //要通知别的类做的事情
    public abstract void notifyOthers();
}

抽象中介类

public abstract class AbstractMediator {

    protected Hashtable<String, AbstractColleague> hashtable=new Hashtable<>();

    public abstract void execute(String name,String method);

    public void add(String name, AbstractColleague obj){
        //中介者可以和同事动态的建立关系
        obj.setMediator(this);
        hashtable.put(name,obj);
    }
    public void remove(String name){
        hashtable.remove(name);
    }
}