设计模式(十七)中介者(调停者)模式

作者: 我犟不过你 | 来源:发表于2021-01-18 09:27 被阅读0次

    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)降低组件间的耦合。
    缺点:
    过度使用会导致中介者称为上帝对象。

    相关文章

      网友评论

        本文标题:设计模式(十七)中介者(调停者)模式

        本文链接:https://www.haomeiwen.com/subject/kigloktx.html