23种设计模式——中介者模式 (Mediator Pattern)详解

✅作者简介：大家好，我是 Meteors., 向往着更加简洁高效的代码写法与编程方式，持续分享Java技术内容。

🍎个人主页：Meteors.的博客
💞当前专栏：设计模式
✨特色专栏：知识分享
🥭本文内容：23种设计模式------中介者模式 (Mediator Pattern)
📚 ** ps ** ：阅读文章如果有问题或者疑惑，欢迎在评论区提问或指出

[一. 介绍](#一. 介绍)

[二. 概念](#二. 概念)

[三. 组成](#三. 组成)

[四. 代码示例](#四. 代码示例)

[五. 特点](#五. 特点)

[1. 优点](#1. 优点)

[2. 缺点](#2. 缺点)

[六. 适用场景](#六. 适用场景)

[七. 优化方案](#七. 优化方案)

[1. 优化方案](#1. 优化方案)

[2. 优化后的实现](#2. 优化后的实现)

[八. 总结](#八. 总结)

一. 介绍

就像这个设计模式的名字一般，中介者模式像是：***就是有一个人在两个人之间的作为中介，两个人不直接交流，两个人都只和中介进行对话，消息的管理和交流的人数由中介者管理。***可能现在你还是有些不解，但没关系，下面的内容将会详细介绍这种设计模式。

二. 概念

中介者模式是一种行为型 设计模式，它通过引入一个中介者对象来封装一系列对象之间的交互。这种模式可以减少对象之间的直接依赖，使它们之间的交互更加松散耦合。

中介者模式的核心思想是"将交互逻辑集中化" 。在复杂的系统中，多个对象之间可能存在复杂的交互关系，如果让这些对象直接相互引用和通信，会导致系统结构混乱、难以维护。中介者模式通过引入一个中介者对象作为协调中心，让所有对象都通过中介者进行通信，从而将网状的依赖关系转化为星型结构。

三. 组成

中介者模式包含以下主要角色：

角色介绍

Mediator（抽象中介者） 定义了同事对象到中介者对象的接口

ConcreteMediator（具体中介者） 实现抽象中介者的方法，协调各同事对象的交互

Colleague（抽象同事类） 定义同事类的接口，保存中介者对象的引用

ConcreteColleague（具体同事类） 实现抽象同事类，每个具体同事类只需要与中介者通信

角色	介绍
Mediator（抽象中介者）	定义了同事对象到中介者对象的接口
ConcreteMediator（具体中介者）	实现抽象中介者的方法，协调各同事对象的交互
Colleague（抽象同事类）	定义同事类的接口，保存中介者对象的引用
ConcreteColleague（具体同事类）	实现抽象同事类，每个具体同事类只需要与中介者通信

四. 代码示例

下面是一个同事间发消息，加入中介者后，实现中介者模式的Java代码示例：

java 复制代码

// 抽象中介者
interface Mediator {
    void register(Colleague colleague);
    void relay(Colleague colleague, String message);
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues = new ArrayList<>();

    @Override
    public void register(Colleague colleague) {
        if (!colleagues.contains(colleague)) {
            colleagues.add(colleague);
            colleague.setMediator(this);
        }
    }

    @Override
    public void relay(Colleague sender, String message) {
        for (Colleague colleague : colleagues) {
            if (colleague != sender) {
                colleague.receive(message);
            }
        }
    }
}

// 抽象同事类
abstract class Colleague {
    protected Mediator mediator;

    public void setMediator(Mediator mediator) {
        this.mediator = mediator;
    }

    public abstract void send(String message);
    public abstract void receive(String message);
}

// 具体同事类A
class ConcreteColleagueA extends Colleague {
    @Override
    public void send(String message) {
        System.out.println("同事A发送消息: " + message);
        mediator.relay(this, message);
    }

    @Override
    public void receive(String message) {
        System.out.println("同事A收到消息: " + message);
    }
}

// 具体同事类B
class ConcreteColleagueB extends Colleague {
    @Override
    public void send(String message) {
        System.out.println("同事B发送消息: " + message);
        mediator.relay(this, message);
    }

    @Override
    public void receive(String message) {
        System.out.println("同事B收到消息: " + message);
    }
}

// 客户端代码
public class Client {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        Colleague colleagueA = new ConcreteColleagueA();
        Colleague colleagueB = new ConcreteColleagueB();
        
        mediator.register(colleagueA);
        mediator.register(colleagueB);
        
        colleagueA.send("你好，我是A");
        colleagueB.send("你好，我是B");
    }
}

五. 特点

1. 优点

降低耦合度： 对象之间不需要直接交互，减少了相互依赖。

简化对象关系： 将复杂的网状结构转化为星型结构，便于理解和维护。

集中控制： 交互逻辑集中在中介者中，便于统一管理和修改。

符合迪米特法则： 对象之间不需要知道彼此的细节，只与中介者交互。

2. 缺点

中介者可能变得复杂： 随着同事对象的增加，中介者可能承担过多的职责 ，成为"上帝对象"。

性能问题： 所有交互都需要通过。中介者，可能成为性能瓶颈。

六. 适用场景

GUI组件交互 ：如对话框中的各种控件通过*对话框(*中介者)进行交互

聊天应用 ：聊天室作为中介者协调用户之间的消息传递

航空管制系统 ：塔台作为中介者协调飞机之间的通信

事件分发系统 ：如Spring的事件机制

微服务架构 ：API网关作为中介者协调服务间的调用

七. 优化方案

1. 优化方案

使用事件机制：将中介者模式与观察者模式结合，实现更松散的耦合
引 责任链：对于复杂的消息路由，可以使用责任链模式来处理
异步处理：对于高并发场景，可以使用消息队列实现异步中介
动态注册：支持同事类的动态注册和注销
类型过滤：根据消息类型进行选择性转发

2. 优化后的实现

java 复制代码

// 增强版中介者接口
interface EnhancedMediator {
    void register(String type, Colleague colleague);
    void unregister(String type, Colleague colleague);
    void relay(Colleague sender, String type, String message);
}

// 增强版具体中介者
class EnhancedConcreteMediator implements EnhancedMediator {
    private Map<String, List<Colleague>> colleagueMap = new HashMap<>();

    @Override
    public void register(String type, Colleague colleague) {
        colleagueMap.computeIfAbsent(type, k -> new ArrayList<>()).add(colleague);
        colleague.setMediator(this);
    }

    @Override
    public void unregister(String type, Colleague colleague) {
        List<Colleague> colleagues = colleagueMap.get(type);
        if (colleagues != null) {
            colleagues.remove(colleague);
        }
    }

    @Override
    public void relay(Colleague sender, String type, String message) {
        List<Colleague> colleagues = colleagueMap.get(type);
        if (colleagues != null) {
            for (Colleague colleague : colleagues) {
                if (colleague != sender) {
                    colleague.receive(message);
                }
            }
        }
    }
}

// 增强版抽象同事类
abstract class EnhancedColleague {
    protected EnhancedMediator mediator;

    public void setMediator(EnhancedMediator mediator) {
        this.mediator = mediator;
    }

    public abstract void send(String type, String message);
    public abstract void receive(String message);
}

// 具体同事类
class ChatUser extends EnhancedColleague {
    private String name;

    public ChatUser(String name) {
        this.name = name;
    }

    @Override
    public void send(String type, String message) {
        System.out.println(name + " 发送[" + type + "]消息: " + message);
        mediator.relay(this, type, name + ": " + message);
    }

    @Override
    public void receive(String message) {
        System.out.println(name + " 收到消息: " + message);
    }
}

// 客户端代码
public class EnhancedClient {
    public static void main(String[] args) {
        EnhancedMediator mediator = new EnhancedConcreteMediator();
        
        EnhancedColleague user1 = new ChatUser("张三");
        EnhancedColleague user2 = new ChatUser("李四");
        EnhancedColleague user3 = new ChatUser("王五");
        
        // 注册到不同的聊天室
        mediator.register("room1", user1);
        mediator.register("room1", user2);
        mediator.register("room2", user2);
        mediator.register("room2", user3);
        
        user1.send("room1", "大家好，我是张三");
        user2.send("room2", "大家好，我是李四");
        
        // 动态注销
        mediator.unregister("room1", user2);
        user1.send("room1", "李四还在吗？");
    }
}

八. 总结

中介者模式通过集中控制对象间的交互，有效地降低了系统的复杂度，是解耦对象间关系的有效手段。中介者模式在GUI组件交互、聊天系统、MVC框架等场景中都有广泛应用，能够有效降低系统复杂度，提高代码的可维护性。

最后，

其它设计模式会陆续更新，希望文章对你有所帮助！