行为型模式 - 中介者模式

系列文章目录

设计模式 - 设计原则

创建型模式 - 单例模式（一）
创建型模式 - 工厂模式（二）
创建型模式 - 原型模式（三）
创建型模式 - 建造者模式（四）

结构型模式 - 适配器模式（一）
结构型模式 - 桥接模式（二）
结构型模式 - 装饰器模式（三）
结构型模式 - 组合模式（四）
结构型模式 - 外观模式（五）
结构型模式 - 享元模式（六）
结构型模式 - 代理模式（七）

行为型模式 - 模板方法模式（一）
行为型模式 - 命令模式（二）
行为型模式 - 访问者模式（三）
行为型模式 - 迭代器模式（四）
行为型模式 - 观察者模式（五）
行为型模式 - 中介者模式（六）
行为型模式 - 备忘录模式（七）
行为型模式 - 解释器模式（八）
行为型模式 - 状态模式（九）
行为型模式 - 策略模式（十）
行为型模式 - 责任链模式（十一）

---

---

前言

代码地址

---

一、中介者模式

1.1 中介者模式介绍

• 中介者（Mediator）模式：

  • 用一个中介对象来封装一系列对象的交互，中介者使各对象不需要显示的相互引用，减少对象间混乱的依赖关系，从而使其耦合松散，而且可以独立地改变他们之间的交互；
  • 如果在一个系统中对象之间的存在多对多的相互关系，我们可以将对象之间的交互行为从各对象中分离出来，并封装在一个中介对象中，并由该中介对象统一协调；
  • 即对象之间多对多的网状结构变为星型结构；

1.2 中介者模式结构

• 抽象中介者（Mediator）角色:

  • 它是中介者的接口，提供了同事对象的注册与转发同事对象信息的抽象方法；

• 具体中介者（Concrete Mediator）角色：

  • 具体的中介对象，实现抽象方法，它需要知道所有的具体同事类，即以一个集合来管理，并接受某个同事消息，完成响应的任务；

• 抽象同事类（Colleague）角色：

  • 定义同事类的接口，保存中介者对象，提供同事对象的交互的抽象方法，实现所有相互影响的同事类的公共功能；

• 具体同事类（Concrete Colleague）角色：

  • 具体的同事类，会有很多，每个同事只知道自己的行为，而不了解其他同事的行为（方法）他们都依赖中介者对象；

二、实现

例子：

• A飞行员要起飞，通过塔台联系其他飞行员是否可以起飞；

2.1 中介者实现

/**
 * 抽象中介者
 */
public abstract class TowerMediator {

    public  abstract void registerColleague(CaptainColleague colleague);

    public abstract void sendMsg(CaptainColleague colleague, String msg);
}

package com.dozezz.designpattern.mediator;

import java.util.ArrayList;
import java.util.List;

/**
 * 具体中介者
 */
public class ConcreteTowerMediator extends TowerMediator {

    List<CaptainColleague> captainColleagueList = new ArrayList<>();


    @Override
    public void registerColleague(CaptainColleague colleague) {
        if(! captainColleagueList.contains(colleague)){
            colleague.setTowerMediator(this);
            captainColleagueList.add(colleague);
        }
    }

    @Override
    public void sendMsg(CaptainColleague target, String msg) {

        for (CaptainColleague colleague : captainColleagueList) {

            if (colleague != target) {
                colleague.receiveMsg(msg);
            }
        }
    }
}

package com.dozezz.designpattern.mediator;

/**
 * 抽象同事类
 */
public abstract class CaptainColleague {

    TowerMediator towerMediator;

    public void setTowerMediator(TowerMediator towerMediator) {
        this.towerMediator = towerMediator;
    }

    /**
     * 发送消息
     */
    public abstract void sendMsg(String msg);


    /**
     * 接收消息
     */
    public abstract void receiveMsg(String msg);

}

package com.dozezz.designpattern.mediator;

/**
 * 具体同事类
 */
public class ACaptainConcreteColleague extends CaptainColleague {


    @Override
    public void sendMsg( String msg) {
        towerMediator.sendMsg(this, msg);
    }

    @Override
    public void receiveMsg(String msg) {
        System.out.println(String.format("%s 机长收到消息: %s", "A", msg));
    }
}

package com.dozezz.designpattern.mediator;

/**
 * 具体同事类
 */
public class BCaptainConcreteColleague extends CaptainColleague {


    @Override
    public void sendMsg(String msg) {
        towerMediator.sendMsg(this, msg);
    }

    @Override
    public void receiveMsg(String msg) {
        System.out.println(String.format("%s 机长收到消息: %s", "B", msg));
    }
}

package com.dozezz.designpattern.mediator;

/**
 * 具体同事类
 */
public class CCaptainConcreteColleague extends CaptainColleague {


    @Override
    public void sendMsg( String msg) {
        towerMediator.sendMsg(this, msg);
    }

    @Override
    public void receiveMsg(String msg) {
        System.out.println(String.format("%s 机长收到消息: %s", "C", msg));
    }
}

package com.dozezz.designpattern.mediator;

/**
 * 主测试类
 */
public class ClientTest {
    public static void main(String[] args) {
        ConcreteTowerMediator concreteTowerMediator = new ConcreteTowerMediator();

        ACaptainConcreteColleague colleague1 = new ACaptainConcreteColleague();
        BCaptainConcreteColleague colleague2 = new BCaptainConcreteColleague();
        CCaptainConcreteColleague colleague3 = new CCaptainConcreteColleague();

        concreteTowerMediator.registerColleague(colleague1);
        concreteTowerMediator.registerColleague(colleague2);
        concreteTowerMediator.registerColleague(colleague3);

        colleague1.sendMsg("A 跟 您 说： 我是A，我要起飞了。。 ");
        colleague2.sendMsg("B 跟 您 说： 我是B，请不要起飞，我还在跑道上。。");
        colleague3.sendMsg("C 跟 您 说： 我是C，可以起飞。。");
    }
}

三、中介者模式总结

3.1 中介者的应用场景

• 系统中对象存在较为复杂的引用，导致依赖关系和结构混乱而无法复用的情况；
• 想通过一个中间类来封装多个类的行为，但是又不想要太多的子类；

3.2 中介者模式、观察者模式区别

• 观察者模式用于一对多依赖场景中解耦，通过引入Observer 角色，将消息发布者与具体的订阅者进行解耦；

• 中介者是将系统内部多对多的复杂耦合关系，借助于中介者进行解耦，将网状结构简化为星型结构，将多对多转换为一对多；

• 他们都能实现消息发布者与接受者的解耦，消息发布者都不知道具体的消息接收者；

• 两个模式之间是一种类似的关系，在有些场景可替代转换

  • 如果协作关系比较简答，可以实现为一对多的形式，使用观察者模式；
  • 如果协作关系更加复杂，那么就可以使用中介者模式；

3.3 中介者模式、外观模式区别

• 外观模式和中介者模式都是通过中间类来降低系统的耦合度；
• 外观模式是为了子系统提供一个简单一致的接口，客户端透过门面向子系统发送消息，可以认为消息的发送是单方面的；
• 外观模式外部客户端和内部子系统之间
• 中介者模式则是复杂系统内部多个对象之间相互协作，中介者模式是各个内部对象同事之间；

3.4 中介者模式优缺点

• 简化了对象之间的关系，将系统内各个对象之间的交互进行封装，使得各个类之间关系解耦，使得系统成为低耦合系统；
• 中介者模式将各个同事对象进行解耦，增加新的中介者或者同事类都比较方便；
• 由于中介者封装了各个类之间的交互，导致中介者类本身的复杂性上升，中介者类本身维护会变得复杂；

四、参考文献

• http://c.biancheng.net/view/1390.html
• https://www.cnblogs.com/noteless/p/10178477.html
• https://www.bilibili.com/video/BV1G4411c7N4?p=54&spm_id_from=pageDriver