16. 23种经典设计模式-310-中介者模式

迷南。 2024-04-17 14:53 56阅读 0赞

## 1. 中介者模式(Mediator Pattern) ##

> Define an object that encapsulates how a set of objects interact. Mediator promotes loose coupling by keeping objects from referring to each other explicitly, and it lets you vary their interaction independently. (用一个中介对象封装一系列的对象交互, 中介者使各个对象不需要再显示地相互作用，从而使其耦合松散，而且可以独立地改变它们之间的交互.)

### 1.1 中介者模式-核心思想 ###

![format_png][]

### 1.2 中介者模式-类图 ###

中介者模式主要有三个角色:

*  Mediator: 抽象中介者角色, 定义一个接口，用于与各同事(Colleague)对象通信
 *  ConcreateMediator: 具体中介者角色, 通过协调各同事对象实现协作行为
 *  Colleague: 同事角色. 每一个同事角色都知道它的中介者类，当需要和同事对象交互时，与它的中介者进行通信

### 1.3 中介者模式-优缺点 ###

*  优点: 减少类的依赖, 降低类直接的耦合. 将原有的一对多，改成了一对一的结构.
 *  缺点: 中介者角色逻辑复杂，类膨胀很大

### 1.4 中介者模式-适用场景 ###

*  MVC 框架, 就是典型的中介者模式. C(Controller) 便是M(Model) 和 V(View) 的中介者
 *  当多个对象产生了相互的依赖关系，环形依赖
 *  调度系统，中介服务等

## 2. 环形依赖应用示例 ##

我们来举一个环形依赖的示例, 假设现有销售员和库存两个类， 销售员销售时，需要判断库存数量. 库存进货时，需要判断销售员的月销量. 这样便成了造成了环形依赖.

### 2.1 类图 ###

![format_png 1][]

### 2.2 销售员类-SaleMan ###

*  耦合仓库类Stock, 在进行销售时判断库存数量

public class SaleMan { 
    
        private String name;
    
        private int mothSale;
    
        private Stock stock;
    
        public SaleMan(String name, int mothSale) { 
            this.name = name;
            this.mothSale = mothSale;
        }
    
        public int getMothSale() { 
            return mothSale;
        }
    
        public String getName(){ 
            return this.name;
        }
    
        public void setStock(Stock stock) { 
            this.stock = stock;
        }
    
        // 销售时需要判断库存是否充足
        public void sale(int num) { 
            if (num > stock.getTotal()) { 
                System.out.printf("库存不足!仅剩余%d台\n", num);
            }else { 
                System.out.printf("%s销售了%d台电脑\n", this.name, num );
                stock.decrease(num);
                this.mothSale += num;
            }
        }
    
    }

### 2.3 仓库类-Stock ###

*  仓库申请补货时，需要判断销售员的月销量.

// 库存
    public class Stock { 
    
        private int total;
    
        private SaleMan sale;
    
        public Stock(int total) { 
            this.total = total;
        }
    
        public void setSale(SaleMan sale) { 
            this.sale = sale;
        }
    
        public int getTotal(){ 
            return this.total;
        }
    
        public void decrease(int num) { 
            this.total -= num;
        }
    
        public void increase(int num) { 
            this.total += num;
        }
    
        // 申请捕获时需判断销售的数量
        public void applyIncreate(int num) { 
            if (sale.getMothSale() < num) { 
                System.out.printf("拒绝%s的补货%d台的申请,月销量%d小于申请数量%d\n", sale.getName(), num, sale.getMothSale(), num);
            }else { 
                System.out.printf("同意%s的补货%d台的申请, 准备进货!\n", sale.getName(), num);
                this.increase(num);
            }
        }
    }

### 3.4 测试 ###

@Test
    public void test() { 
    
        Stock stock = new Stock(100);
        SaleMan sale = new SaleMan("zhangsan", 80);
    
        // 设置相互依赖
        sale.setStock(stock);
        stock.setSale(sale);
    
        // 申请补货
        stock.applyIncreate(100);
    
        // 被拒绝后，努力再销售30台
        sale.sale(30);
    
        // 在销售100台，库存不足
        sale.sale(100);
    
        // 申请补货
        stock.applyIncreate(100);
    }

### 3.5 测试输出 ###

拒绝zhangsan的补货100台的申请,月销量80小于申请数量100
    zhangsan销售了30台电脑
    库存不足!仅剩余100台
    同意zhangsan的补货100台的申请, 准备进货!

## 3 中介者模式-应用示例 ##

我们借助中介者模式来改进上述环形依赖的示例

### 3.1 类图 ###

\[外链图片转存失败(img-Oal17Ygr-1566895244024)(https://raw.githubusercontent.com/zongf0504/blog-images/master/images/design-parttern/ldp-mediator-02.png)\]

### 3.2 抽象中介者接口-IMediator ###

public interface IMediator { 
    
        public void execute(String cmd, int num);
    
    }

### 3.3 具体中介者-Mediator ###

public class Mediator implements IMediator{ 
    
        private SaleManColleague saleColleague;
    
        private StockColleague stockColleague;
    
        public void setSaleColleague(SaleManColleague saleColleague) { 
            this.saleColleague = saleColleague;
        }
    
        public void setStockColleague(StockColleague stockColleague) { 
            this.stockColleague = stockColleague;
        }
    
        @Override
        public void execute(String cmd, int num) { 
    
            if ("buy".equals(cmd)) { 
                if (saleColleague.getMothSale() < num) { 
                    System.out.printf("拒绝%s的补货%d台的申请,月销量%d小于申请数量%d\n", saleColleague.getName(), num, saleColleague.getMothSale(), num);
                }else { 
                    stockColleague.increase(num);
                    System.out.printf("同意%s的补货%d台的申请, 准备进货!\n", saleColleague.getName(), num);
                }
            }else if("sale".equals(cmd)) { 
                if (num > stockColleague.getTotal()) { 
                    System.out.printf("库存不足!仅剩余%d台\n", num);
                }else { 
                    saleColleague.setMothSale(saleColleague.getMothSale() + num);
                    stockColleague.decrease(num);
                    System.out.printf("%s销售了%d台电脑\n", saleColleague.getName(), num );
                }
            }
    
        }
    }

### 3.4 抽象同事类-AbsColleague ###

public class AbsColleague { 
    
        protected IMediator mediator;
    
        public AbsColleague(IMediator mediator) { 
            this.mediator = mediator;
        }
    
    }

### 3.5 销售员-SaleManColleague ###

public class SaleManColleague extends AbsColleague { 
    
        private String name;
    
        private int mothSale;
    
        public SaleManColleague(IMediator mediator, String name, int mothSale) { 
            super(mediator);
            this.name = name;
            this.mothSale = mothSale;
        }
    
        public int getMothSale() { 
            return mothSale;
        }
    
        public String getName(){ 
            return this.name;
        }
    
        public void setMothSale(int mothSale) { 
            this.mothSale = mothSale;
        }
    
        public void sale(int num) { 
            this.mediator.execute("sale", num);
        }
    }

### 3.5 库存-StockColleague ###

// 库存
    public class StockColleague extends AbsColleague{ 
    
        private int total;
    
        public StockColleague(IMediator mediator, int total) { 
            super(mediator);
            this.total = total;
        }
    
        public void decrease(int num) { 
            this.total -= num;
        }
    
        public void increase(int num) { 
            this.total -= num;
        }
    
        public int getTotal(){ 
            return this.total;
        }
    
        public void applyIncrease(int num) { 
            this.mediator.execute("buy", num);
        }
    
    }

### 3.7 测试 ###

@Test
    public void test(){ 
    
        Mediator mediator = new Mediator();
    
        SaleManColleague sale = new SaleManColleague(mediator, "zhangsan", 80);
        StockColleague stock = new StockColleague(mediator, 100);
    
        mediator.setSaleColleague(sale);
        mediator.setStockColleague(stock);
    
        // 申请补货
        stock.applyIncrease(100);
    
        // 被拒绝后，努力再销售30台
        sale.sale(30);
    
        // 在销售100台，库存不足
        sale.sale(100);
    
        // 申请补货
        stock.applyIncrease(100);
    
    }

### 3.8 测试输出 ###

拒绝zhangsan的补货100台的申请,月销量80小于申请数量100
    zhangsan销售了30台电脑
    库存不足!仅剩余100台
    同意zhangsan的补货100台的申请, 准备进货!

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3pvbmdmMDUwNC9ibG9nLWltYWdlcy9tYXN0ZXIvaW1hZ2VzL2Rlc2lnbi1wYXJ0dGVybi9sZHAtbWVkaWF0b3ItMDEucG5n?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3pvbmdmMDUwNC9ibG9nLWltYWdlcy9tYXN0ZXIvaW1hZ2VzL2Rlc2lnbi1wYXJ0dGVybi9sZHAtbWVkaWF0b3ItMDMucG5n?x-oss-process=image/format,png