设计模式（十七）中介者（调停者）模式

1、概述

中介者模式是一种行为设计模式， 能让你减少对象之间混乱无序的依赖关系。 该模式会限制对象之间的直接交互， 迫使它们通过一个中介者对象进行合作。

2、适用场景

1）当一些对象和其他对象紧密耦合以致难以对其进行修改时， 可使用中介者模式。
2）当组件因过于依赖其他组件而无法在不同应用中复用时， 可使用中介者模式。
3）如果为了能在不同情景下复用一些基本行为， 导致你需要被迫创建大量组件子类时， 可使用中介者模式。

3、实例

有以下场景：

有一个商城系统，内部又很多个功能：
订单功能，支付功能，商品功能，购物车功能，库存功能。

假设功能依赖关系如下。
订单需要关联支付、商品、库存。
支付需要关联订单、商品。
商品需要关联库存。
购物车需要关联商品、订单、库存。

使用中介者优化。

创建商品抽象接口：

/**
 * shop抽象接口
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public interface IShop {
}

创建商城的五个组件：

/**
 * 商品
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class Goods implements IShop {

    public void getGoods() {
        System.out.println("查询商品信息");
    }
}

/**
 * 支付
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class Pay implements IShop {

    public void pay() {
        System.out.println("支付成功");
    }
}

/**
 * 库存
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class Inventory implements IShop {

    public void getInventory() {
        System.out.println("查询库存信息成功");
    }
}

/**
 * 订单
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class Order implements IShop {

    public void order(){
        System.out.println("下单成功");
    }

}

/**
 * 购物车
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class ShoppingCar implements IShop {

    public void addShoppingCar() {
        System.out.println("添加购物城成功");
    }
}

中介者抽象接口：

/**
 * 中介者
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public interface Mediator {

    /**
     * 下单
     */
    void order();

    /**
     * 查询商品
     */
    void getGoods();

    /**
     * 查询库存
     */
    void getInventory();

    /**
     * 支付
     */
    void pay();

    /**
     * 添加购物车
     */
    void addShoppingCar();
}

具体的中介者类：

/**
 * 具体商品中介者
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class ShopMediator implements Mediator {

    private Order order;
    private Goods goods;
    private Inventory inventory;
    private Pay pay;
    private ShoppingCar shoppingCar;


    @Override
    public void order() {
        order.order();
    }

    @Override
    public void getGoods() {
        goods.getGoods();
    }

    @Override
    public void getInventory() {
        inventory.getInventory();
    }

    @Override
    public void pay() {
        pay.pay();
    }

    @Override
    public void addShoppingCar() {
        shoppingCar.addShoppingCar();
    }

    public void register(IShop shop){
        if (shop.getClass().getName() == Order.class.getName()){
            order = new Order();
        }
        if (shop.getClass().getName() == Pay.class.getName()){
            pay = new Pay();
        }
        if (shop.getClass().getName() == Goods.class.getName()){
            goods = new Goods();
        }
        if (shop.getClass().getName() == Inventory.class.getName()){
            inventory = new Inventory();
        }
        if (shop.getClass().getName() == ShoppingCar.class.getName()){
            shoppingCar = new ShoppingCar();
        }
    }
}

测试类：

/**
 * 测试类
 * @date: 2021/1/13
 * @author weirx
 * @version 3.0
 */
public class TestDemo {

    public static void main(String[] args) {
        //创建一个商城中介者
        ShopMediator shopMediator  = new ShopMediator();
        //注册商城内的元素
        shopMediator.register(new Goods());
        shopMediator.register(new ShoppingCar());
        shopMediator.register(new Order());
        shopMediator.register(new Pay());
        shopMediator.register(new Inventory());
        //调用方法
        shopMediator.getGoods();
        shopMediator.getInventory();
        shopMediator.addShoppingCar();
        shopMediator.order();
        shopMediator.pay();
    }
}

结果：

查询商品信息
查询库存信息成功
添加购物城成功
下单成功
支付成功

4、分析

在没有使用中介者的情况下，各功能的调用情况如下所示：

未使用.png

使用中介者后，如下所示：

中介者.png

中介者的关系图：

image.png

综上能看到，使用中介者模式，确实能使各组件间达到解耦的目的，但是过度的使用会导致中介者过大。

5、总结

优点：
1）单一原则。
2）开闭原则。
3）降低组件间的耦合。
缺点：
过度使用会导致中介者称为上帝对象。