通俗易懂设计模式（中介者模式）

请叫我leek2024-03-13 11:16

中介者模式（Mediator Pattern）是一种行为型设计模式，它定义了一个中介者对象，该对象封装了一组对象之间的交互。中介者模式的主要目的是降低对象之间的耦合，使得对象之间的交互更加独立。中介者模式具有以下特点：

  1. 降低对象之间的耦合，使得对象之间的交互更加独立。
  2. 将对象之间的交互行为从对象中分离出来，封装在中介者对象中。
  3. 可以将中介者对象替换为其他中介者对象，从而改变对象之间的交互行为。

中介者模式的主要角色有：

  1. 中介者（Mediator）：定义了一个接口，用于封装一组对象之间的交互。
  2. 具体中介者（Concrete Mediator）：实现中介者接口，封装了一组对象之间的交互行为。
  3. 对象（Colleague）：定义了一个接口，用于与中介者进行通信。
  4. 具体对象（Concrete Colleague）：实现对象接口，与具体中介者进行通信。

中介者模式的优点：

  1. 降低了对象之间的耦合，使得对象之间的交互更加独立。
  2. 将对象之间的交互行为从对象中分离出来，封装在中介者对象中，使得对象更加简单。
  3. 可以将中介者对象替换为其他中介者对象，从而改变对象之间的交互行为。

中介者模式的缺点：

  1. 中介者对象可能会变得过于复杂，尤其是当对象之间的交互行为很多时。
  2. 需要为每个对象定义一个具体的中介者类，增加了代码的复杂性。

下面是一个使用 Java 实现的中介者模式的例子：

java 复制代码 
// 中介者接口
interface Mediator {
    void send(String message, Colleague colleague);
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private ColleagueA colleagueA;
    private ColleagueB colleagueB;

    public void setColleagueA(ColleagueA colleagueA) {
        this.colleagueA = colleagueA;
    }

    public void setColleagueB(ColleagueB colleagueB) {
        this.colleagueB = colleagueB;
    }

    @Override
    public void send(String message, Colleague colleague) {
        if (colleague == colleagueA) {
            colleagueB.receive(message);
        } else {
            colleagueA.receive(message);
        }
    }
}

// 对象接口
interface Colleague {
    void send(String message);
    void receive(String message);
}

// 具体对象 A
class ColleagueA implements Colleague {
    private Mediator mediator;

    public ColleagueA(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void send(String message) {
        mediator.send(message, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("Colleague A received message: " + message);
    }
}

// 具体对象 B
class ColleagueB implements Colleague {
    private Mediator mediator;

    public ColleagueB(Mediator mediator) {
        this.mediator = mediator;
    }

    @Override
    public void send(String message) {
        mediator.send(message, this);
    }

    @Override
    public void receive(String message) {
        System.out.println("Colleague B received message: " + message);
    }
}

// 客户端
public class Client {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();

        ColleagueA colleagueA = new ColleagueA(mediator);
        ColleagueB colleagueB = new ColleagueB(mediator);

        mediator.setColleagueA(colleagueA);
        mediator.setColleagueB(colleagueB);

        colleagueA.send("Hello, Colleague B!");
        colleagueB.send("Hello, Colleague A!");
    }
}

在这个例子中，我们定义了一个 ConcreteMediator 类，它实现了 Mediator 接口，并封装了 ColleagueA 和 ColleagueB 之间的交互行为。ColleagueA 和 ColleagueB 类实现了 Colleague 接口，并与具体中介者进行通信。客户端可以通过调用 send() 方法发送消息，中介者会将消息转发给另一个对象。

场景举例

场景一：多人聊天室

在多人聊天室中，有多个用户参与聊天，他们可以向聊天室发送消息，也可以接收其他用户发送的消息。为了实现这个场景，我们可以使用中介者模式。

首先，我们定义一个 ChatRoom 类作为中介者，它负责接收和转发用户的聊天记录。然后，我们定义一个 User 类，它负责与 ChatRoom 类交互，发送和接收消息。

java 复制代码 
public class ChatRoom {
    public void showMessage(String user, String message) {
        System.out.println(user + ": " + message);
    }
}

public class User {
    private String name;
    private ChatRoom chatRoom;

    public User(String name, ChatRoom chatRoom) {
        this.name = name;
        this.chatRoom = chatRoom;
    }

    public void sendMessage(String message) {
        chatRoom.showMessage(name, message);
    }
}

接下来，我们创建一个 ChatRoom 对象和多个 User 对象，并将它们关联起来：

java 复制代码 
public class ChatRoomDemo {
    public static void main(String[] args) {
        ChatRoom chatRoom = new ChatRoom();
        User user1 = new User("User1", chatRoom);
        User user2 = new User("User2", chatRoom);
        User user3 = new User("User3", chatRoom);

        user1.sendMessage("Hello, everyone!");
        user2.sendMessage("Hi, what's up?");
        user3.sendMessage("Hey, I have a question...");
    }
}

在这个例子中，用户之间不直接通信，而是通过 ChatRoom 类进行通信。这样，我们可以轻松地添加新的用户或删除现有的用户，而不必修改大量的代码。此外，如果需要修改聊天室的行为，我们只需要修改 ChatRoom 类即可，而不必修改每个用户的代码。

场景二：组件之间的交互

在图形用户界面（GUI）应用程序中，有许多组件（如按钮、文本框、标签等）需要相互交互。为了实现这些组件之间的交互，我们可以使用中介者模式。

以计算器为例，我们有一个 Calculator 类，它包含多个按钮（如数字按钮、运算符按钮和功能按钮），以及一个文本框，用于显示计算结果。当用户点击按钮时，我们需要更新文本框中的内容。

首先，我们定义一个 CalculatorMediator 类作为中介者，它负责协调按钮和文本框之间的交互。然后，我们定义一个 Button 类和一个 TextBox 类，它们分别表示按钮和文本框。

java 复制代码 
public class CalculatorMediator {
    private Button[] buttons;
    private TextBox textBox;

    public CalculatorMediator(Button[] buttons, TextBox textBox) {
        this.buttons = buttons;
        this.textBox = textBox;

        for (Button button : buttons) {
            button.setMediator(this);
        }
    }

    public void buttonClicked(Button button) {
        String text = button.getText();
        if (textBox.getText().isEmpty()) {
            textBox.setText(text);
        } else {
            textBox.setText(textBox.getText() + text);
        }
    }
}

public abstract class Component {
    protected CalculatorMediator mediator;

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

public class Button extends Component {
    private String text;

    public Button(String text) {
        this.text = text;
    }

    public String getText() {
        return text;
    }

    // 模拟按钮被点击的事件
    public void click() {
        mediator.buttonClicked(this);
    }
}

public class TextBox extends Component {
    private String text;

    public String getText() {
        return text;
    }

    public void setText(String text) {
        this.text = text;
    }
}

接下来，我们创建一个 Calculator 类，它包含一个 CalculatorMediator 对象、一个 Button 数组和一个 TextBox 对象：

java 复制代码 
public class Calculator {
    public static void main(String[] args) {
        Button[] buttons = new Button[]{
                new Button("1"), new Button("2"), new Button("3"),
                new Button("+"), new Button("-"), new Button("*"),
                new Button("/"), new Button("="), new Button("C")
        };
        TextBox textBox = new TextBox();
        CalculatorMediator mediator = new CalculatorMediator(buttons, textBox);

        // 模拟用户点击按钮
        buttons[0].click();
        buttons[1].click();
        buttons[2].click();
        buttons[3].click();
        buttons[4].click();
        buttons[5].click();
        buttons[8].click();
    }
}

在这个例子中，按钮和文本框之间不直接通信，而是通过 CalculatorMediator 类进行通信。这样，我们可以轻松地添加新的组件或删除现有的组件，而不必修改大量的代码。此外，如果需要修改计算器的行为，我们只需要修改 CalculatorMediator 类即可，而不必修改每个组件的代码。

相关推荐
theLuckyLong几秒前
SpringBoot后端解决跨域问题
spring boot·后端·python
.生产的驴2 分钟前
SpringCloud Gateway网关路由配置 接口统一 登录验证 权限校验 路由属性
java·spring boot·后端·spring·spring cloud·gateway·rabbitmq
小扳6 分钟前
Docker 篇-Docker 详细安装、了解和使用 Docker 核心功能（数据卷、自定义镜像 Dockerfile、网络）
运维·spring boot·后端·mysql·spring cloud·docker·容器
v'sir16 分钟前
POI word转pdf乱码问题处理
java·spring boot·后端·pdf·word
李少兄20 分钟前
解决Spring Boot整合Redis时的连接问题
spring boot·redis·后端
提高记忆力24 分钟前
SpringBoot整合FreeMarker生成word表格文件
java·spring
JDS_DIJ25 分钟前
RabbitMQ
java·rabbitmq·java-rabbitmq
XiaoLeisj39 分钟前
【JavaEE初阶 — 多线程】生产消费模型 & 阻塞队列
java·开发语言·java-ee
hxj..1 小时前
【设计模式】外观模式
java·设计模式·外观模式
吾与谁归in1 小时前
【C#设计模式(10)——装饰器模式(Decorator Pattern)】
设计模式·c#·装饰器模式
热门推荐
01玄机平台应急响应—webshell查杀02Ubuntu 20.04使用Livox mid 360 测试 FAST_LIO03【HarmonyOS】HUAWEI DevEco Studio 下载地址汇总04新版微信小程序获取用户手机号05文件或文件夹名称中有空格如何批量去除06组基轨迹建模 GBTM的介绍与实现（Stata 或 R）07【TC3xx芯片】TC3xx芯片电源管理系统PMS详解08优化手机性能，解决卡顿问题：关闭这3个微信开关，释放内存空间09基于YOLOv10深度学习的CT扫描图像肾结石智能检测系统【python源码+Pyqt5界面+数据集+训练代码】深度学习实战、目标检测10【Flutter】基于 GetX 实现 Dio 的生命周期自动化