中介模式

原文地址:https://www.jianshu.com/p/298ef103b484

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

看一下类图

 

中介模式类图

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

以下是代码
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就是一个中介者
在现实生活中我们从中介租房子也是一种中介模式,这里要吐槽一下黑心中介

  • 0
    点赞
  • 2
    收藏
    觉得还不错? 一键收藏
  • 0
    评论

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值