设计模式之中介者模式

好久没更新设计模式系列的文章了，最近工作有些变动，无论如何都不能停止学习。在产品中发挥更大的价值。设计模式一直是我非常重视的一块内容，如果说数据结构算法是编程的内功，那设计模式就是架构师的内功。
中介者模式是行为模式的一种，它主要是封装了通信的关心的复杂性，如果很多同事之间都有消息的传递。这个时候如果再增加新的同事，那通信开销会成倍增加。

扩展的困难性导致我们想到可以用一个中介类类维护这种复杂的关系。

类似于网络拓扑图的网状结构和星型结构。这样我们一方面可以降低各个同事类之间的直接依赖关系，降低了耦合，也可以方便的扩展同事类。但是缺点也是中介类太重，万一中介类有什么变动，很容易影响到其他的通信。
关于中介者模式要明确的是几个角色。

中介者：定义能够传递消息的方式。
抽象同事：定义一个拥有中介者的基础。

// 中介者
    static class Mediator {
        // 控制请求
        private void print(AbstractUser sourceUser, AbstractUser targetUser) {
            System.out.println("中介者收到 " + sourceUser.getName() + " 请求");
            // 调用目标对象
            System.out.println(targetUser.getName() + " --- actions : ");
            targetUser.actions();
        }
    }

static abstract class AbstractUser {
        protected String name;
        // 所有用户都能够跟中介者通信
        protected Mediator mediator;
        AbstractUser (Mediator mediator) {
            this.mediator = mediator;
        }
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        // 定义通信
        public void sendHelp(AbstractUser abstractUser) {
            System.out.println(this.getName() + " 发送消息给中介者 : ");
            this.mediator.print(this, abstractUser);
        }
        // 每个User
        public abstract void actions();
    }

static class ASystemUser extends AbstractUser {

        ASystemUser(Mediator mediator) {
            super(mediator);
        }

        @Override
        public void actions() {
            System.out.println("ASystem take actions");
        }
    }

    static class BSystemUser extends AbstractUser {

        BSystemUser(Mediator mediator) {
            super(mediator);
        }

        @Override
        public void actions() {
            System.out.println("BSystem take actions");
        }
    }

测试代码：

        Mediator mediator = new Mediator();
        AbstractUser user1 = new ASystemUser(mediator);
        user1.setName("用户A");
        AbstractUser user2 = new BSystemUser(mediator);
        user2.setName("用户B");
        user1.sendHelp(user2);
        System.out.println("-----------");
        user2.sendHelp(user1);

用户A 发送消息给中介者 : 
中介者收到 用户A 请求
用户B --- actions : 
BSystem take actions
-----------
用户B 发送消息给中介者 : 
中介者收到 用户B 请求
用户A --- actions : 
ASystem take actions

如果我们要添加一个新的关系

static class CSystemUser extends AbstractUser {

        CSystemUser(Mediator mediator) {
            super(mediator);
        }

        @Override
        public void actions() {
            System.out.println("我是新的用户C");
        }

    }

AbstractUser user3 = new CSystemUser(mediator);
        user3.setName("用户3");
        user2.sendHelp(user3);

用户A 发送消息给中介者 : 
中介者收到 用户A 请求
用户B --- actions : 
BSystem take actions
-----------
用户B 发送消息给中介者 : 
中介者收到 用户B 请求
用户A --- actions : 
ASystem take actions
---------
用户B 发送消息给中介者 : 
中介者收到 用户B 请求
用户3 --- actions : 
我是新的用户C

不用修改原有的代码，这样就方便了扩展，优点是降低了耦合。缺点也是中介类过重的责任。应该根据场景使用该模式。这里的UML与我的例子不同的是，UML中Media是抽象类或者接口。可以根据需要去注入具体的中介者实现类，怎样去调用之间的关系完全取决于中介者的具体实现，这里我用一个类代替了接口。