设计模式 - 行为型模式 - 中介者模式

目录

1. 引言
2. 中介者模式概述
   • 定义
   • 意图
3. 中介者模式的结构
   • 类图
4. 中介者模式的优缺点
5. 使用场景
6. 案例分析
   • 案例一：聊天应用
   • 案例二：订单处理系统
7. 总结

引言

在软件开发中，随着系统的复杂性不断增加，模块之间的交互和协调变得愈发重要。为了有效管理这些交互，设计模式提供了可重用的解决方案。其中，中介者模式作为一种行为型模式，旨在通过引入一个中介对象来促进不同模块之间的通信，从而减少它们之间的耦合度。本篇文章将深入探讨中介者模式的定义、结构、优缺点、使用场景及具体案例。

中介者模式概述

定义

中介者模式（Mediator Pattern）是一种行为型设计模式，定义了一个中介对象以封装一组对象之间的交互。中介者使各个对象不需要显式地引用彼此，从而使它们之间的耦合度降低，并可以独立变化。

意图

中介者模式的主要意图是：

• 降低对象之间的耦合度。
• 提供一个集中化的控制点，以便于对象间的通信。
• 简化对象之间的相互依赖关系。

中介者模式的结构

中介者模式通常由以下几个角色组成：

1. 中介者（Mediator）：定义与各个参与者交互的接口。
2. 具体中介者（ConcreteMediator）：实现中介者接口，协调各个参与者的交互。
3. 同事类（Colleague）：每个同事类都知道中介者，并通过它与其他同事进行通信。

类图

plaintextCopy Code
+-------------------+
|     Mediator      |
+-------------------+
| +send(message, col)| 
+-------------------+
          ^
          |
+-------------------+
| ConcreteMediator  |
+-------------------+
| +colleagues: List | 
| +send(message, col)| 
+-------------------+
          ^
          |
+-------------------+
|   Colleague       |
+-------------------+
| +mediator: Mediator|
| +send(message)    |
| +receive(message) |
+-------------------+

中介者模式的优缺点

优点

1. 降低耦合度：中介者模式通过中介者对象减少了同事类之间的直接联系，使得系统更易于维护和扩展。
2. 集中管理：所有的交互都通过中介者进行，便于管理和调试。
3. 增强灵活性：可以在不影响同事类的情况下，修改中介者的实现或者添加新的同事类。

缺点

1. 单点故障：中介者作为中心节点，如果出现问题，可能会导致整个系统的通信失败。
2. 复杂性增加：在某些情况下，引入中介者可能会增加系统的复杂性，特别是在中介者承担了过多职责时。

使用场景

中介者模式适用于以下情况：

• 当系统中存在多个对象需要相互通信，但它们之间的耦合度应尽量降低时。
• 当需要集中控制对象之间的交互逻辑，并希望简化对象之间的关系时。
• 当对象的交互频繁且复杂时，可以考虑引入中介者来管理这些交互。

案例分析

案例一：聊天应用

需求描述

在一个聊天应用中，不同的用户可以发送消息给其他用户。每个用户需要知道如何发送和接收消息，但不应该直接引用其他用户的对象。

代码实现

pythonCopy Code
class Mediator:
    def send(self, message, colleague):
        raise NotImplementedError

class ConcreteMediator(Mediator):
    def __init__(self):
        self.colleagues = []

    def register(self, colleague):
        self.colleagues.append(colleague)
        colleague.mediator = self

    def send(self, message, colleague):
        for c in self.colleagues:
            if c != colleague:
                c.receive(message)

class Colleague:
    def __init__(self, name):
        self.name = name
        self.mediator = None

    def send(self, message):
        print(f"{self.name} sends: {message}")
        self.mediator.send(message, self)

    def receive(self, message):
        print(f"{self.name} receives: {message}")

# 使用示例
mediator = ConcreteMediator()

user1 = Colleague("User1")
user2 = Colleague("User2")
user3 = Colleague("User3")

mediator.register(user1)
mediator.register(user2)
mediator.register(user3)

user1.send("Hello Everyone!")

运行结果

plaintextCopy Code
User1 sends: Hello Everyone!
User2 receives: Hello Everyone!
User3 receives: Hello Everyone!

案例二：订单处理系统

需求描述

在一个电商平台中，用户下单后需要通知库存、支付和配送等模块。为了保持这些模块之间的解耦，我们可以使用中介者模式来管理这些交互。

代码实现

pythonCopy Code
class OrderMediator(Mediator):
    def __init__(self):
        self.inventory = Inventory()
        self.payment = Payment()
        self.shipping = Shipping()

    def send(self, order, colleague):
        if isinstance(colleague, Order):
            self.inventory.process_order(order)
            if self.payment.process_payment(order):
                self.shipping.schedule_delivery(order)

class Order:
    def __init__(self, item, quantity):
        self.item = item
        self.quantity = quantity

class Inventory:
    def process_order(self, order):
        print(f"Inventory processed order for {order.quantity} of {order.item}")

class Payment:
    def process_payment(self, order):
        print(f"Payment processed for {order.quantity} of {order.item}")
        return True  # Assume payment is successful

class Shipping:
    def schedule_delivery(self, order):
        print(f"Delivery scheduled for {order.quantity} of {order.item}")

# 使用示例
mediator = OrderMediator()
order = Order("Laptop", 1)
mediator.send(order, order)

运行结果

plaintextCopy Code
Inventory processed order for 1 of Laptop
Payment processed for 1 of Laptop
Delivery scheduled for 1 of Laptop

总结

中介者模式通过引入中介者对象，有效降低了模块之间的耦合度，使得系统更加灵活和可维护。我们通过聊天应用和订单处理系统的案例，展示了中介者模式在实际开发中的应用情况。通过合理使用中介者模式，开发者能够更好地管理复杂的对象交互，实现高内聚、低耦合的系统设计。