设计模式原则14----中介者模式

其他 2018-05-30 12:07:15 阅读次数: 0

个人博客：打开链接

进销存管理

为了引入中介者模式，我们首先来看一下进销存管理这个例子，其UML图为：
这里写图片描述
Purchase负责采购管理，buyIBMComputer指定了采购IBM电脑，refuseBuyIBM是指不再采购IBM了，源代码清单如下：
采购管理：


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

Purchase定义了采购电脑的标准：如果销售情况比较好，大于80分，你让我采购多少我就采购多少；销售情况不好，你让我采购100台，我就采购50台，对折采购。来看一下stock类：
库存管理：


public class Stock {

    //刚开始有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(){
        Purchase purchase = new Purchase();
        Sale sale = new Sale();
        System.out.println("清理库存数量为：" + COMPUTER_NUMBER);
        //要求折价销售
        sale.offSale();
        //要求采购人员不要再采购
        purchase.refuseIBM();
    }
}

销售管理：


import java.util.Random;

public class Sale {

    //销售IBM电脑
    public void sellIBMComputer(int number){
        //访问库存
        Stock stock = new Stock();
        //访问采购
        Purchase purchase = new Purchase();
        if(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("-----------------销售人员销售电脑---------------");
        Sale sale = new Sale();
        sale.sellIBMComputer(1);
        //库存人员管理库存
        System.out.println("-----------------库存人员管理库存---------------");
        Stock stock = new Stock();
        stock.clearStock();
    }
}

然而我们很容易看出，这三个类是彼此关联的，每个类都与其他两个类产生了关联关系。迪米特法则认为“每个类只和朋友类交流”，这个朋友类并非越多越好，朋友类越多，耦合性越大，要想修改一个就得修改一片，这不是面向对象设计所期望的。为了解决这个矛盾，我们引入星型结构的中介者模式。加入一个中介者作为三个模块的交流核心，每个模块之间不再相互交流，要交流就通过中介者进行。每个模块只负责自己的业务逻辑，不属于自己的则丢给中介者来处理，简化了各个模块之间的耦合，来我们看一下UML图：
这里写图片描述
建立了两个抽象类AbstractMediator和AbstractColeague，每个对象只是与中介者Mediator之间产生依赖，与其他对象之间没有直接关系，AbstractMediator的作用是实现中介者的抽象定义，定义了一个抽象方法execute，代码如下：


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.offsale")){//折价销售
            this.offSale();
        }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){// 库存数量不够销售
            purchase.buyIBMComputer(number);
        }
        stock.decrease(number);
    }
    private void offSale() {
        System.out.println("折价销售IBM电脑" + stock.getStockNumber() + "台");
    }

    private void clearStock() {
        //要求清仓销售
        super.sale.offSale();
        //要求采购人员不要采购
        super.purchase.refuseIBM();
    }
}

中介者Mediator定义了多个private方法，其目的是处理各个对象之间的依赖关系，就是说把原有一个对象要依赖多个对象的情况移到中介者的private方法中实现。在实际项目中，一般的做法是中介者按照职责进行划分，每个中介者处理一个或多个类似的关联请求。
由于要使用中介者，我们增加了一个抽象同事类，三个具体的实现类分别继承该抽象类，代码如下：

public abstract class AbstractColleague {

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

修改后的采集管理：


public class Purchase extends AbstractColleague{

    public Purchase(AbstractMediator _mMediator) {
        super(_mMediator);
    }
    //采购IBM电脑
    public void buyIBMComputer(int number){
        super.mediator.execute("puchase.buy", number);
    }
    //不再采购IBM电脑
    public void refuseIBM(){
        System.out.println("不再采购IBM电脑");
    }
}

修改后的库存管理：


public class Stock extends AbstractColleague{

    public Stock(AbstractMediator _mMediator) {
        super(_mMediator);
    }
    //刚开始有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");
    }
}

修改后的销售管理：


import java.util.Random;

public class Sale extends AbstractColleague{

    public Sale(AbstractMediator _mMediator) {
        super(_mMediator);
    }
    //销售IBM电脑
    public void sellIBMComputer(int number){
        System.out.println("销售IBM电脑" + number +"台");
        super.mediator.execute("sale.sell", 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 Client {

    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();
    }
}

在场景类中增加了一个中介者，然后分别传递到三个同事类中，三个类都具有相同的特性：只负责处理自己的活动(行为)，与自己无关的活动就丢给中介者处理，程序运行的结果是相同的。从项目设计来看，加入了中介者，设计结构清晰了许多，而且类间的耦合性大大减少了，代码质量也有了很大的提升。
在多个对象依赖的情况下，通过加入中介者角色，取消了多个对象的关联或依赖关系，减少了对象的耦合性。

中介者模式的定义

英文定义：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.
中文定义：用一个中介对象封装一些列的对象交互，中介者使对象不需要显示地相互作用，从而使其耦合松散，而且可以独立地改变他们之间的交互。
中介者模式通用类图：
这里写图片描述

  • Mediator抽象中介者角色
    抽象中介者角色定义统一的接口，用于各个同事角色之间的通信。

  • ConcreteMediator具体中介者角色
    具体中介者通过协调各个同事角色实现协作行为，因此它必须依赖于各个同事角色。

  • Colleague同事角色
    每个同事角色都知道中介者角色，而且与其他的同事角色通信的时候，一定要通过中介者角色协作。每个同事类的行为分为两种：一种是同事本身的行为，比如改变对象本身的状态，处理自己的行为等，这种行为叫做自发行为(Self-Methos)，与其他的同事类或中介者没有任何的依赖；第二种是必须依赖中介者才能完成的行为，叫做依赖方法(Dep-Method)。
    通用抽象中介者：
public abstract class Mediator {
    //定义同事类
    protected ConcreteColleague c1;
    protected ConcreteColleague c2;
    //通过getter和setter方法把同事类注入进来
    public ConcreteColleague1 getC1() {
        return c1;
    }
    public void setC1(ConcreteColleague1 c1) {
        this.c1 = c1;
    }
    public ConcreteColleague2 getC2() {
        return c2;
    }
    public void setC2(ConcreteColleague2 c2) {
        this.c2 = c2;
    }
    //中介者模式的业务逻辑
    public abstract void doSomething1();
    public abstract void doSomething2();
}

通用中介者：

public calss ConcreteMediator extends Mediator {
    @Override
    public void doSomething1(){
        //调用同事类的方法，只要是public方法都可以调用
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }
    public void doSomething2() {
        super.c1.selfMethod1();
        super.c2.selfMethod2();
    }
}

抽象同事类：

public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator){
        this.mediator = mediator;
    }
}

具体同事类：

public class ConcreteColleague1 extends Colleague {
    //通用构造函数传递中介者
    public ConcreteColleague1(Mediator mediator){
        super(mediator);
    }
    //自有方法 self-method
    public void selfMethod1(){
        //处理自己的业务逻辑
    }
    //依赖方法 dep-method
    public void depMethod1(){
        //处理自己的业务逻辑
        //自己不能处理的业务逻辑，委托给中介者处理
        super.mediator.doSomething1();
    }
}
public class ConcreteColleague2 extends Colleague {
    //通用构造函数传递中介者
    public ConcreteColleague2(Mediator mediator){
        super(mediator);
    }
    //自有方法 self-method
    public void selfMethod2(){
        //处理自己的业务逻辑
    }
    //依赖方法 dep-method
    public void depMethod2(){
        //处理自己的业务逻辑
        //自己不能处理的业务逻辑，委托给中介者处理
        super.mediator.doSomething2();
    }
}

在Mediator抽象类中我们只定义了同事类的注入，而不是同事抽象类的注入–那是因为同事类是虽然有抽象，但是没有每个同事必须要完成的业务方法； 为什么同事类要使用构造函数注入中介者，而中介者则通过setter/getter来注入同事类呢？这是因为同事类必须有中介者，而中介者却可以只有部分同事类

中介者的应用

中介者模式的优点

  • 减少类间依赖
  • 降低类间耦合

中介模式的缺点

  • 中介者会膨胀很大
  • 中介者逻辑复杂–同事类越多的时候

使用场景

  • 量力而行–别使用后反而变得更加复杂
  • 适用于多个对象的紧耦合的情况–蜘蛛网状的结构–>梳理成星型结构，使原本复杂的关系变得更加简单起来

实际应用

  • 中介者模式也叫调停者模式–一个对象要和N个对象交流，就像对象间的战争，很混乱，这时加入一个中心，和所有类都进行交流，中心说怎么处理就怎么处理
  • 机场调度中心–调度每一架飞机的起降
  • MCV框架中的C（Controller）–前端控制器（Font
    Controller），它的作用就是把M（Model，业务逻辑）和V（View，视图）隔离开，协调M和V协同工作，减少他们之间的依赖
  • 媒体网关–MSN服务器（中介者），中转站，接发信件【相反的是IPMsg–每个客户端集市客户端也是服务端】
  • 中介服务–房屋中介、出国中介–主要是省心

最佳实践

如下情况下尝试使用中介者模式：
- N个对象之间产生了相互依赖的关系
- 多个对象有依赖关系，但是依赖的行为尚不确定或者有发生改变的可能—–降低变更引起的风险
- 产品开发（MVC框架），提升产品的性能和扩展性–稳定高效，扩展

猜你喜欢

转载自blog.csdn.net/jinglisen/article/details/80179477
今日推荐
周排行
Leetcode简单题61~80
解决zookeeper磁盘IO高的问题
多线程相关方法详解
Maven-setting.xml文件详解
Maven 项目的 classpath 理解
渊亭科技大数据笔试题
配置JVM内存分配
计算机网络个人学习笔记 （三）网络层 ：第三部分 连载
js中两个等号(==)和三个等号(===)的区别
用C程序自动打开电脑上的程序
每日归档
更多
2024-09-18(0)
2024-09-17(0)
2024-09-16(0)
2024-09-15(0)
2024-09-14(0)
2024-09-13(0)
2024-09-12(0)
2024-09-11(0)
2024-09-10(0)
2024-09-09(0)

代码天地 © 2018 codetd.com

境外服务器   最新电视剧2022