Java中介者模式教程：如何简化对象间的复杂通信-优快云博客

本文链接：https://blog.youkuaiyun.com/weixin_41859354/article/details/141201151

Java中介者模式教程：如何简化对象间的复杂通信

一、引言

在软件开发中，随着系统的复杂性增加，对象间的通信也变得越来越复杂。对象之间的直接交互可能导致系统耦合度过高，难以维护和扩展。中介者模式（Mediator Pattern）是一种行为型设计模式，旨在通过引入一个中介者对象来简化对象间的复杂通信，从而降低系统的耦合度。

本文将深入探讨中介者模式的概念、实现及其在Java中的应用，并通过示例演示如何使用中介者模式来简化对象间的通信。

二、中介者模式概述

2.1 中介者模式定义

中介者模式定义了一个中介者对象，用于封装一系列对象之间的交互。中介者使得对象不需要直接引用彼此，从而使对象间的耦合松散。中介者模式通过将对象间的复杂通信交给中介者对象处理，从而简化了对象间的交互。

2.2 中介者模式的角色

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

中介者接口（Mediator）：定义一个接口，用于协调对象间的通信。
具体中介者（ConcreteMediator）：实现中介者接口，负责具体的协调和通信逻辑。
同事类（Colleague）：依赖于中介者进行通信的对象类。
具体同事类（ConcreteColleague）：实现具体的同事类，利用中介者进行通信。

2.3 中介者模式的结构

中介者模式的结构如下图所示：

+------------------+
|   Mediator       |
|------------------|
| +notify(colleague) |
+------------------+
         |
         v
+---------------------+
| ConcreteMediator    |
|---------------------|
| +colleague1: Colleague  |
| +colleague2: Colleague  |
| +notify(colleague)     |
+---------------------+
         ^
         |
         |
+---------------------+
| ConcreteColleague1  |
|---------------------|
| +mediator: Mediator |
| +send()             |
| +receive()          |
+---------------------+
         ^
         |
+---------------------+
| ConcreteColleague2  |
|---------------------|
| +mediator: Mediator |
| +send()             |
| +receive()          |
+---------------------+

三、中介者模式的实现

3.1 中介者接口

中介者接口定义了协调对象间通信的方法。它通常包含一个 notify 方法，用于通知其他同事对象。

public interface Mediator {
    void notify(Colleague colleague, String message);
}

3.2 具体中介者

具体中介者实现了中介者接口，并负责处理具体的通信逻辑。在这个类中，通常会维护同事对象的引用，并实现协调这些对象的逻辑。

import java.util.HashMap;
import java.util.Map;

public class ConcreteMediator implements Mediator {
    private Map<String, Colleague> colleagues = new HashMap<>();

    public void addColleague(String name, Colleague colleague) {
        colleagues.put(name, colleague);
        colleague.setMediator(this);
    }

    @Override
    public void notify(Colleague colleague, String message) {
        String colleagueName = colleague.getName();
        for (Map.Entry<String, Colleague> entry : colleagues.entrySet()) {
            if (!entry.getKey().equals(colleagueName)) {
                entry.getValue().receive(message);
            }
        }
    }
}

3.3 同事类接口

同事类接口定义了需要通过中介者进行通信的对象类的基本行为，包括设置中介者的接口。

public interface Colleague {
    void setMediator(Mediator mediator);
    void send(String message);
    void receive(String message);
    String getName();
}

3.4 具体同事类

具体同事类实现了同事类接口，并通过中介者对象进行通信。

public class ConcreteColleague1 implements Colleague {
    private Mediator mediator;
    private String name;

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

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

    @Override
    public void send(String message) {
        System.out.println(name + " sends: " + message);
        mediator.notify(this, message);
    }

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

    @Override
    public String getName() {
        return name;
    }
}

public class ConcreteColleague2 implements Colleague {
    private Mediator mediator;
    private String name;

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

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

    @Override
    public void send(String message) {
        System.out.println(name + " sends: " + message);
        mediator.notify(this, message);
    }

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

    @Override
    public String getName() {
        return name;
    }
}

3.5 客户端代码

客户端代码创建具体的中介者和同事对象，并通过中介者进行通信。

public class Client {
    public static void main(String[] args) {
        ConcreteMediator mediator = new ConcreteMediator();
        
        ConcreteColleague1 colleague1 = new ConcreteColleague1("Colleague1");
        ConcreteColleague2 colleague2 = new ConcreteColleague2("Colleague2");
        
        mediator.addColleague("Colleague1", colleague1);
        mediator.addColleague("Colleague2", colleague2);
        
        colleague1.send("Hello from Colleague1");
        colleague2.send("Hello from Colleague2");
    }
}

在这个示例中，ConcreteMediator 处理了 ConcreteColleague1 和 ConcreteColleague2 之间的通信。客户端代码通过中介者发送消息，并且消息会被传递到所有其他同事对象。

四、中介者模式的应用场景

中介者模式适用于以下场景：

系统中存在多个对象且它们之间的通信复杂：当对象之间的直接通信导致系统的复杂性增加时，可以使用中介者模式来简化通信。
需要减少对象间的依赖：中介者模式将对象间的通信逻辑集中在一个中介者对象中，减少了对象间的直接依赖。
需要提高系统的灵活性：通过将通信逻辑集中在中介者中，系统的扩展和维护变得更加容易。

五、中介者模式的优缺点

5.1 优点

减少对象间的依赖：中介者模式将对象间的通信逻辑集中在一个中介者对象中，减少了对象间的直接依赖。
简化对象间的通信：中介者模式将对象间的复杂通信交给中介者处理，使得对象之间的交互更加简洁。
提高系统的灵活性：通过将通信逻辑集中在中介者中，可以更容易地修改和扩展系统的功能。

5.2 缺点

中介者对象可能变得复杂：随着系统的复杂性增加，中介者对象可能会变得非常复杂，负责处理大量的通信逻辑。
难以追踪通信过程：由于所有的通信都通过中介者进行，可能会导致通信过程变得不容易追踪和理解。

六、中介者模式的实际案例

6.1 实际案例：聊天系统

在一个聊天系统中，中介者模式可以用于管理用户之间的消息传递。每个用户通过一个中介者（聊天服务器）来发送和接收消息，而不直接与其他用户进行通信。

public interface ChatMediator {
    void sendMessage(String message, User user);
    void addUser(User user);
}

public class ChatMediatorImpl implements ChatMediator {
    private List<User> users = new ArrayList<>();

    @Override
    public void sendMessage(String message, User user) {
        for (User u : users) {
            if (u != user) {
                u.receive(message);
            }
        }
    }

    @Override
    public void addUser(User user) {
        users.add(user);
    }
}

public abstract class User {
    protected ChatMediator mediator;
    protected String name;

    public User(ChatMediator mediator, String name) {
        this.mediator = mediator;
        this.name = name;
    }

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

public class UserImpl extends User {
    public UserImpl(ChatMediator mediator, String name) {
        super

(mediator, name);
    }

    @Override
    public void send(String message) {
        System.out.println(name + " sends: " + message);
        mediator.sendMessage(message, this);
    }

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

在这个示例中，ChatMediatorImpl 作为中介者管理用户之间的消息传递。每个 UserImpl 用户通过中介者发送和接收消息，而不直接与其他用户进行通信。

七、总结

中介者模式是一种强大的设计模式，用于简化对象间的复杂通信。通过引入一个中介者对象，中介者模式降低了系统的耦合度，使得对象之间的交互更加简洁和清晰。在Java中实现中介者模式涉及定义中介者接口、具体中介者、同事类接口和具体同事类，并通过中介者对象协调对象之间的通信。

虽然中介者模式在简化通信和降低耦合度方面具有许多优点，但在实际应用中也需要注意中介者对象的复杂性和通信过程的追踪。通过合理使用中介者模式，可以提高系统的灵活性和可维护性，使得系统设计更加高效和易于扩展。