设计模式之中介者模式

FireZHFox

浏览: 335141 次

最近访客更多访客>>

bicheng

chenxr

yefei888

xx5333

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

博客分类：

设计模式

java 设计模式中介者模式调停模式

中介者模式又叫调停模式，定义如下：用一个中介者对象封装一系列的对象的交互，中介者使各个对象不需要显示的相互作用，从而使其耦合松散，而且可以独立的改变他们之间的交互。

通用类图如下：

从图中可以看到，中介者模式由一下几部分组成:

1.抽象中介者模式Mediator

抽象中介模式定义统一的接口，用于各同事角色之间的通信

2.具体中介者模式ConcreteMediator

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

3.同事角色Colleague

每一个同事角色都知道中介者角色，而且其他的同事角色通信的时候，一定要通过中介角色的协作

说完中介者的通用类图，下面看看如何应用以及应用中介者模式有哪些好处

现实生活中存在很多的中介者模式，比如和我们自身相关的那就是租房，大家从学校毕业来到社会上工作的第一件事可能就是租房（有房的除外），然后才是找工作，还有就是机场的调度中心其实也是一个中介者模式的体现，还有我们做开发现在用的最多一种结构MVC也是中介模式的体现，其中C叫做控制器，V--视图，M--业务逻辑，前端想要显示什么数据首先会询问C然后又C去询问M而不是通过V直接询问M，这样的设计就是为了松耦合，这也是中介者模式的优点，下面我们以一个实际应用来说明：

一家奔驰的4S店主要设计到的角色有：销售部门、采购部门、库存部门

销售部门:

销售部门要反馈销售情况，畅销就多采购，不畅销就少采购，同事卖出后要通知库存部门

库存部门：

即使是畅销情况，如果库存已经超过某个上限也就不需要在采购了

下面是没有使用中介者模式的类图

/**
 * 销售部门
 * 
 */
public class Sale {

    // 销售奔驰汽车
    public void sellBenz(int carNum) {

        // 访问库存
        Stock stock = new Stock();
        // 判断购买量和库存量
        if (stock.getStockNum() < carNum) {
            // 库存不够，通知采购部门进行采购
            Purchase purchase = new Purchase();

            purchase.buyBenz(carNum);
        }
        System.out.println("销售汽车：" + carNum + "辆");
        // 更新库存
        stock.decrease(carNum);
    }

    // 打折销售
    public void offSale() {

        // 访问库存
        Stock stock = new Stock();

        System.out.println("打折处理汽车数量:" + stock.getStockNum());
    }

    // 获取销售状态，用数字0-10来表示，0没有销售，10代表非常畅销
    public int getSaleStatus() {

        Random random = new Random(System.currentTimeMillis());

        int saleStatus = random.nextInt(10);

        System.out.println("汽车的销售情况：" + saleStatus);

        return saleStatus;
    }
}

/**
 * 采购部门
 * 
 */
public class Purchase {

    // 采购奔驰汽车
    public void buyBenz(int carNum) {

        // 询问销售部门汽车的销售情况，如果销售状态>8则进行采购，如果是0就暂时不采购，如果处于0--8之间则进行折半采购
        Sale sale = new Sale();
        if (sale.getSaleStatus() == 0) {
            System.out.println("销售情况不好,暂时不采购");
        } else if (sale.getSaleStatus() < 8) {
            int halfNum = carNum / 2;
            System.out.println("销售情况不算理想，进行折半采购，采购汽车数量:" + halfNum);
            // 更新库存
            Stock stock = new Stock();
            stock.increase(halfNum);

        } else {
            System.out.println("采购汽车:" + carNum + "量");
            // 更新库存
            Stock stock = new Stock();
            stock.increase(carNum);
        }
    }

    // 不在采购
    public void refuseBuyBenz() {

        System.out.println("不在采购汽车");
    }
}

/**
 * 库存部门
 * 
 */
public class Stock {

    // 库存中默认100辆奔驰
    public static int DEFAULT_NUM = 100;

    // 库存汽车容量的上限
    public static final int MAX_NUM = 200;

    // 增加库存
    public void increase(int carNum) {

        DEFAULT_NUM += carNum;

        System.out.println("现在库存量：" + DEFAULT_NUM);
    }

    // 减少库存
    public void decrease(int catNum) {

        DEFAULT_NUM -= catNum;

        System.out.println("现在库存剩余量:" + DEFAULT_NUM);
    }

    // 获取库存量
    public int getStockNum() {

        return DEFAULT_NUM;
    }

    // 清理库存
    public void clearStock() {

        // 通知销售
        Sale sale = new Sale();

        sale.offSale();

        // 通知采购
        Purchase purchase = new Purchase();

        purchase.refuseBuyBenz();
    }
}

public class Client {

    public static void main(String[] args) {

        // 采购人员采购汽车
        System.out.println("-----采购汽车------");
        Purchase purchase = new Purchase();
        purchase.buyBenz(20);

        // 销售人员销售汽车
        System.out.println("-----销售汽车------");
        Sale sale = new Sale();
        sale.sellBenz(50);

        // 清理库存
        System.out.println("-----清理库存-------");
        Stock stock = new Stock();
        stock.clearStock();
    }

}

相信大家已经看出这段程序的问题，那就是销售、采购、库存之间耦合太紧了，稍微有一个程序需要修改，那么可能就会导致一片程序的修改，下面看看引入中介者模式之后的效果：

/**
 * 抽象中介者
 * 
 */
public abstract class AbstractMediator {

    protected Sale sale;

    protected Purchase purchase;

    protected Stock stock;

    public AbstractMediator() {

        sale = new Sale(this);
        purchase = new Purchase(this);
        stock = new Stock(this);
    }

    protected abstract void exec(String str, Integer... num);
}

/**
 * 
 * 具体中介者
 */
public class Mediator extends AbstractMediator {
    

    /**
     * @param str
     * @param num
     */
    @Override
    protected void exec(String str, Integer... num) {

        if ("buy".equals(str)) {
            this.buyBenz(num[0]);
        }

        if ("sell".equals(str)) {

            this.sellBenz(num[0]);
        }

        if ("offSale".equals(str)) {

            this.offSale();
        }

        if ("clear".equals(str)) {

            this.clearStock();
        }
    }

    // 清理库存
    public void clearStock() {

        // 通知销售
        super.sale.offSale();

        // 通知采购
        super.purchase.refuseBuyBenz();
    }

    // 打折销售
    private void offSale() {

        // 访问库存

        System.out.println("打折处理汽车数量:" + super.stock.getStockNum());
    }

    // 采购奔驰汽车
    private void buyBenz(int carNum) {

        // 询问销售部门汽车的销售情况，如果销售状态>8则进行采购，如果是0就暂时不采购，如果处于0--8之间则进行折半采购

        if (super.sale.getSaleStatus() == 0) {
            System.out.println("销售情况不好,暂时不采购");
        } else if (super.sale.getSaleStatus() < 8) {
            int halfNum = carNum / 2;
            System.out.println("销售情况不算理想，进行折半采购，采购汽车数量:" + halfNum);
            // 更新库存
            super.stock.increase(halfNum);

        } else {
            System.out.println("采购汽车:" + carNum + "量");
            // 更新库存
            super.stock.increase(carNum);
        }
    }

    // 销售奔驰汽车
    private void sellBenz(int carNum) {

        // 访问库存
        // 判断购买量和库存量
        if (super.stock.getStockNum() < carNum) {
            // 库存不够，通知采购部门进行采购

            super.purchase.buyBenz(carNum);
        }
        System.out.println("销售汽车：" + carNum + "辆");
        // 更新库存
        super.stock.decrease(carNum);
    }

}

/**
 * 抽象同事类
 * 
 */
public abstract class AbstractColleague {

    protected AbstractMediator mediator;

    public AbstractColleague(AbstractMediator mediator) {

        this.mediator = mediator;
    }
}

/**
 * 销售部门
 * 
 */
public class Sale extends AbstractColleague {

    /**
     * @param mediator
     */
    public Sale(AbstractMediator mediator) {
        super(mediator);
    }

    // 销售奔驰汽车
    public void sellBenz(int carNum) {

        super.mediator.exec("sell", 50);
    }

    // 打折销售
    public void offSale() {

        super.mediator.exec("offSale");
    }

    // 获取销售状态，用数字0-10来表示，0没有销售，10代表非常畅销
    public int getSaleStatus() {

        Random random = new Random(System.currentTimeMillis());

        int saleStatus = random.nextInt(10);

        System.out.println("汽车的销售情况：" + saleStatus);

        return saleStatus;
    }
}

/**
 * 库存部门
 * 
 */
public class Stock extends AbstractColleague {

    /**
     * @param mediator
     */
    public Stock(AbstractMediator mediator) {
        super(mediator);
        // TODO Auto-generated constructor stub
    }

    // 库存中默认100辆奔驰
    public static int DEFAULT_NUM = 100;

    // 库存汽车容量的上限
    public static final int MAX_NUM = 200;

    // 增加库存
    public void increase(int carNum) {

        DEFAULT_NUM += carNum;

        System.out.println("现在库存量：" + DEFAULT_NUM);
    }

    // 减少库存
    public void decrease(int catNum) {

        DEFAULT_NUM -= catNum;

        System.out.println("现在库存剩余量:" + DEFAULT_NUM);
    }

    // 获取库存量
    public int getStockNum() {

        return DEFAULT_NUM;
    }

    // 清理库存
    public void clearStock() {

        super.mediator.exec("clear", DEFAULT_NUM);
    }
}

/**
 * 采购部门
 * 
 */
public class Purchase extends AbstractColleague {

    /**
     * @param mediator
     */
    public Purchase(AbstractMediator mediator) {
        super(mediator);
    }

    // 采购奔驰汽车
    public void buyBenz(int carNum) {

        super.mediator.exec("buy", 20);
    }

    // 不在采购
    public void refuseBuyBenz() {

        System.out.println("不在采购汽车");
    }
}

public class Client {

    public static void main(String[] args) {

        // 创建一个中介者
        AbstractMediator mediator = new Mediator();
        // 采购人员采购汽车
        System.out.println("-----采购汽车------");
        Purchase purchase = new Purchase(mediator);
        purchase.buyBenz(20);

        // 销售人员销售汽车
        System.out.println("-----销售汽车------");
        Sale sale = new Sale(mediator);
        sale.sellBenz(50);

        // 清理库存
        System.out.println("-----清理库存-------");
        Stock stock = new Stock(mediator);
        stock.clearStock();
    }

}

中介者模式简单，但是简单并不代表容易使用，而且有时候很容易被误用，大家可以尝试在如下情况使用中介者模式：

1.多个对象之间产生了相互依赖的关系

2.多个对象之间有依赖关系，但是依赖行为尚不确定或者有发生改变的可能