设计模式——中介者模式

作者: 树生1995 | 来源:发表于2018-11-12 23:28 被阅读11次

    定义了一个中介对象来封装一系列对象之间的交互关系。中介者使各个对象之间不需要显式地相互引用,从而使耦合性降低,而且可以独立地改变它们之间的交互行为。

    中介模式.png

    我的日常


    在我的日常工作中,项目经理(老祁)就是一个称职的黑中介。

    销售经理(老王)中标了就屁颠屁颠的跑到老祁面前说:
    '老祁老祁咱们的XX项目中标了。'

    老祁听完之后就咧开大嘴,藏不住的幸福从他的嘴里流出,然后屁颠屁颠的跑到办公室,命令小组研发人员:
    '赶紧的咱们的项目中标了,两周后完成开发任务,麻溜的。'

    两周之后项目如期完成,老祁按耐不住激动的心情,跑到运维(小姜)跟前说:
    '小姜呀,你去把项目部署到客户那里,以后这个项目就靠你运维了,加油哦,我看好你!'。

    最终,这个项目在老祁的运筹帷幄中顺利上线,得到了上级领导的认可,故事就这样圆满结束。

    en interesting!


    中介者模式的目的

    项目经理老祁在这个故事里 集中相关对象之间复杂的沟通和控制方式,最终做到了将 销售、研发、运维 完美的解耦。

    类关系

    • Mediator:抽象中介者,定义一个方法用于接收并处理各同事(Colleague)对象传达过来的消息。
    • Colleague:抽象同事类。
    • ConreteMediator:具体中介者,实现抽象类的方法,他需要知道所有具体同事对象,接收某个具体同事对象传达的消息,并对相关具体同事对象发号施令。
    • ConcreteColleague:具体同事类,每个同事只知道自己的行为,不了解其他同事对象的情况,但是他认识中介者对象。


      关系图.png

    实战

    Alarm(闹钟)、CoffeePot(咖啡壶)、Calendar(日历)、Sprinkler(喷头)是一组相关的对象,在某个对象的事件产生时需要去操作其它对象,形成了下面这种依赖结构:


    原始依赖结构.jpg

    使用中介者模式可以将复杂的依赖结构变成星形结构:


    中介者模式依赖图.jpg
    • 同事类
    public abstract class Colleague {
        public abstract void onEvent(Mediator mediator);
    }
    
    public class Alarm extends Colleague {
    
        @Override
        public void onEvent(Mediator mediator) {
            mediator.doEvent("alarm");
        }
    
        public void doAlarm() {
            System.out.println("doAlarm()");
        }
    }
    
    public class CoffeePot extends Colleague {
        @Override
        public void onEvent(Mediator mediator) {
            mediator.doEvent("coffeePot");
        }
    
        public void doCoffeePot() {
            System.out.println("doCoffeePot()");
        }
    }
    
    public class Calender extends Colleague {
        @Override
        public void onEvent(Mediator mediator) {
            mediator.doEvent("calender");
        }
    
        public void doCalender() {
            System.out.println("doCalender()");
        }
    }
    
    public class Sprinkler extends Colleague {
        @Override
        public void onEvent(Mediator mediator) {
            mediator.doEvent("sprinkler");
        }
    
        public void doSprinkler() {
            System.out.println("doSprinkler()");
        }
    }
    
    • 中介者类
    public abstract class Mediator {
        public abstract void doEvent(String eventType);
    }
    
    public class ConcreteMediator extends Mediator {
        private Alarm alarm;
        private CoffeePot coffeePot;
        private Calender calender;
        private Sprinkler sprinkler;
    
        public ConcreteMediator(Alarm alarm, CoffeePot coffeePot, Calender calender, Sprinkler sprinkler) {
            this.alarm = alarm;
            this.coffeePot = coffeePot;
            this.calender = calender;
            this.sprinkler = sprinkler;
        }
    
        @Override
        public void doEvent(String eventType) {
            switch (eventType) {
                case "alarm":
                    doAlarmEvent();
                    break;
                case "coffeePot":
                    doCoffeePotEvent();
                    break;
                case "calender":
                    doCalenderEvent();
                    break;
                default:
                    doSprinklerEvent();
            }
        }
    
        public void doAlarmEvent() {
            alarm.doAlarm();
            coffeePot.doCoffeePot();
            calender.doCalender();
            sprinkler.doSprinkler();
        }
    
        public void doCoffeePotEvent() {
            // ...
        }
    
        public void doCalenderEvent() {
            // ...
        }
    
        public void doSprinklerEvent() {
            // ...
        }
    }
    
    public class Client {
        public static void main(String[] args) {
            Alarm alarm = new Alarm();
            CoffeePot coffeePot = new CoffeePot();
            Calender calender = new Calender();
            Sprinkler sprinkler = new Sprinkler();
            Mediator mediator = new ConcreteMediator(alarm, coffeePot, calender, sprinkler);
            // 闹钟事件到达,调用中介者就可以操作相关对象
            alarm.onEvent(mediator);
        }
    }
    
    优点
    • 简化了对象之间的关系,将系统的各个对象之间的相互关系进行封装,将各个同事类解耦,使得系统变为松耦合。
    • 提供系统的灵活性,使得各个同事对象独立而易于复用。
    缺点
    • 中介者模式中,中介者角色承担了较多的责任,所以一旦这个中介者对象出现了问题,整个系统将会受到重大的影响。
    • 新增加一个同事类时,不得不去修改抽象中介者类和具体中介者类,此时可以使用观察者模式和状态模式来解决这个问题。
    适用场景
    • 一组定义良好的对象,现在要进行复杂的相互通信。
    • 想通过一个中间类来封装多个类中的行为,而又不想生成太多的子类。



    相关链接:https://www.cnblogs.com/snaildev/p/7686908.html

    相关文章

      网友评论

        本文标题:设计模式——中介者模式

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