中介者模式

Love The Way You Lie 2022-03-14 15:42 232阅读 0赞

> 中介者模式适用于，完成一件事情，需要多方面协同合作，而多方面之间的耦合性较紧密

有一个场景

采购部门要采购IBM的电脑，它根据以下两个要素来决定采购数量。

*  销售情况

销售部门要反馈销售情况，畅销就多采购，滞销就不采购。

*  库存情况

即使是畅销产品，库存都有1000台了，每天才卖出去10台，也就不需要再采购了！

销售模块是企业的赢利核心，对其他两个模块也有影响：

*  库存情况

库房有货，才能销售，空手套白狼是不行的。

*  督促采购

在特殊情况下，比如一个企业客户要一次性购买100台电脑，库存只有80台，这时需要  
催促采购部门赶快采购！

从以上分析来看，这三个模块都有自己的行为，并且与其他模块之间的行为产生关联，  
类似于我们办公室的同事，大家各干各的活，但是彼此之间还是有交叉的，于是彼此之间就  
产生紧耦合

#### 采购管理 ####

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电脑：" + buyNumber + "台");
                stock.increase(buyNumber);
            }
        }
    
        // 不再采购IBM电脑
        public void refuseBuyIBM() {
            System.out.println("不再采购IBM电脑");
        }
    }

#### 库存管理 ####

public class Stock {
    
        //刚开始有100台电脑
        private static int COMPUTER_NUMBER = 100;
    
        //库存增加
        public void increase(int number) {
            COMPUTER_NUMBER += number;
            System.out.println("库存数量为：" + COMPUTER_NUMBER);
        }
    
        //库存降低
        public void decrease(int number) {
            COMPUTER_NUMBER -= number;
            System.out.println("库存数量为：" + COMPUTER_NUMBER);
        }
    
        //获得库存数量
        public int getStockNumber() {
            return COMPUTER_NUMBER;
        }
    
        //存货压力大了，就要通知采购人员不要采购，销售人员要尽快销售
        public void clearStock() {
            Purchase purchase = new Purchase();
            Sale sale = new Sale();
            System.out.println("清理存货数量为：" + COMPUTER_NUMBER);
            //要求折价销售
            sale.offSale();
            //要求采购人员不要采购
            purchase.refuseBuyIBM();
        }
    }

#### 销售管理 ####

public class Sale {
    
        //销售IBM电脑
        public void sellIBMComputer(int number) {
            //访问库存
            Stock stock = new Stock();
            //访问采购
            Purchase purchase = new Purchase();
            while (stock.getStockNumber() < number) {
                // 库存数量不够销售
                purchase.buyIBMcomputer(number);
            }
            System.out.println("销售IBM电脑" + number + "台");
            stock.decrease(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() {
            //库房有多少卖多少
            Stock stock = new Stock();
            System.out.println("折价销售IBM电脑" + stock.getStockNumber() + "台");
        }
    }

#### 场景类 ####

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

#### 运行结果 ####

------采购人员采购电脑--------
    IBM电脑的销售情况为：51
    采购IBM电脑：50台
    库存数量为：150
    
    ------销售人员销售电脑--------
    IBM电脑的销售情况为：51
    采购IBM电脑：500台
    库存数量为：650
    IBM电脑的销售情况为：51
    采购IBM电脑：500台
    库存数量为：1150
    销售IBM电脑1000台
    库存数量为：150
    
    ------库房管理人员清库处理--------
    清理存货数量为：150
    折价销售IBM电脑150台
    不再采购IBM电脑

但是这个造就了很高的偶合度，这并不是我们所希望的，我们所希望得解耦合

耦合性越大，要想修改一个就得修改一片，这不是面向对象设计所期望的

如果我们的管理部门多了怎么办，那显然这样是不合适的

所以我们需要一个中介者，来作为这三个部门的交流核心

#### 虚拟中介者类 ####

public abstract class AbstractMediator {
        protected NewPurchase purchase;
        protected NewSale sale;
        protected NewStock stock;
    
        //构造函数
        public AbstractMediator() {
            purchase = new NewPurchase(this);
            sale = new NewSale(this);
            stock = new NewStock(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 + "台");
            }
        }
    
        //销售电脑
        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电脑" + 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;
        }
    }

--------------------

public class NewPurchase extends AbstractColleague {
    
        public NewPurchase(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 NewStock extends AbstractColleague {
    
        public NewStock(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 NewSale extends AbstractColleague {
    
        public NewSale(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 NewClient \{

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

--------------------

#### 中介者模式的优点 ####

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

#### 中介者模式的缺点 ####

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

#### 中介者模式的使用场景 ####

中介者模式适用于多个对象之间紧密耦合的情况，紧密耦合的标准是：在类图中出现了蜘蛛网状结构。在这种情况下一定要考虑使用中介者模式，这有利于把蜘蛛网梳理为星型结构，使原本复杂混乱的关系变得清晰简单