中介者模式

应用场景

当类的关系图呈现网状结构的时候，这时可以考虑使用使用中介者模式，它能够将这种网状结构的类关系转化为星型结构，降低了类与类之间的耦合度。

类图描述

Mediator：抽象中介者，定义同一接口，用于各同事角色之间的通讯

ConcreteMediator:具体中介角色，协调各同事角色实现协作行为

Colleague:每个同事角色都知道中介者角色，并且与其他同时角色进行通信的时候一定要通过中介者角色协作。每个同事类有两种行为：自发行为(自行完成，不依赖他人)，依赖方法(需要借助中介者才能完成)

示例代码

通用抽象中介者

这里将具体的同事类而不将抽象同事类进行注入，是因为每个同事类干的活是不一样的

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();
        super.c2.selfMethod2();
    }

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

抽象同事类

抽象同事类中需要持有中介的引用，是因为自己干不了的事可以提交给中介来处理

public abstract class Colleague{
    protected Mediator mediator;
    public Colleague(Mediator _mediator){
        this.mediator = _mediator;
    }
}

具体同事类

public class ConcreteColleague1 extends Colleague{
    //通过构造函数传递中介者
    public ConcreteColleague1(Mediator _mediator){
        super(_mediator);
    }
    
    //自由方法self-method
    public void selfMethod1(){
        //处理自己的业务逻辑
    }
    
    //依赖方法dep-method
    public void depMethod1(){
        //处理自己的业务
　　    //自己不能处理的委托中介处理
    　　super.mediator.doSomething1();
    }
}