中介者模式

一）故事


二）定义
用一个中介对象封装一系列的对象交互，中介者使各对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

三）代码例子
由四部分组成：1）抽象中介者；2）具体中介者；3）抽象同事类；4）具体同事类（可多个）；
1）抽象中介者：

/**
 *  抽象中介者
 * 
 * @author levovo
 */
public abstract class AbsMediator {
    // 定义同事类
    protected ConcreteColleagua1 c1;
    protected ConcreteColleagua2 c2;
    
    // 通过getter/setter方法把同事类注入进来
    /**
     * @return the c1
     */
    public ConcreteColleagua1 getC1() {
        return c1;
    }

    /**
     * @param c1 the c1 to set
     */
    public void setC1(ConcreteColleagua1 c1) {
        this.c1 = c1;
    }

    /**
     * @return the c2
     */
    public ConcreteColleagua2 getC2() {
        return c2;
    }

    /**
     * @param c2 the c2 to set
     */
    public void setC2(ConcreteColleagua2 c2) {
        this.c2 = c2;
    }
    
    // 中介者的业务逻辑
    public abstract void doSomething1();
    public abstract void doSomething2();
}

2）具体中介者：

/**
 *  具体中介者
 * 
 * @author levovo
 */
public class Mediator extends AbsMediator {
    
    @Override
    public void doSomething1() {
        // doSomething .....
        super.c1.selfMethod1(); // 调用同事类的方法
        // doSomething ......
        super.c2.selfMethod2(); // 调用同事类的方法
        // doSomething .....
    }
    
    @Override
    public void doSomething2() {
        // doSomething .....
        super.c1.selfMethod1(); // 调用同事类的方法
        // doSomething ......
        super.c2.selfMethod2(); // 调用同事类的方法
        // doSomething .....
    }
    
}

3）抽象同事类：

/**
 * 抽象同事类
 * 
 * @author levovo
 */
public abstract class AbsColleague {
    protected AbsMediator mediator;
    public AbsColleague(AbsMediator mediator) {
        this.mediator = mediator;
    }
}

4）具体同事类：

/**
 *  具体同事类1
 * 
 * @author levovo
 */
public class ConcreteColleagua1 extends AbsColleague {
    public ConcreteColleagua1(AbsMediator mediator) {
        super(mediator);
    }
    
    // 自有方法
    public void selfMethod1() {
        // 处理自己的业务逻辑
        System.out.println("ConcreteColleagua1->selfMethod1()");
    }
    
    // 依赖方法
    public void depMethod1() {
        // 处理自己的业务逻辑
         System.out.println("ConcreteColleagua1->depMethod1()");
        // 自己不能处理的业务逻辑，委托给中介者处理
        super.mediator.doSomething1();
    }
}

/**
 * 具体同事类2
 * 
 * @author levovo
 */
public class ConcreteColleagua2 extends AbsColleague {
    public ConcreteColleagua2(AbsMediator mediator) {
        super(mediator);
    }
    
    // 自有方法
    public void selfMethod2() {
        // 处理自己的业务逻辑
         System.out.println("ConcreteColleagua2->selfMethod2()");
    }
    
    // 依赖方法
    public void depMethod2() {
        // 处理自己的业务逻辑
         System.out.println("ConcreteColleagua2->depMethod2()");
        // 自己不能处理的业务逻辑，委托给中介者处理
        super.mediator.doSomething2();
    }
}

场景使用例子：

/**
 *  场景使用例子
 *
 * @author levovo
 */
public class Client {
    public static void main(String[] args) {
        // 中介者
        AbsMediator mediator = new Mediator();
        // 同事类1
        ConcreteColleagua1 c1 = new ConcreteColleagua1(mediator);
        mediator.setC1(c1);
        // 同事类2
        ConcreteColleagua2 c2 = new ConcreteColleagua2(mediator);
        mediator.setC2(c2);
        // 自身的方法
        c1.selfMethod1();
        // 自己不处理，交给中介者
        c1.depMethod1();
        // 自身的方法
        c2.selfMethod2();
        // 自己不处理，交给中介者
        c2.depMethod2();
    }
}

四）优点
减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减少了依赖，当然同时也降低了类间的耦合。

五）缺点
中介者会膨胀得很大，而且逻辑复杂，原本N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。

六）使用场景
机场调度中心，MVC框架，媒体网关，中介服务（租房中介，出国中介）

如下情况可尝试使用中介者模式：
1）N个对象之间产生了相互的依赖关系。
2）多个对象有依赖关系，便是依赖的行为*不确定或者有发生改变的可能，在这种情况下一般建议采用中介者模式，降低变更引起的风险扩散。
3）产品开发。一个明显的例子就是MVC框架，把中介者模式应用到产品中，可以提升产品的性能和扩展性，但是对于项目开发就未必，因为项目是以交付投产为目标，而产品则是以稳定，高效，扩展为宗旨。

七）注意事项

八）扩展

九）总结
在多个对象依赖的情况下，通过加入中介者角色，取消了多个对象的关联或依赖关系，减少了对象的耦合性。