Java设计模式：中介者模式详解与最佳实践

范范0825

于 2024-08-10 13:54:20 发布

阅读量261

点赞数 1

文章标签： java 设计模式中介者模式

本文链接：https://blog.csdn.net/weixin_41859354/article/details/141090034

版权

Java设计模式：中介者模式详解与最佳实践

1. 引言

在软件开发过程中，特别是复杂系统的构建中，模块间的交互往往成为影响代码质量的重要因素。当模块之间耦合度过高时，系统的维护、扩展和理解成本都会显著增加。为了降低模块之间的耦合度，保持系统的灵活性和可维护性，我们可以使用设计模式中的中介者模式（Mediator Pattern）。本篇文章将详细介绍中介者模式的概念、优点及其在Java中的应用，并通过实例代码演示如何实现这一模式。

2. 中介者模式概述

2.1 中介者模式定义

中介者模式是一种行为型设计模式，用于减少多个对象之间的耦合。它通过引入一个中介者对象，使得各个对象不直接相互引用，而是通过中介者对象进行通信。这种模式将对象之间的复杂关系转换为简化的星型关系，从而降低对象之间的耦合度。

2.2 中介者模式的适用场景

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

对象之间存在复杂的交互关系：如果对象之间的关系错综复杂，直接交互会导致代码难以维护，此时适合引入中介者模式。
需要复用对象，但又希望能在不同的上下文中灵活互通：通过中介者模式，可以在不同的中介者中定义不同的交互逻辑。
希望将交互行为封装到一个独立的对象中：这样可以更好地控制、管理和扩展交互逻辑，而不影响对象本身的设计。

2.3 中介者模式的优缺点

优点：

降低对象之间的耦合：通过中介者对象，各模块不再直接引用彼此，减少了代码的耦合度。
集中控制交互逻辑：所有的交互都在中介者中处理，可以统一管理和修改，逻辑集中且清晰。
提高代码的可维护性和可扩展性：当新增或修改交互逻辑时，只需更改中介者，减少对原有代码的影响。

缺点：

可能导致中介者过于复杂：如果交互逻辑过多，可能导致中介者类变得庞大和复杂，难以维护。
降低了对象的独立性：对象过度依赖中介者，可能会使得对象在没有中介者的情况下难以使用。

3. 中介者模式的结构与实现

3.1 中介者模式的结构

中介者模式主要由以下几个角色组成：

Mediator（中介者）：定义了同事对象之间交互的接口。
ConcreteMediator（具体中介者）：实现了中介者接口，协调各个同事对象之间的交互。
Colleague（同事类）：每个同事类只知道自己的行为，不了解其他同事类的情况，它们通过中介者与其他同事类进行通信。

3.2 UML类图

在详细介绍代码实现之前，我们先看一下中介者模式的UML类图：

       +------------------+
       |     Mediator     |<-------------------+
       +------------------+                    |
       |  + notify()      |                    |
       +------------------+                    |
                ^                              |
                |                              |
     +------------------+                      |
     | ConcreteMediator |                      |
     +------------------+                      |
     |  + notify()      |                      |
     +------------------+                      |
                ^                              |
                |                              |
 +------------------+        +------------------+
 |     ColleagueA   |        |    ColleagueB    |
 +------------------+        +------------------+
 |  + send()        |        |  + send()        |
 |  + receive()     |        |  + receive()     |
 +------------------+        +------------------+

3.3 代码实现

以下是中介者模式的Java代码实现，展示了一个简单的聊天系统，多个用户（同事类）通过中介者进行消息传递。

// 定义中介者接口
interface Mediator {
    void sendMessage(String message, Colleague colleague);
    void addColleague(Colleague colleague);
}

// 具体中介者类
class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues;

    public ConcreteMediator() {
        this.colleagues = new ArrayList<>();
    }

    @Override
    public void sendMessage(String message, Colleague colleague) {
        for (Colleague c : colleagues) {
            // 不发送消息给发送者本身
            if (c != colleague) {
                c.receive(message);
            }
        }
    }

    @Override
    public void addColleague(Colleague colleague) {
        colleagues.add(colleague);
    }
}

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

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

    public abstract void send(String message);

    public abstract void receive(String message);
}

// 具体的同事类：UserA
class UserA extends Colleague {

    public UserA(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        System.out.println("UserA发送消息: " + message);
        mediator.sendMessage(message, this);
    }

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

// 具体的同事类：UserB
class UserB extends Colleague {

    public UserB(Mediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        System.out.println("UserB发送消息: " + message);
        mediator.sendMessage(message, this);
    }

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

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

        Colleague userA = new UserA(mediator);
        Colleague userB = new UserB(mediator);

        mediator.addColleague(userA);
        mediator.addColleague(userB);

        userA.send("你好，UserB！");
        userB.send("你好，UserA！我收到了你的消息。");
    }
}

在这个示例中，ConcreteMediator类作为中介者，负责管理Colleague对象之间的消息传递。每个Colleague对象（如UserA和UserB）通过中介者发送和接收消息，而不需要直接引用彼此。

3.4 代码分析

松散耦合：UserA和UserB并不知道对方的存在，它们只通过ConcreteMediator进行通信。这样，如果我们增加一个新的同事类，例如UserC，并不需要修改UserA和UserB的代码，只需要在中介者中处理其交互即可。
单一职责原则：每个同事类只负责发送和接收消息，不关心如何传递消息。中介者类集中管理消息的路由逻辑，使得同事类的职责单一化。
扩展性：通过中介者模式，可以轻松地增加新的同事类或修改交互逻辑，而不会影响现有的类。

4. 中介者模式的最佳实践

4.1 在大型系统中的应用

在大型系统中，模块之间的交互关系往往非常复杂，使用中介者模式可以有效降低模块间的耦合度。例如，在企业级应用中，用户界面的各个组件之间通常需要频繁交互，使用中介者模式可以使界面组件之间的通信更加清晰和灵活。

4.2 在消息传递系统中的应用

中介者模式非常适合用于消息传递系统中。例如，在即时通讯应用中，各个客户端可以通过服务器（中介者）进行消息传递。服务器负责管理客户端的连接和消息的转发，而客户端只需要关注如何发送和接收消息。

4.3 在微服务架构中的应用

在微服务架构中，各个服务之间的通信往往通过消息队列或事件总线来实现。这种通信方式本质上就是中介者模式的一种应用。通过引入一个消息中介者，可以解耦微服务之间的依赖关系，增强系统的扩展性和容错性。

5. 中介者模式的变体与改进

5.1 事件驱动的中介者模式

在某些情况下，可以结合事件驱动的方式来实现中介者模式。这种变体通常在GUI应用程序或实时系统中

使用，通过事件机制来触发中介者的动作，而不是直接调用方法。

interface EventMediator {
    void notify(String event, Colleague colleague);
}

class EventDrivenMediator implements EventMediator {
    private Map<String, List<Colleague>> listeners = new HashMap<>();

    public void subscribe(String event, Colleague colleague) {
        listeners.putIfAbsent(event, new ArrayList<>());
        listeners.get(event).add(colleague);
    }

    @Override
    public void notify(String event, Colleague colleague) {
        if (listeners.containsKey(event)) {
            for (Colleague c : listeners.get(event)) {
                if (c != colleague) {
                    c.receive(event + " triggered by " + colleague.getClass().getSimpleName());
                }
            }
        }
    }
}

class EventUserA extends Colleague {

    public EventUserA(EventMediator mediator) {
        super(mediator);
    }

    public void triggerEvent(String event) {
        System.out.println("EventUserA triggers event: " + event);
        mediator.notify(event, this);
    }

    @Override
    public void send(String message) {
        // Implementation not required for this example
    }

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

class EventUserB extends Colleague {

    public EventUserB(EventMediator mediator) {
        super(mediator);
    }

    @Override
    public void send(String message) {
        // Implementation not required for this example
    }

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

public class EventDrivenMediatorDemo {
    public static void main(String[] args) {
        EventDrivenMediator mediator = new EventDrivenMediator();

        EventUserA userA = new EventUserA(mediator);
        EventUserB userB = new EventUserB(mediator);

        mediator.subscribe("event1", userB);

        userA.triggerEvent("event1");
    }
}

在这个例子中，中介者模式结合了事件驱动的思想，EventUserA触发了event1事件，EventUserB通过中介者接收到该事件。事件驱动的中介者模式提高了系统的响应性和灵活性。

5.2 中介者模式与观察者模式的结合

中介者模式可以与观察者模式结合使用，通过将观察者模式中的订阅者通知功能整合到中介者中，从而实现更复杂的交互逻辑。这种结合方式特别适用于需要动态管理和通知多个组件的场景。

6. 结论

中介者模式通过引入一个中介者对象，减少了系统中对象之间的直接耦合，从而提高了代码的可维护性和扩展性。在复杂系统的构建中，中介者模式尤其适合处理对象之间复杂的交互关系，避免了代码的混乱和难以维护。

通过本文的详细讲解与代码示例，我们深入理解了中介者模式的核心思想、适用场景以及实际应用中的最佳实践。在实际开发中，掌握并合理运用中介者模式，可以有效提升系统设计的质量，降低维护成本。

范范0825

关注

1
点赞
踩
3

收藏

觉得还不错? 一键收藏
0
评论
Java设计模式：中介者模式详解与最佳实践

中介者模式是一种行为型设计模式，用于减少多个对象之间的耦合。它通过引入一个中介者对象，使得各个对象不直接相互引用，而是通过中介者对象进行通信。这种模式将对象之间的复杂关系转换为简化的星型关系，从而降低对象之间的耦合度。
复制链接

扫一扫