中介模式

中介模式是用来解决多个对象显示相互调用造成的耦合，使用一个中介来使耦合松散，减少类之间的依赖

看一下类图

中介模式类图

联系一个场景。
角色有采购，销售，和库房。
采购在采购的时候要依赖销售的状态，销售在销售的时候要依据库房的库存，并且销售后要修改库存。清空库存时要让采购停止采购，销售打折销售。这种场景就比较适合中介模式，让他们从网状的结构变成星型结构，使他们除了自己本身的操作外只与中介者产生关系

以下是代码
1，抽象的伙伴类，他们是库存，销售，采购的抽象，负责构造注入抽象的中介供这些角色调用

/**
 * 抽象伙伴类
 */
public abstract class AbstractColleague {
    protected AbstractMediator mediator;
    public AbstractColleague(AbstractMediator abstractMediator){
        this.mediator = abstractMediator;
    }
}

2，具体角色的实现类

/**
 * 采购管理
 */
public class Purchase extends AbstractColleague{

    public Purchase(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    //不要采购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 abstractMediator) {
        super(abstractMediator);
    }

    //销售IBM电脑
    public void sellIBMComputer(int number){
        super.mediator.execute("sale.offsell",number);
    }

    //反馈销售情况，0~100之间变化，0代表根本就没人买，100代表非常畅销，出一个卖一个
    public int getSaleStatus(){
        Random random = new Random(System.currentTimeMillis());
        int saleStatus = random.nextInt(100);
        System.out.println("IBM电脑销售情况为：" + saleStatus);
        return saleStatus;
    }

    //折价处理
    public void offSale(){
        super.mediator.execute("sale.offsell");
    }
}

/**
 * 存货管理
 */
public class Stock extends AbstractColleague{
    //最开始库存电脑
    private static int COMPUTER_NUMBER = 100;

    public Stock(AbstractMediator abstractMediator) {
        super(abstractMediator);
    }

    //库存增加
    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(){
        super.mediator.execute("clear.stock");
    }
}

3，抽象的中介类，初始化我们的各个角色类，还有一个抽象方法，这个是很重要的方法，各个角色类都是与这个方法沟通

//中介者
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);
}

4，中介者的实现类

public class Mediator extends AbstractMediator {
    @Override
    public void execute(String str, Object... objects) {
        if (str.equals("purchase.buy")){
            //采购电脑
            buyCompter((Integer)objects[0]);
        } else  if (str.equals("sale.sell")){
            //销售电脑
            sellComputer((Integer)objects[0]);
        } else  if (str.equals("sale.offsell")){
            //折价销售
            offSell();
        } else  if (str.equals("clear.stock")){
            //清仓处理
            clearStock();
        }
    }

    private void buyCompter(int number){
        int saleStatus = super.sale.getSaleStatus();
        if (saleStatus > 80){
            //销售情况良好
            System.out.println("采购IBM电脑：" + number+ "台");
            stock.increase(number);
        } else {
            //销售情况不好
            int buyNumber = number/2; //折半采购
            System.out.println("采购IBM电脑：" + buyNumber+ "台");
            stock.increase(number);
        }
    }

    private void sellComputer(int number){
        //库存数量不够
        if (super.stock.getStockNumber() < number){
            super.purchase.buyIBMcomputer(number);
        }
        System.out.println("销售IBM电脑：" + number + "台");
        super.stock.decrease(number);
    }

    private void offSell(){
        System.out.println("折价销售IBM电脑：" + stock.getStockNumber() + "台");
    }

    private void clearStock(){
        //要求折价销售
        super.sale.offSale();
        //要求采购人员不要采购
        super.purchase.refuseBuyIBM();
    }
}

5，调用

public class Main {

    public static void main(String[] args){
        AbstractMediator mediator = new Mediator();

       //采购人员采购电脑
        System.out.println("----------采购人员采购电脑---------------");
        Purchase purchase = new Purchase(mediator);
        purchase.buyIBMcomputer(100);
        System.out.println("----------销售人员销售电脑---------------");
        Sale sale = new Sale(mediator);
        sale.sellIBMComputer(1);
        System.out.println("----------库房管理人员清空处理---------------");
        Stock stock = new Stock(mediator);
        stock.clearStock();
    }
}

总结：我们可以看到我们的各个角色处理自身逻辑的更新，其他操作的沟通都是通过调用中介者的execute()方法，中介者也只是提供了一个操作的函数供各个橘色操作，其他的修改各个对象的状态都是私有在自己内部当中，这样就把各个依赖关系很强的类进行了解耦。
大家可能觉得就三个类，不使用中介模式好像也可以，可如果当类型有几十个，一个操作要更新几十个对象的状态的时候，这种解耦就是有必要的了。
中介者模式很可能会导致我们的架构变复杂所以使用时要谨慎，在类图形成蜘蛛网结构时，这种情况就要考虑将他们梳理成星型结构

中介模式使用非常广泛，在开发中我们经常使用的MVC就是一种，C就是一个中介者
在现实生活中我们从中介租房子也是一种中介模式，这里要吐槽一下黑心中介