java设计模式之中介者模式

一、定义：用一个中介对象封装一系列的对象交互，中介者使各对象不须要显示地相互做用，从而使其耦合松散，并且能够独立地改变它们之间的交互。

二、代码实现

/**
 * 抽象中介者
 */
public abstract class AbstractMediator {

    protected Purchase purchase;
    protected Sale sale;
    protected Stock stock;
    //构造函数
    public AbstractMediator(){
        purchase = new Purchase(this);
        sale = new Sale(this);
        stock = new Stock(this);
    }
    
    //中介者最重要的方法叫作事件方法， 处理多个对象之间的关系
    public abstract void execute(String str,Object...objects);
    
}

 

/**
 * 中介者
 */
public class Mediator extends AbstractMediator {

    //中介者最重要的方法
    @Override
    public void execute(String str, Object... objects) {
        if (str.equals("purchase.buy")){ //采购电脑
            this.buyComputer((Integer)objects[0]);
        }else if(str.equals("sale.sell")){ //销售电脑
            this.sellComputer((Integer)objects[0]);
        }else if(str.equals("sale.offsell")){ //折价销售
            this.offSell();
        }else if(str.equals("stock.clear")){ //清仓处理
            this.clearStock();
        }
    }
    //采购电脑
    private void buyComputer(int number){
        int saleStatus = super.sale.getSaleStatus();
        if(saleStatus > 80){ //销售状况良好
            System.out.println("采购IBM电脑:"+number + "台");
            super.stock.increase(number);
        }else{ //销售状况很差
            int buyNumber = number/2; //折半采购
            System.out.println("采购IBM电脑： "+buyNumber+ "台");
            super.stock.increase(buyNumber);
        }
    }
    //销售电脑
    private void sellComputer(int number){
        if(super.stock.getStockNumber()<number){ //库存数量不够销售
            super.purchase.buyIBMcomputer(number);
        }
        super.stock.decrease(number);
    }
    //折价销售电脑
    private void offSell(){
        System.out.println("折价销售IBM电脑"+super.stock.getStockNumber()+"台");
    }
    //清仓处理
    private void clearStock(){
        //要求清仓销售
        super.sale.offSale();
        //要求采购人员不要采购
        super.purchase.refuseBuyIBM();
    }
    
}

 

/**
 * 抽象同事类
 */
public abstract class AbstractColleague {

    protected AbstractMediator mediator;
    
    public AbstractColleague(AbstractMediator _mediator){
        this.mediator = _mediator;
    }
}

 

/**
 * 采购管理
 * Purchase类处理本身的职责， 与外界有关系的事件处理则交给了中介者来完成
 */
public class Purchase extends AbstractColleague {

    public Purchase(AbstractMediator _mediator) {
        super(_mediator);
    }
    
    //采购IBM电脑
    public void buyIBMcomputer(int number){
        super.mediator.execute("purchase.buy", number);
    }
    
    //再也不采购IBM电脑
    public void refuseBuyIBM(){
        System.out.println("再也不采购IBM电脑");
    }
}

 

/**
 * 销售管理
 */
public class Sale extends AbstractColleague {

    public Sale(AbstractMediator _mediator) {
        super(_mediator);
    }
    //销售ibm电脑
    public void sellIBMComputer(int number){
        super.mediator.execute("sale.sell", number);
        System.out.println("销售IBM电脑"+number+"台");
    }
    //反馈销售状况， 0～100之间变化， 0表明根本就没人卖， 100表明很是畅销， 出一个卖一个
    public int getSaleStatus(){
        Random rand = new Random(System.currentTimeMillis());
        int saleStatus = rand.nextInt(100);
        System.out.println("IBM电脑的销售状况为： "+saleStatus);
        return saleStatus;
    }
    //折价处理
    public void offSale(){
        super.mediator.execute("sale.offsell");
    }
}

 

/**
 * 库存管理
 */
public class Stock extends AbstractColleague {
    public Stock(AbstractMediator _mediator) {
        super(_mediator);
    }
    //刚开始有100台电脑
    private static int COMPUTER_NUMBER = 100;
    
    //库存增长
    public void increase(int number) {
        COMPUTER_NUMBER = COMPUTER_NUMBER + number;
        System.out.println("库存数量为：" + COMPUTER_NUMBER);
    }
    //库存减小
    public void decrease(int number) {
        COMPUTER_NUMBER = COMPUTER_NUMBER - number;
        System.out.println("库存数量为： "+COMPUTER_NUMBER);
    }
    //得到库存数量
    public int getStockNumber(){
        return COMPUTER_NUMBER;
    }
    //存货压力大了， 就要通知采购人员不要采购， 销售人员要尽快销售
    public void clearStock(){
        System.out.println("清理存货数量为： "+COMPUTER_NUMBER);
        super.mediator.execute("stock.clear");
    }
}

 

/**
 * 测试类
 */
public class Client {

    public static void main(String[] args) {
        AbstractMediator mediator = new Mediator();
        //采购人员采购电脑
        System.out.println("------采购人员采购电脑--------");
        mediator.purchase.buyIBMcomputer(100);
        //销售人员销售电脑
        System.out.println("\n------销售人员销售电脑--------");
        mediator.sale.sellIBMComputer(1);
        //库房管理人员管理库存
        System.out.println("\n------库房管理人员清库处理--------");
        mediator.stock.clearStock();
    }
}

多个对象相互依赖的状况下，经过增长中介者，每一个对象只处理本身的行为，与本身无关的丢给中介者处理，下降对象的耦合性，提示代码质量。

三、主要由3部分组成：
抽象中介者：抽象中介者角色定义统一的接口，用于各同事角色之间的通讯。
具体中介者：具体中介者角色经过协调各同事角色实现协做行为，所以它必须依赖于各个同事角色。
同事角色：每个同事角色都知道中介者角色，并且与其余的同事角色通讯的时候，必定要经过中介者角色协做。
同事类必须有中介者，而中介者却能够只有部分同事类。
四、优势
减小类间的依赖， 把原有的一对多的依赖变成了一对一的依赖，同事类只依赖中介者，减小了依赖，固然同时也下降了类间的耦合。
五、缺点
中介者会膨胀得很大，并且逻辑复杂，本来N个对象直接的相互依赖关系转换为中介者和同事类的依赖关系，同事类越多，中介者的逻辑就越复杂。
六、使用场景
中介者模式适
用于多个对象之间紧密耦合的状况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构。在这种状况下必定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使本来复杂混
乱的关系变得清晰简单。