设计模式-行为型模式-中介者模式

设计模式-行为型模式-中介者模式

行为型模式

划分类和对象的职责。

中介者模式

进销存管理，即采购，销售，库存。

其中类图

代码如下

public class Purchase {
    // 采购IBM电脑
    public void buyIBMcomputer(int number){
        // 访问库存
        Stock stock = new STock();
        // 访问销售
        Sale sale = new Sale();
        // 电脑销售情况
        int saleStatus = sale.getSaleStatus();
        // 对销售进行判断
        if(saleStatus > 80){    // 销售情况良好
            System.out.println("采购IBM电脑" + number + "台");
            // 往库存里放入产品
            stock.increase(number);
        }else {
            int buyNumber = number / 2;    // 折半销售
            System.out.println("采购IBM电脑" + number + "台");
        }
    }
    // 不再采购IBM电脑
    public void refuseBuyIBM(){
        System.out.println("不再采购IBM电脑");
    }
}

该Purchase定义了采购电脑的标准。根据电脑的销售情况，往库存里放入产品。如果销售不好，则折半销售。
另外定义了一个不再采购IBM电脑。

库存管理

public class Stock{
    // 初始化
    private static int COMPUTER_NUMBER = 100;
    // 库存增加
    public void increase(int number){
        COMPUTER_NUMBER = COMPUTER_NUMBER + number;
    }
    // 库存降低
    public void decrease(int number){
        COMPUTER_NUMBER = COMPUTER_NUMBER - number;
    }
    // 获得库存数量
    public int getStockNumber(){
        return COMPUTER_NUMBER;
    }
    // 通知销售进行销售
    public void clearStock(){
        Purchase purchase = new Purchase();
        Sale sale = new Sale();
        sale.offSale();    // 折半销售
        purchase.refuseBuyIBM();    // 要求不再采购
    }
}

然后书写销售管理

public class Sale{
    // 销售
    public void sellIBMComputer(int number){
        // 访问库存
        Stock stock = new Stock();
        // 访问采购
        Purchase purchase = new Purchase();
        if(stock.getStockNumber() < number){    // 如果库存数量不足，进行购买
            purchase.buyIBMcomputer(number);
        }
        stock.decrase(number);    // 销售完成以后，清理库存
    }
    // 反馈销售情况,根据销售判断是否折半
    public int getSaleStatus(){
        Random rand = new Random(System.currentTimeMillis());
        int saleStatus = rand.nextint(100);
        return saleStatus;
    }
    // 进行折半销售
    public void offSale(){
        Stock stock = new Stock();
    }
    
}

最后绘制场景

public class Client{
    public static void main(String[] args){
        // 采购人员采购电脑
        Purchase purchase = new Purchase();
        purchase.buyIBMcomputer(100);
        // 销售电脑
        Sale sale = new Sale();
        sale.selllBMComputer(1);
        // 库房管理人员管理库存
        Stock stock = new Stock();
        stock.clearStock();
    }
}

改进

违反迪米特。
增加中介者

// 抽象中介者
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{
    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)object[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){    // 如果销售良好
            super.stock.increase(number);
        }else{
            int buyNumber = number / 2;
        }
    }
    private void sellComputer(int number){
        if(super.stock.getStockNumber() < number){ // 库存不够销售的时候
            super.purchase.buyIBMcomputer(number);
        }
        super.stock.decrease(number);
    }
    // 折半销售电脑
    private void offSell(){
        
    }
    // 清仓处理
    private void clearStock(){
        // 要求清仓销售
        super.sale.offSale();
        // 要求采购人员不要采购
        super.purchase.refuseBuyIBM();
    }
}

然后对同事进行抽象

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

采购类

public class Purchase extends AbstractColleague{
    public Purchase(AbstractMediator _mediator){    // 和中介建立联系
        super(_mediator);
    }
    // 采购电脑
    public void buyIBMcomputer(int number){
        super.meidator.execute("purchase.buy", number);
    }
    // 不在采购电脑
    public void refuseBuyIBM(){
        
    }
}

对于库存管理

public class Stock extends AbstractColleague{
    public Stock(ABstractMediator _mediator){
        super(_meidator);
    }
    // 刚刚开始电脑
    private static int COMPUTER_NUMBER = 100;
    // 库存通知
    public void increase(int number){
        COMPUTER_NUMBER = COMPUTER_NUMBRT + number;
    }
    // 库存降低
    public void decrease(int number){
        COMPUTER_NUMBER = COMPUTER_NUMBER - number;
    }
    // 获得库存数量
    public int getStockNumber(){
        return COMPUTER_NUMBER;
    }
    // 存货量多，不采购，进行销售
    public void clearStock(){
        super.mediator.execute("stock.clear");
    }
}

销售管理，类似不在阐述。
对于场景类进行修改如下

public class Client{
    public static void main(String[] args){
        AbstractMediator mediator = new Mediator();
        Purchase purchase = new Purchase(mediator);    // 传入具体的场景
        purchase.buyIBMcomputer(100);
        Sale sale = new Sale(mediator);
        sale.sellIBMComputer(1);
        Stock stock = new Stock(mediator);
        stock.clearStock();
    }
}

应用

MVC，网关，一个购物车栗子，需求为选择颜色，并输入购买数量，要求和从后台获取到的库存进行对比，在页面显示。思路，为三方，库存数据，输入数据，显示结果，引入中介者，在中介者内部进行数据的判断，并将结果输出，如果此时需要增加新的选项，直接在中介者内部书写业务代码即可。

总结

有中介者和同事类，中介者通过get和set方法将同事传入，然后进行数据的交换，中介完成任务，然后同事类，通过构造方法将中介传入，然后和中介进行交流，获取信息。
中介，get，set传入同事，进行数据处理，交换。
同事，通过构造传入，进行和中介通信。