行为型模式之中介者模式_中介者模式适用于-CSDN博客

本文链接：https://blog.csdn.net/weixin_45240169/article/details/105483856

文章目录

在现实生活中，常常会出现好多对象之间存在复杂的交互关系，这种交互关系常常是“网状结构”，它要求每个对象都必须知道它需要交互的对象。例如，每个人必须记住他（她）所有朋友的电话；而且，朋友中如果有人的电话修改了，他（她）必须告诉其他所有的朋友修改，这叫作“牵一发而动全身”，非常复杂。

如果把这种“网状结构”改为“星形结构”的话，将大大降低它们之间的“耦合性”，这时只要找一个“中介者”就可以了。如前面所说的“每个人必须记住所有朋友电话”的问题，只要在网上建立一个每个朋友都可以访问的“通信录”就解决了。这样的例子还有很多，例如，你刚刚参加工作想租房，可以找“房屋中介”；或者，自己刚刚到一个陌生城市找工作，可以找“人才交流中心”帮忙。

在软件的开发过程中，这样的例子也很多，例如，在 MVC 框架中，控制器（C）就是模型（M）和视图（V）的中介者；还有大家常用的 QQ 聊天程序的“中介者”是 QQ 服务器。所有这些，都可以采用“中介者模式”来实现，它将大大降低对象之间的耦合性，提高系统的灵活性。

中介者模式的定义

中介者（Mediator）模式的定义：定义一个中介对象来封装一系列对象之间的交互，使原有对象之间的耦合松散，且可以独立地改变它们之间的交互。中介者模式又叫调停模式，属于行为型模式，它是迪米特法则的典型应用。

中介者模式包装了一系列对象相互作用的方式，使得这些对象不必相互明显作用。从而使他们可以松散耦合。当某些对象之间的作用发生改变时，不会立即影响其他的一些对象之间的作用。保证这些作用可以彼此独立变化的。其核心思想是，通过中介者解耦系统各层次对象的直接耦合，层次对象的对外依赖通信统一交由中介者转发。

中介者模式的结构

中介者模式包含以下主要角色：
抽象中介者（Mediator）角色：定义统一的接口，用于各同事角色之间的通信。
具体中介者（ConcreteMediator）角色：实现中介者接口，定义一个集合来管理同事对象，协调各个同事角色之间的交互关系，因此它依赖于同事角色。
抽象同事类（Colleague）角色：定义同事类的接口，保存中介者对象，提供同事对象交互的抽象方法，实现所有相互影响的同事类的公共功能。
具体同事类（ConcreteColleague）角色：是抽象同事类的实现者，当需要与其他同事对象交互时，由中介者对象负责后续的交互。

中介者模式的实现

// 抽象中介者
public abstract class Mediator {
    public abstract Mediator register(Colleague colleague);//注册
    public abstract void relay(Colleague colleague); //转发
}

// 具体中介者
public class ConcreteMediator extends Mediator {
    private List<Colleague> colleagues=new ArrayList<Colleague>();//保存具体同事类的集合
    public Mediator register(Colleague colleague) {
        if(!colleagues.contains(colleague)){
            colleagues.add(colleague);
        }
        return this;
    }
    public void relay(Colleague colleague) {
        for(Colleague ob:colleagues){
            if(!ob.equals(colleague)){
                ((Colleague)ob).receive();
            }
        }
    }
}

// 抽象同事类
public abstract class Colleague {
    protected Mediator mediator;
    public Colleague(Mediator mediator) {
        this.mediator = mediator;
    }
    public abstract void receive();//接受
    public abstract void send();//转发
}

// 具体同事类A
public class ConcreteColleagueA extends Colleague {
    public ConcreteColleagueA(Mediator mediator) {
        super(mediator);
    }
    public void receive() {
        // 处理自己的逻辑
        System.out.println(String.format("%s:具体同事A收到请求", this.getClass().getSimpleName()));
    }
    public void send() {
        // 处理自己的逻辑
        System.out.println(String.format("%s:具体同事A发出请求", this.getClass().getSimpleName()));
        // 无法处理的业务逻辑委托给中介者处理
        this.mediator.relay(this);
    }
}

// 具体同事类B
public class ConcreteColleagueB extends Colleague {
    public ConcreteColleagueB(Mediator mediator) {
        super(mediator);
    }
    public void receive() {
        // 处理自己的逻辑
        System.out.println(String.format("%s:具体同事B收到请求", this.getClass().getSimpleName()));
    }
    public void send() {
        // 处理自己的逻辑
        System.out.println(String.format("%s:具体同事B发出请求", this.getClass().getSimpleName()));
        // 无法处理的业务逻辑委托给中介者处理
        this.mediator.relay(this);
    }
}

/**
 * 测试类
 */
public class Test {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        ConcreteColleagueA colleagueA = new ConcreteColleagueA(mediator);
        ConcreteColleagueB colleagueB = new ConcreteColleagueB(mediator);
        mediator.register(colleagueA)
                .register(colleagueB);

        colleagueA.send();
        System.out.println("-------------------------");
        colleagueB.send();
    }
}

程序运行结果如下：

ConcreteColleagueA:具体同事A发出请求
ConcreteColleagueB:具体同事B收到请求
-------------------------
ConcreteColleagueB:具体同事B发出请求
ConcreteColleagueA:具体同事A收到请求

中介者模式的应用场景

中介者模式是用来降低多个对象和类之间的通信复杂性。这种模式通过提供一个中介类，将系统各层次对象间的多对多关系变成一对多关系，中介者对象可以将复杂的网状结构变成以调停者为中心的星形结构，达到降低系统的复杂性，提高可扩展性的作用。

若系统各层次对象之间存在大量的关联关系，即层次对象呈复杂的网状结构，如果让它们紧耦合通信，会造成系统结构变得异常复杂，且其中某个层次对象发生改变，则与其紧耦合的相应层次对象也需要进行改变，系统难以维护。而通过为该系统增加一个中介者层次对象，让其他各层次需对外通信的行为统统交由中介者进行转发，系统呈现以中介者为中心进行通信的星形结构，系统复杂性大大降低。

简单点说就是多个类相互耦合，形成了网状结构，则考虑使用中介者模式进行优化。总结中介者模式适用于以下场景：
1.系统中对象之间存在复杂的引用关系，产生的相互依赖关系结构混乱且难以理解；
2.交互的公共行为，如果需要改变行为则可以增加新的中介者类。