调停者模式

调停者模式定义：

用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。将网状调用关系变成星调用关系。将多对多的关系化解成一对多的关系。

类图：

源代码：

/**
 * 职员接口
 */
abstract class Employee {
    String name;
    private Mediator mediator;
    public Employee(Mediator mediator,String name){
        this.mediator = mediator;
        this.name = name;
    }
    //被调停者调用的方法
    public void called(String message,String fromName){
        System.out.println(this.name + "接收到来自"+ fromName + "的需求：" + message);
    }
    //调用调停者
    public void call(String message,String toName){
        System.out.println(this.name + "发起需求："+ message);
        mediator.send(message,this.name,toName);
    }
}

interface Mediator {

    void addEmployee(String name, Employee employee);

    void send(String message,String fromName,String toName);
}

/**
 * 调停者：经理
 */
class Manager implements Mediator {
    private Map<String,Employee> employeeMap = new HashMap<String, Employee>();

    @Override
    public void addEmployee(String name, Employee employee) {
        employeeMap.put(name, employee);
    }

    @Override
    public void send(String message,String fromName,String toName) {
        System.out.println("经理收到" + fromName + "的需求：" + message);
        System.out.println("经理将" + fromName + "的需求发送给目标职员");
        employeeMap.get(toName).called(message,fromName);
    }
}

/**
 * 职员A
 */
class EmployeeA extends Employee {
    public EmployeeA(Mediator mediator, String name) {
        super(mediator, name);
    }
}

/**
 * 职员B
 */
class EmployeeB extends Employee {
    public EmployeeB(Mediator mediator, String name) {
        super(mediator, name);
    }
}

/**
 * 职员C
 */
class EmployeeC extends Employee {
    public EmployeeC(Mediator mediator, String name) {
        super(mediator, name);
    }
}

class Client {
    public static void main(String[] args) {
        //分配职员与经理
        Mediator manager = new Manager();
        Employee employeeA = new EmployeeA(manager,"职员A");
        Employee employeeB = new EmployeeB(manager,"职员B");
        Employee employeeC = new EmployeeC(manager,"职员C");
        manager.addEmployee(employeeA.name,employeeA);
        manager.addEmployee(employeeB.name,employeeB);
        manager.addEmployee(employeeC.name,employeeC);

        //职员A的需求
        String messageA = "这些资料需要B职员操作";
        employeeA.call(messageA,employeeB.name);
        System.out.println();
        //职员C的请求
        String messageC = "这些资料需要B职员签名";
        employeeC.call(messageC,employeeB.name);
    }
}

控制台输出：

职员A发起需求：这些资料需要B职员操作
经理收到职员A的需求：这些资料需要B职员操作
经理将职员A的需求发送给目标职员
职员B接收到来自职员A的需求：这些资料需要B职员操作

职员C发起需求：这些资料需要B职员签名
经理收到职员C的需求：这些资料需要B职员签名
经理将职员C的需求发送给目标职员
职员B接收到来自职员C的需求：这些资料需要B职员签名

总结：

如上所列，职工A和职工C都需要请求职工B，但是假如他们不认识职工B，那么就将工作需求提交给经理，经理再将工作需求发送给职工B。
使用调停者模式貌似要比原本的结构消耗时间，但是却将需求的发起者与执行者之间的强耦合进行了解耦，极大的优化了系统内部的维护工作。
调停者模式降低的是系统内部的耦合性，而外观模式降低的是系统之间的耦合性。
调停者模式更加细化，针对的是系统内部类与类之间的强耦合的解除，外观模式则较为统筹，针对的是整个系统对外的耦合性解除，二者都都有屏蔽复杂性的作用。

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