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

请叫我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 类即可，而不必修改每个组件的代码。

相关推荐
未来可期LJ2 小时前
【C++ 设计模式】单例模式的两种懒汉式和饿汉式
c++·单例模式·设计模式
Dola_Pan3 小时前
Linux文件IO（二）-文件操作使用详解
java·linux·服务器
wang_book3 小时前
Gitlab学习(007 gitlab项目操作)
java·运维·git·学习·spring·gitlab
蜗牛^^O^4 小时前
Docker和K8S
java·docker·kubernetes
从心归零4 小时前
sshj使用代理连接服务器
java·服务器·sshj
IT毕设梦工厂5 小时前
计算机毕业设计选题推荐-在线拍卖系统-Java/Python项目实战
java·spring boot·python·django·毕业设计·源码·课程设计
Ylucius6 小时前
动态语言？ 静态语言？ ------区别何在？java，js，c，c++，python分给是静态or动态语言？
java·c语言·javascript·c++·python·学习
凡人的AI工具箱6 小时前
AI教你学Python 第11天 ： 局部变量与全局变量
开发语言·人工智能·后端·python
是店小二呀6 小时前
【C++】C++ STL探索：Priority Queue与仿函数的深入解析
开发语言·c++·后端
七夜zippoe6 小时前
分布式系统实战经验
java·分布式
热门推荐
01软件工程从理论到实践客观题汇总(头歌第一章至第八章)02RAG 实践- Ollama+RagFlow 部署本地知识库032024年高教社杯数学建模国赛C题超详细解题思路分析04【halcon】halcon字符识别——OCR05组基轨迹建模 GBTM的介绍与实现（Stata 或 R）06【2024数模国赛赛题思路公开】国赛B题思路丨附可运行代码丨无偿自提072024年网络安全比赛--系统渗透测试（超详细）08苍穹外卖面试总结09【2024高教社杯全国大学生数学建模竞赛】B题 生产过程中的决策问题——解题思路 代码 论文10分享几个惊艳的 Three.js 个人站点