（15）Java设计模式 - 中介者模式（Mediator Pattern）

朴灿烈づ我的快乐病毒、 2022-05-19 10:21 230阅读 0赞

# 中介者模式 #

中介者模式（Mediator Pattern）是用来降低多个对象和类之间的通信复杂性。这种模式提供了一个中介类，该类通常处理不同类之间的通信，并支持松耦合，使代码易于维护。中介者模式属于行为型模式。

## 介绍 ##

**意图：**用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。  
**主要解决：**对象与对象之间存在大量的关联关系，这样势必会导致系统的结构变得很复杂，同时若一个对象发生改变，我们也需要跟踪与之相关联的对象，同时做出相应的处理。  
**何时使用：**多个类相互耦合，形成了网状结构。  
**如何解决：**将上述网状结构分离为星型结构。  
**关键代码：**对象 Colleague 之间的通信封装到一个类中单独处理。  
**应用实例：** 1、中国加入 WTO 之前是各个国家相互贸易，结构复杂，现在是各个国家通过 WTO 来互相贸易。 2、机场调度系统。 3、MVC 框架，其中C（控制器）就是 M（模型）和 V（视图）的中介者。  
**优点：** 1、降低了类的复杂度，将一对多转化成了一对一。 2、各个类之间的解耦。 3、符合迪米特原则。  
**缺点：**中介者会庞大，变得复杂难以维护。  
**使用场景：** 1、系统中对象之间存在比较复杂的引用关系，导致它们之间的依赖关系结构混乱而且难以复用该对象。 2、想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。  
**注意事项：**不应当在职责混乱的时候使用。

## 结构 ##

![653266-20160420191516413-1747235247.png][]

## 实现 ##

租房子的过程中一般会存在中介这样的角色，来促成租客和房东的交易。

第一步：定义Mediator

//定义抽象Mediator,可以与买家和卖家进行联络
    public abstract class Mediator {
        public abstract void contact(String content,Colleague coll);
    }

第二步：定义抽象交易者Trader

public class Trader {
         protected String name;
         protected Mediator mediator;
     
         public Trader(String name, Mediator mediator) {
             this.name = name;
             this.mediator = mediator;
         }
    }

第三步：定义具体交易者

//租客
    public class TraderA extends Trader {
    
        // 具体同事类继承自Trader,此刻就可以与中介者mediator进行通信了
        public TraderA(String name, Mediator mediator) {
            super(name, mediator);
        }
        public void getMessage(String message){
            System.out.println("租客A"+name+"获得信息"+message);
        }
        //租客A与中介者通信
        public void contact(String message){
            mediator.contact(message, this);
        }
    }
    //房东
    public class TraderB extends Trader {
    
        public TraderB(String name, Mediator mediator) {
            super(name, mediator);
        }
        public void getMessage(String message){
            System.out.println("房东B"+name+"获得信息"+message);
        }
        //房东B与中介者通信
        public void contact(String message){
            mediator.contact(message, this);
        }
    }

第四步：定义具体中介者ConcreteMediator,具体中介者通过协调各同事对象实现协作行为，了解并维护它的各个同事。

//定义具体中介者ConcreteMediator,具体中介者通过协调租客和房东方实现协作行为，了解并维护它的各个交易方。
    public class ConcreteMediator extends Mediator {
        TraderA traderA;
        TraderB traderB;
    
        public void setTraderA(TraderA traderA) {
            this.traderA = traderA;
        }
    
        public void setTraderB(TraderB traderB) {
            this.traderB = traderB;
        }
    
        @Override
        public void contact(String content, Trader trader) {
            if (trader==traderA) {
                traderB.getMessage(content);
            } else {
                traderA.getMessage(content);
            }
        }
    }

第五步：定义Test，测试中介者模式的使用

public class Test {
    
        public static void main(String[] args) {
            // 定义中介者
            ConcreteMediator mediator = new ConcreteMediator();
            // 定义具体交易者
            TraderA traderA = new TraderA("张三", mediator);
            TraderB traderAB = new TraderB("李四", mediator);
            // 中介者知晓每一个具体的交易者
            mediator.setTraderA(traderA);
            mediator.setTraderB(traderB);
            traderA.contact("我是租客，3000太贵了，能便宜500不？");
            traderB.contact("我是房东，底价2800，不能再少了！");
        }
    
    }

运行结果:

房东B李四获得信息:我是租客，3000太贵了，能便宜500不？
    租客A张三获得信息:我是房东，底价2800，不能再少了！

总结：  
中介者就是一个处于众多对象中间，并恰当地处理众多对象之间相互之间的联系的角色。以上代码中只有两个参与者类，但是这些我们都可以根据中介者模式的宗旨进行适当地扩展，即增加参与者类，然后中介者就得担负更加重的任务了，我们看到上面具体中介者类Mediator中的方法比较多而且有点乱。 所以，在解耦参与者类之间的联系的同时，中介者自身也不免任务过重，因为几乎所有的业务逻辑都交代到中介者身上了，可谓是“万众期待”的一个角色了。这就是中介者模式的不足之处了。此外，上面这个代码例子的参与者的属性和方法都是一样的，我们可以抽取一个抽象类出来，减少代码，但是有时候我们根本抽取不了多个“参与者”之间的共性来形成一个抽象类，这也大大增加了中介者模式的使用难度。

[653266-20160420191516413-1747235247.png]: /images/20220519/3788beb6056d491eb767caf4ed7316f6.png