中介者模式

也叫调停者模式，顾名思义，是一个中间人。多个类之间需要相互交互，难以管理，将结构改成星形，所有的交互全都交给中介去管理。

比如有三个彼此需要交互的 colleague(同事)类：DengTa、BangZi、GuiZi。

不使用中介的例子

public class DengTa {

    // 收保护费
    public void shouBHF() {
        GuiZi bz = new GuiZi(); 
        BangZi bz = new BangZi();
        gz.jiaoBHF(4); // 鬼子上交 4 千亿
        bz.jiaoBHF(1); // 棒子上交 1 千亿
    }

    // 收拾
    public boolean shouShi(String name) {
        if (Random().nextInt(2) == 1) {
            System.out.println("算了，放他们一码")
            return false;
        }
        if (name.equals("BangZi")) {
            System.out.println("狗东西找死");
        } else if (name.equals("GuiZi")) {
            System.out.println("儿子不听话，找打")
        }
        return true;
    }

}

public class GuiZi {
    private bhf = 0;

    // 最终交了多少保护费
    public int getBFH() {
        return bhf;
    }

    public void setBFH(int number) {
        this.bhf = bhf;
    }
    
    // 上交保护费
    public void jiaoBHF(int number) {
        DengTa dt = new DengTa();
        BangZi bz = new BangZi();
        
        if (bz.maGuiZi()) { // 棒子骂我
            if (dt.shouShi("BangZi")) { // 爸爸帮我收拾它一顿
                bhf = number * 2; // 心情好，交两倍
            } else { // 爸爸没有帮我收拾
                bhf = number / 2; // 心情不好，少交一半
            }
        }
        
        bhf = number;
        System.out.println("给爸爸交保护费：" + bhf);
    }
}

public class BangZi {
    
    // 骂它
    public boolean maGuiZi() {
        System.out.print("鬼子你个混蛋，我与你誓不两立")
        return true;
    }
    
    public void jiaoBHF(int number) {
        DengTa dt = new DengTa();
        GuiZi gz = new GuiZi();
        int gzBHF = gz.getBFH();
        if (gzBHF == 0) {
            System.out.println("他还没交，主人先从他那收到钱，我再给");
        } else if (gzBHF < 4) {
            System.out.println("他才交了这么一点，那我只能交保护费 " + number/2);
        } else {
            System.out.println("给主人交保护费：" + number);
        }
    }
}

每一个类都要和另外两个类交互，类越多，关系越复杂。这时候如果有一个中介者(Mediator)，它知道所有类，负责统一处理这些事件，而别的 colleague 只需要和它打交道就行了。

使用中介者

public abstract class AbstractMediator { 
    protected DengTa dt; 
    protected GuiZi gz;  
    protected BangZi bz;

    // setter/getter

    //中介者最重要的方法叫做事件方法，处理多个对象之间的关系 
    // str 是具体指令，objects 是可能调用方法需要的参数 
    public abstract void execute(String str,Object...objects);
}

public class Mediator extends AbstractMediator {
    public void execute(String str,Object...objects){ 
        if(str.equals("dengTa.shouBHF")){ //灯塔收保护费
            this.dengTaShouBHF(); 
        }else if(str.equals("guiZi.jiaoBHF")){ //鬼子交保护费
            this.guiZiJiaoBHF(); 
        }else if(str.equals("bangZi.jiaoBHF")){ //棒子交保护费
            this.bangZiJiaoBHF();  
        }
    }

    private void dengTaShouBHF() {
        gz.jiaoBHF(4); // 鬼子上交 4 千亿
        bz.jiaoBHF(1); // 棒子上交 1 千亿
    }


    private int guiZiJiaoBHF() {
        int bhf = number;
        if (bz.maGuiZi()) { // 棒子骂我
            if (dt.shouShi("BangZi")) { // 爸爸帮我收拾它一顿
                bhf = number * 2; // 心情好，交两倍
            } else { // 爸爸没有帮我收拾
                bhf = number / 2; // 心情不好，少交一半
            }
        }
        bhf = number;
        gz.setBHF(bhf);
        System.out.println("给爸爸交保护费：" + bhf);
    }

    private int bangZiJiaoBHF() {
        int gzBHF = gz.getBFH();
        if (gzBHF == 0) {
            System.out.println("他还没交，主人先从他那收到钱，我再给");
        } else if (gzBHF < 4) {
            System.out.println("他才交了这么一点，那我只能交保护费 " + number/2);
        } else {
            System.out.println("给主人交保护费：" + number);
        }
    }

}

改造 colleague，要持有中介引用。

public abstract class AbstractColleague {  
    protected AbstractMediator mediator;  
    // 构造控制必须传进来一个中介
    public AbstractColleague(AbstractMediator _mediator){
        this.mediator = _mediator;
    } 
}

public class DengTa extends AbstractColleague{ 
    public DengTa(AbstractMediator _mediator){
        super(_mediator);
    }  
    

    // 收保护费，需要和别人交互的全部委托给中介
    public void shouBHF() {
        super.mediator.execute("dengTa.shouBHF");
    }

    // 收拾
    public boolean shouShi(String name) {
        if (Random().nextInt(2) == 1) {
            System.out.println("算了，放他们一码")
            return false;
        }
        if (name.equals("BangZi")) {
            System.out.println("狗东西找死");
        } else if (name.equals("GuiZi")) {
            System.out.println("儿子不听话，找打")
        }
        return true;
    }
}

public class GuiZi {
    private bhf = 0;

    // 最终交了多少保护费
    public int getBFH() {
        return bhf;
    }

    public void setBFH(int number) {
        this.bhf = bhf;
    }
    
    // 上交保护费
    public void jiaoBHF(int number) {
        super.mediator.execute("guiZi.jiaoBHF");
    }
}

public class BangZi {
    
    // 骂它
    public boolean maGuiZi() {
        System.out.print("鬼子你个混蛋，我与你誓不两立")
        return true;
    }
    
    public void jiaoBHF(int number) {
        super.mediator.execute("bangZi.jiaoBHF");
    }
}

这样每个类只需要处理自己的方法，要交互直接扔给中介。

模式定义

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

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() { 
        //调用同事类的方法，只要是public方法都可以调用 
        super.c1.selfMethod1(); 
        super.c2.selfMethod2();
    }  
    public void doSomething2() {
        super.c1.selfMethod1(); 
        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();
    } 
}

特点

1. 减少类间的依赖，把原有的一对多的依赖变成了一对一的依赖。
2. 同事类只依赖中介者，减少了依赖，同时也降低了类间的耦合。
3. 中介者会膨胀得很大，而且逻辑复杂。
4. 适用于多个对象之间紧密耦合的情况，就是在类图中出现了蜘蛛网状结构。在这种情况下要考虑使用中介者模式变成星型结构。