设计模式–行为型模式之中介者模式

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

场景介绍：

房产中介

1. 假如没有总经理。下面三个部门：财务部、市场部、研发部。财务部要发工资，让大家核对公司需要跟市场部和研发部都通气；市场部要接个新项目，需要研发部处理技术、需要财务部出资金。市场部跟各个部门打交道。 虽然只有三个部门，但是关系非常乱。

1. 实际上，公司都有总经理。各个部门有什么事情都通报到总经理这里，总经理再通知各个相关部门。

1. 这就是一个典型的“中介者模式”，总经理起到一个中介、协调的作用

实现核心

  如果一个系统中对象之间的联系呈现为网状结构，对象之间存在大量多对多关系，将导致关系及其复杂，这些对象称为”同事对象”，我们可以引入一个中介者对象，使各个同事对象只跟中介者对象打交道，将复杂的网络结构化解为星型结构。

模式动机

• 在用户与用户直接聊天的设计方案中，用户对象之间存在很强的关联性，将导致系统出现如下问题：
• 系统结构复杂：对象之间存在大量的相互关联和调用，若有一个对象发生变化，则需要跟踪和该对象关联的其他所有对象，并进行适当处理。
• 对象可重用性差：由于一个对象和其他对象具有很强的关联，若没有其他对象的支持，一个对象很难被另一个系统或模块重用，这些对象表现出来更像一个不可分割的整体，职责较为混乱。
• 系统扩展性低：增加一个新的对象需要在原有相关对象上增加引用，增加新的引用关系也需要调整原有对象，系统耦合度很高，对象操作很不灵活，扩展性差。
• 在面向对象的软件设计与开发过程中，根据“单一职责原则”，我们应该尽量将对象细化，使其只负责或呈现单一的职责。
• 对于一个模块，可能由很多对象构成，而且这些对象之间可能存在相互的引用，为了减少对象两两之间复杂的引用关系，使之成为一个松耦合的系统，我们需要使用中介者模式，这就是中介者模式的模式动机。

模式定义

中介者模式(Mediator Pattern)定义：用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。

模式结构

中介者模式包含如下角色：

• Mediator: 抽象中介者 定义一个接口，该接口用于与各同事对象之间的通信；
• ConcreteMediator: 具体中介者 是抽象中介者的子类，通过协调各个同事对象来实现协作行为，了解并维护它的各个同事对象的引用；
• Colleague: 抽象同事类 定义各同事的公有方法；
• ConcreteColleague: 具体同事类 是抽象同事类的子类，每一个同事对象都引用一个中介者对象；

每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中定义的方法。

时序图

代码分析

抽象中介者

/**
 * 中介者接口
 *
 * @author Devil
 * @since 2022-09-03-11:51
 *
 */
public interface Mediator {
    /**
     * 注册 同事
     * @param dname
     * @param d
     */
    void register(String dname, Department d);

    /**
     * 执行 处理
     * @param name
     */
    void command(String dname);
}

具体中介者

/**
 * 中介者的实现类
 * @author Devil
 * @since 2022-09-03-11:53
 */
public class President implements Mediator {
    private Map<String, Department> map = new HashMap<String,Department>();

    @Override
    public void register(String dname, Department d) {
        map.put(dname,d);
    }

    @Override
    public void command(String dname) {
        map.get(dname).selfAction();
    }
}

抽象同事类

/**
 * 同事类的接口
 * @author Devil
 * @since 2022-09-03-11:55
 */
public interface Department {
    void selfAction(); //做本部门的事情

    void outAction(); //向总经理发出申请
}

具体同事类

/**
 * 财务部
 * @author Devil
 * @since 2022-09-03-12:00
 */
public class Financial implements Department {

    private Mediator mediator;

    public Financial(Mediator mediator) {
        super();
        this.mediator = mediator;
        //注册到中介者的管理列表中
        mediator.register("financial",this);
    }

    @Override
    public void selfAction() {
        System.out.println("提供资金支持！");
    }

    @Override
    public void outAction() {
        System.out.println("数钱");
    }
}


/**
 * 开发部
 * @author Devil
 * @since 2022-09-03-12:01
 */
public class Development implements Department {

    private Mediator mediator;

    public Development(Mediator mediator) {
        super();
        this.mediator = mediator;
        mediator.register("development",this);
    }

    @Override
    public void selfAction() {
        System.out.println("汇报工作！没钱了，需要资金支持！");
        //中介者做协同处理 并不用我们单独去调用指定对象完成操作 而是借助了中介者
        mediator.command("financial");
    }

    @Override
    public void outAction() {
        System.out.println("专心科研，开发项目！");
    }
}

/**
 * 市场部 同事类的具体实现
 * @author Devil
 * @since 2022-09-03-11:57
 */
public class Market implements Department {

    private Mediator mediator;

    public Market(Mediator mediator) {
        super();
        this.mediator = mediator;
        mediator.register("market",this);
    }

    @Override
    public void selfAction() {
        System.out.println("汇报工作！项目承接的进度，需要资金支持！");
		//中介者做协同处理 并不用我们单独去调用指定对象完成操作 而是借助了中介者
        mediator.command("financial");
    }

    @Override
    public void outAction() {
        System.out.println("跑去接项目！");
    }
}

客户端

/**
 * 客户端
 * @author Devil
 * @since 2022-09-03-12:02
 */
public class Client {
    public static void main(String[] args) {
        //获取中介者对象
        Mediator m = new President();
        //获取同事对象，实例化的时候会在中介者对象中注册
        Market market = new Market(m);
        Development development = new Development(m);
        Financial financial = new Financial(m);

        market.selfAction();
        market.outAction();

    }
}

通过中介者的加入，将同事类之间的耦合关系松散，当同事之间有调用关系时，并不是通过添加引用直接调用，而是通过中介者完成协调。将这样的调用关系全部交给中介者。

执行结果：

模式分析

中介者模式可以使对象之间的关系数量急剧减少。

中介者承担两方面的职责：

• 中转作用（结构性）：通过中介者提供的中转作用，各个同事对象就不再需要显式引用其他同事，当需要和其他同事进行通信时，通过中介者即可。该中转作用属于中介者在结构上的支持。
• 协调作用（行为性）：中介者可以更进一步的对同事之间的关系进行封装，同事可以一致地和中介者进行交互，而不需要指明中介者需要具体怎么做，中介者根据封装在自身内部的协调逻辑，对同事的请求进行进一步处理，将同事成员之间的关系行为进行分离和封装。该协调作用属于中介者在行为上的支持。

时序图

实例

实例：虚拟聊天室

某论坛系统欲增加一个虚拟聊天室，允许论坛会员通过该聊天室进行信息交流，普通会员(CommonMember)可以给其他会员发送文本信息，钻石会员(DiamondMember)既可以给其他会员发送文本信息，还可以发送图片信息。该聊天室可以对不雅字符进行过滤，如“日”等字符；还可以对发送的图片大小进行控制。用中介者模式设计该虚拟聊天室。

优点

中介者模式的优点

• 简化了对象之间的交互。
• 将各同事解耦。
• 减少子类生成。
• 可以简化各同事类的设计和实现。

缺点

中介者模式的缺点

• 在具体中介者类中包含了同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。

适用环境

在以下情况下可以使用中介者模式：

• 系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解。
• 一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象。
• 想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。可以通过引入中介者类来实现，在中介者中定义对象。
• 交互的公共行为，如果需要改变行为则可以增加新的中介者类。

模式应用

MVC架构中控制器

Controller 作为一种中介者，它负责控制视图对象View和模型对象Model之间的交互。如在Struts中，Action就可以作为JSP页面与业务对象之间的中介者。

模式扩展

中介者模式与迪米特法则

• 在中介者模式中，通过创造出一个中介者对象，将系统中有关的对象所引用的其他对象数目减少到最少，使得一个对象与其同事之间的相互作用被这个对象与中介者对象之间的相互作用所取代。因此，中介者模式就是迪米特法则的一个典型应用。

中介者模式与GUI开发

• 中介者模式可以方便地应用于图形界面(GUI)开发中，在比较复杂的界面中可能存在多个界面组件之间的交互关系。
• 对于这些复杂的交互关系，有时候我们可以引入一个中介者类，将这些交互的组件作为具体的同事类，将它们之间的引用和控制关系交由中介者负责，在一定程度上简化系统的交互，这也是中介者模式的常见应用之一。

总结

• 中介者模式用一个中介对象来封装一系列的对象交互，中介者使各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。中介者模式又称为调停者模式，它是一种对象行为型模式。
• 中介者模式包含四个角色：抽象中介者用于定义一个接口，该接口用于与各同事对象之间的通信；具体中介者是抽象中介者的子类，通过协调各个同事对象来实现协作行为，了解并维护它的各个同事对象的引用；抽象同事类定义各同事的公有方法；具体同事类是抽象同事类的子类，每一个同事对象都引用一个中介者对象；每一个同事对象在需要和其他同事对象通信时，先与中介者通信，通过中介者来间接完成与其他同事类的通信；在具体同事类中实现了在抽象同事类中定义的方法。
• 通过引入中介者对象，可以将系统的网状结构变成以中介者为中心的星形结构，中介者承担了中转作用和协调作用。中介者类是中介者模式的核心，它对整个系统进行控制和协调，简化了对象之间的交互，还可以对对象间的交互进行进一步的控制。
• 中介者模式的主要优点在于简化了对象之间的交互，将各同事解耦，还可以减少子类生成，对于复杂的对象之间的交互，通过引入中介者，可以简化各同事类的设计和实现；中介者模式主要缺点在于具体中介者类中包含了同事之间的交互细节，可能会导致具体中介者类非常复杂，使得系统难以维护。
• 中介者模式适用情况包括：系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解；一个对象由于引用了其他很多对象并且直接和这些对象通信，导致难以复用该对象；想通过一个中间类来封装多个类中的行为，而又不想生成太多的子类。