java设计模式-中介者模式

待我称王封你为后i 2022-05-27 01:15 177阅读 0赞

文章转自：[汤高的Java设计模式（二十二）—-调停者模式][Java_-]

参考链接：  
[Java设计模式系列之中介者模式][Java]  
[java设计模式之中介者模式][java]

> 中介者模式用一个中介对象来封装一系列的对象交互。中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。

**为什么需要调停者**  
如下图所示，这个示意图中有大量的对象，这些对象既会影响别的对象，又会被别的对象所影响，因此常常叫做同事(Colleague)对象。这些同事对象通 过彼此的相互作用形成系统的行为。从图中可以看出，几乎每一个对象都需要与其他的对象发生相互作用，而这种相互作用表现为一个对象与另一个对象的直接耦 合。这就是过度耦合的系统。  
![这里写图片描述][70]

通过引入调停者对象(Mediator)，可以将系统的网状结构变成以中介者为中心的星形结构，如下图所示。在这个星形结构中，同事对象不再通过直接的联 系与另一个对象发生相互作用；相反的，它通过调停者对象与另一个对象发生相互作用。调停者对象的存在保证了对象结构上的稳定，也就是说，系统的结构不会因 为新对象的引入造成大量的修改工作。  
![这里写图片描述][70 1]

类图：  
![这里写图片描述][70 2]

**调停者模式包括以下角色**

**抽象调停者(Mediator)角色：**  
定义出同事对象到调停者对象的接口，其中主要方法是一个（或多个）事件方法。  
**具体调停者(ConcreteMediator)角色：**  
实现了抽象调停者所声明的事件方法。具体调停者知晓所有的具体同事类，并负责具体的协调各同事对象的交互关系。  
**抽象同事类(Colleague)角色：**  
定义出调停者到同事对象的接口。同事对象只知道调停者而不知道其余的同事对象。  
**具体同事类(ConcreteColleague)角色：**  
所有的具体同事类均从抽象同事类继承而来。实现自己的业务，在需要与其他同事通信的时候，就与持有的调停者通信，调停者会负责与其他的同事交互。

**案例：**  
Mediator定义一个抽象的中介者，中介者来维持对象的引用。

package com.madman.base.designMode.Mediator;
    
    /** * 定义抽象中介者 定义对象之间的依赖关系 * 比如说方法AaffectB表示A改动了会影响B， * 方法BaffectA类似 * 最常见比如说对象A的值原来类型是String 后来改成了int * 而对象B的值又来源于A，你想A对象的类型都变了，B对象直接取值还能用嘛， * 肯定是不能的，必须由中介者转换一下 */
    public abstract class Mediator{ 
        public Colleague A;
        public Colleague B;
    
        public Mediator(Colleague a, Colleague b) {
            A = a;
            B = b;
        }
    
        public abstract void AaffectB();
    
        public abstract void BaffectA();
    
    }

ConcreteMediator 具体的中介者，是做事情的人，调停类之间关联关系的人。

package com.madman.base.designMode.Mediator;
    
    /*** * * 定义具体的中介者，用来执行被影响到事情 * 类中的放AaffectB和BaffectA的具体实现，就是调停类之间的影响。 * */
    
    public class ConcreteMediator extends Mediator{ 
        public ConcreteMediator(Colleague a, Colleague b) {
            super(a, b);
        }
    
        // 处理A对B的影响
        @Override
        public void AaffectB() {
            int number = A.getNumber();
            B.setNumber(number * 100);
        }
    
        // 处理B对A的影响
        @Override
        public void BaffectA() {
            int number = B.getNumber();
            A.setNumber(number / 100);
        }
    
    }

Colleague定义具体的对象，也就是同事

package com.madman.base.designMode.Mediator;
    
    
    /** * 定义对象类，我们这里叫做同事 * 这里的变量定义了的目的是为了统一标准，因为我们把同事丢进 * 中介者的时候，往往是非显示调用。个性化定制在思考.. * */
    public abstract class Colleague{ 
        protected int number;
    
        public int getNumber() {
            return number;
        }
    
        public void setNumber(int number) {
            this.number = number;
        }
    
        // 注意这里的参数不再是同事类，而是一个中介者
        public abstract void setNumber(int number, Mediator am);
    }

ConcreteColleagueA 定义具体的同事A

package com.madman.base.designMode.Mediator;
    
    /** * * 定义具体的同事 */
    public class ConcreteColleagueA extends Colleague{ 
        @Override
        public void setNumber(int number, Mediator am) {
            this.number = number;
            am.AaffectB();
        }
    }

ConcreteColleagueB定义具体的同事B

package com.madman.base.designMode.Mediator;
    
    /** * * 定义具体的同事B */
    public class ConcreteColleagueB extends Colleague{ 
        @Override
        public void setNumber(int number, Mediator am) {
            this.number = number;
            am.BaffectA();
        }
    }

客户端

package com.madman.base.designMode.Mediator;
    
    public class Client{
        public static void main(String[] args) {
            Colleague collA = new ConcreteColleagueA();
            Colleague collB = new ConcreteColleagueB();
    
            Mediator am = new ConcreteMediator(collA, collB);
    
            System.out.println("==========通过设置A影响B==========");
            collA.setNumber(1000, am);
            System.out.println("collA的number值为：" + collA.getNumber());
            System.out.println("collB的number值为A的10倍：" + collB.getNumber());
    
            System.out.println("==========通过设置B影响A==========");
            collB.setNumber(1000, am);
            System.out.println("collB的number值为：" + collB.getNumber());
            System.out.println("collA的number值为B的0.1倍：" + collA.getNumber());
        }
    }

结果：

==========通过设置A影响B========== collA的number值为：1000
    collB的number值为A的10倍：100000
    ==========通过设置B影响A========== collB的number值为：1000
    collA的number值为B的0.1倍：10

#### 调停者模式的优点 ####

**松散耦合**   
　　调停者模式通过把多个同事对象之间的交互封装到调停者对象里面，从而使得同事对象之间松散耦合，基本上可以做到互补依赖。这样一来，同事对象就可以独立地变化和复用，而不再像以前那样“牵一处而动全身”了。  
**集中控制交互**   
　　多个同事对象的交互，被封装在调停者对象里面集中管理，使得这些交互行为发生变化的时候，只需要修改调停者对象就可以了，当然如果是已经做好的系统，那么就扩展调停者对象，而各个同事类不需要做修改。  
**多对多变成一对多**   
　　没有使用调停者模式的时候，同事对象之间的关系通常是多对多的，引入调停者对象以后，调停者对象和同事对象的关系通常变成双向的一对多，这会让对象的关系更容易理解和实现。

#### 调停者模式的缺点 ####

调停者模式的一个潜在缺点是，过度集中化。如果同事对象的交互非常多，而且比较复杂，当这些复杂性全部集中到调停者的时候，会导致调停者对象变得十分复杂，而且难于管理和维护。

[Java_-]: https://blog.csdn.net/tanggao1314/article/details/50658655
[Java]: https://www.cnblogs.com/ysw-go/p/5413958.html
[java]: https://www.cnblogs.com/liaoweipeng/p/5791068.html
[70]: /images/20220527/4211de3718cd44c6a4c4937fbdf2af85.png
[70 1]: /images/20220527/da7cad96406d49aeb2f65fe0cf89e294.png
[70 2]: /images/20220527/6135fc4be24c45c1819bc440742f3205.png