中介者模式

1.使用场景:
系统中的关系比较复杂，存在网状的关系。例如经典的MVC模式中的”C”-Controller就是一个中介者对象还有例如Java反射中的invoke()方法中也是使用到了中介者模式。
2.UML表示
2.1 Mediator：抽象中介者角色，定义了同事对象到中介者对象的接口，一般以抽象类的方式实现。
2.2 ConcreteMediator：具体中介者角色，继承于抽象中介者，实现了父类定义的方法，它从具体的同事对象接受消息，向具体同事对象发出命令。
2.3 Colleague：抽象同事类角色，定义了中介者对象的接口，它只知道中介者而不知道其他的同事对象。
2.4 ConcreteColleague1、ConcreteColleague2：具体同事类角色，继承于抽象同事类，每个具体同事类都知道本身在小范围的行为，而不知道在大范围内的目的。

具体的UML示意图如下：

3.代码实现

定义中介者接口:

 

public interface Mediator {
    /**    
     *   
     * @author lsj  
     * @date 2018/2/14 16:43  
     * @param [dName, dt]  
     * @return void  
     */ 
    void register(String dName,Department dt);
    /**    
     *   
     * @author lsj  
     * @date 2018/2/14 16:43  
     * @param [dName]  
     * @return void  
     */ 
    void command(String dName);

}

实现接口:

 

 

public class President implements Mediator{
    private Map<String,Department> map=new HashMap<>();
    @Override
    public void register(String dName, Department dt) {
        map.put(dName,dt);
    }
    @Override
    public void command(String dName) {
        map.get(dName).selfAction();
    }
}

定义Department接口:

 

 

public interface Department {
    /**    
     *   
     * @author lsj  
     * @date 2018/2/14 16:45  
     * @param []  
     * @return void  
     */ 
    void selfAction();//
    /**    
     *   
     * @author lsj  
     * @date 2018/2/14 16:45  
     * @param []  
     * @return void  
     */ 
    void outAction();
}

我们定义一个研发部来实现这个接口:

 

 

public class Development implements Department{
    private Mediator m;

    public Development(Mediator m) {
        this.m = m;
    }

    @Override
    public void selfAction() {
        System.out.println("研发");
    }

    @Override
    public void outAction() {
        System.out.println("需要资金");
    }
}

限于篇幅，这里省略其他的部门类。
最后，我们通过一个简单的例子进行测试：

public class Client {
    public static void main(String[] args) {
        Mediator m=new President();//中介者对象
        Market market=new Market(m);
        market.selfAction();
        market.outAction();
    }
}

4.总结
中介者模式用于解耦多个对象之间的关系。每个对象都会持有一个中介者的对象，然后通过中介者统一管理这些交互的关系。
下面给出项目的链接:
https://github.com/memoryexplosion/design_pattern_review/tree/master/src/java/mediator