设计模式-中介者模式

设计模式专栏

---

---

模式介绍

中介者模式是一种行为型设计模式，它通过引入一个中介者对象，将系统中的各个对象之间的耦合关系转变为对中介者对象的依赖关系，从而降低多个对象之间的耦合度，使得这些对象可以更好地协作。

在中介者模式中，中介者对象扮演了集成所有相关对象的角色。这个对象可以处理所有相关对象之间的通信，并控制这些对象之间的交互以完成某一特定任务。当多个对象之间需要相互通信时，它们不再直接彼此引用，而是通过中介者对象来进行通信和协调。

中介者模式的角色包括：

1. 抽象中介者（Mediator）：声明所有具体中介者的公共接口，主要用于对象之间的通信和协调。
2. 具体中介者（ConcreteMediator）：实现了抽象中介者的接口，管理所有相关的对象之间的通信和协调。
3. 抽象对象（Colleague）：声明所有具体对象的公共接口，该接口用于与中介者进行通信。
4. 具体对象（ConcreteColleague）：实现了抽象对象的接口，通过中介者来完成对象之间的通信和协调。

中介者模式的优点包括：

1. 降低了各个对象之间的耦合度，减少了系统中的相互依赖关系，使得系统更易于维护和扩展。
2. 提供了一种集中化的控制方式，可以更好地管理系统中的复杂交互。
3. 可以提高系统的灵活性和可复用性，使得系统更易于修改和升级。

在现实生活中，许多系统都采用了中介者模式的设计思想。例如，在电视游戏机中，通过引入一个智能家居设备作为中介者，可以解耦电视、游戏机和遥控器之间的依赖关系。此外，MVC/MVVM框架中也含有中介者模式的思想，Controller/ViewModel层作为中介者协调View/Model进行工作，减少View/Model之间的直接耦合依赖，从而做到视图层和数据层的最大分离。

中介者模式是一种重要的设计模式，它可以有效地降低系统中的耦合度，提高系统的可维护性、灵活性和可复用性。

模式特点

中介者模式的主要特点包括：

1. 降低对象之间的耦合度：中介者模式通过将对象之间的交互行为集中到一个中介者对象中，从而降低了对象之间的耦合度，使得对象之间的交互更加简单和可维护。
2. 简化对象之间的交互：中介者模式将对象之间的交互行为抽象出来，形成一个中介者对象，所有的对象都通过中介者对象来进行交互，从而简化了对象之间的交互。
3. 提高系统的可扩展性：中介者模式使得系统中的各个对象可以独立地改变和复用，而不需要修改其他对象的代码，从而提高了系统的可扩展性。

请注意，虽然中介者模式有很多优点，但也有一些缺点。例如，提高了中介者的复杂性，即将各个对象的交互的复杂性变为了中介者的复杂性，使得中介者的复杂性比其他对象类更复杂。

应用场景

中介者模式在许多实际应用场景中都有应用。以下是一些常见的应用场景：

1. 通信系统：在复杂的通信系统中，中介者模式可以用于协调多个通信实体之间的通信。中介者可以负责管理通信实体的注册、注销以及消息的转发等操作，降低通信实体之间的耦合度，提高通信系统的可维护性和可扩展性。
2. 分布式系统：在分布式系统中，中介者模式可以用于协调多个节点之间的交互。中介者可以负责管理节点的注册、注销以及消息的转发等操作，降低节点之间的耦合度，提高分布式系统的可扩展性和可维护性。
3. 插件系统：在插件系统中，中介者模式可以用于协调插件之间的交互。中介者可以负责管理插件的注册、注销以及消息的转发等操作，降低插件之间的耦合度，提高插件系统的可扩展性和可维护性。
4. 事件驱动系统：在事件驱动系统中，中介者模式可以用于协调事件发起者和事件处理者之间的交互。中介者可以负责管理事件的注册、注销以及消息的转发等操作，降低事件发起者和事件处理者之间的耦合度，提高事件驱动系统的可扩展性和可维护性。

中介者模式在许多实际应用场景中都有应用，它可以帮助降低系统中的耦合度，提高系统的可维护性、灵活性和可复用性。

中介者模式和装饰者模式的区别

中介者模式和装饰者模式在以下方面存在区别：

1. 目的不同：中介者模式的主要目的是通过引入中介者对象来解耦多个对象之间的耦合关系，使得这些对象可以更好地协作。而装饰者模式的主要目的是通过一个装饰器来增加新的方法和属性，不改变原始类的代码，以动态地扩展类的功能。

2. 参与者不同：在中介者模式中，参与者包括抽象中介者、具体中介者、抽象对象和具体对象。而在装饰者模式中，参与者包括抽象组件、具体组件、抽象装饰器和具体装饰器。

3. 结构不同：中介者模式中的中介者对象封装了一系列对象的交互，而装饰者模式中的装饰器则是通过添加新的方法和属性来扩展类的功能。

4. 侵入程度不同：在中介者模式中，具体对象需要实现抽象对象的接口，从而与中介者进行通信。而在装饰者模式中，装饰器只需要实现抽象装饰器的接口，从而扩展类的功能。

5. 扩展性不同：中介者模式具有良好的扩展性，可以通过添加新的具体中介者和具体对象来扩展系统。而装饰者模式的扩展性相对较弱，因为当需要添加新的装饰器时，需要修改抽象装饰器的接口，从而影响到所有使用该接口的装饰器。

中介者模式和装饰者模式在目的、参与者、结构、侵入程度和扩展性等方面存在差异。

代码示例

Java实现中介者模式

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

// 抽象中介者
interface Mediator {
    void register(Colleague colleague);
    void unregister(Colleague colleague);
    void relay(Colleague colleague, String message);
}

// 具体中介者
class ConcreteMediator implements Mediator {
    private List<Colleague> colleagues = new ArrayList<>();

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

    @Override
    public void unregister(Colleague colleague) {
        colleagues.remove(colleague);
    }

    @Override
    public void relay(Colleague colleague, String message) {
        for (Colleague c : colleagues) {
            if (c != colleague) {
                c.receive(message);
            }
        }
    }
}

// 抽象对象
interface Colleague {
    void receive(String message);
}

// 具体对象
class ConcreteColleague implements Colleague {
    private String name;
    private Mediator mediator;

    public ConcreteColleague(String name, Mediator mediator) {
        this.name = name;
        this.mediator = mediator;
        mediator.register(this);
    }

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

// 客户端代码
public class MediatorPatternDemo {
    public static void main(String[] args) {
        Mediator mediator = new ConcreteMediator();
        ConcreteColleague colleague1 = new ConcreteColleague("Alice", mediator);
        ConcreteColleague colleague2 = new ConcreteColleague("Bob", mediator);
        ConcreteColleague colleague3 = new ConcreteColleague("Charlie", mediator);
        mediator.relay(colleague1, "Hello"); // Charlie received: Hello
        mediator.relay(colleague2, "World"); // Alice received: World
        mediator.relay(colleague3, "!"); // Bob received: !
    }
}

在这个示例中，我们定义了一个抽象中介者接口 Mediator 和一个具体中介者类 ConcreteMediator。抽象对象接口 Colleague 定义了同事之间的通信方法 receive，具体对象类 ConcreteColleague 实现了该接口，并注册到中介者中。在客户端代码中，我们创建了三个同事对象，并通过中介者传递消息。当一个同事接收到消息时，它会通知其他同事。

python实现中介者模式

以下是使用Python实现中介者模式的示例代码：

from abc import ABC, abstractmethod

# 抽象中介者
class Mediator(ABC):
    @abstractmethod
    def register(self, colleague):
        pass
    
    @abstractmethod
    def unregister(self, colleague):
        pass
    
    @abstractmethod
    def relay(self, colleague, message):
        pass

# 具体中介者
class ConcreteMediator(Mediator):
    def __init__(self):
        self.colleagues = []
    
    def register(self, colleague):
        self.colleagues.append(colleague)
    
    def unregister(self, colleague):
        self.colleagues.remove(colleague)
    
    def relay(self, colleague, message):
        for c in self.colleagues:
            if c != colleague:
                c.receive(message)

# 抽象对象
class Colleague(ABC):
    @abstractmethod
    def receive(self, message):
        pass

# 具体对象
class ConcreteColleague(Colleague):
    def __init__(self, name):
        self.name = name
    
    def receive(self, message):
        print(f"{self.name} received: {message}")

# 客户端代码
def main():
    mediator = ConcreteMediator()
    colleague1 = ConcreteColleague("Alice")
    colleague2 = ConcreteColleague("Bob")
    colleague3 = ConcreteColleague("Charlie")
    mediator.register(colleague1)
    mediator.register(colleague2)
    mediator.register(colleague3)
    mediator.relay(colleague1, "Hello") # Charlie received: Hello
    mediator.relay(colleague2, "World") # Alice received: World
    mediator.relay(colleague3, "!") # Bob received: !
    mediator.unregister(colleague1) # Remove Alice from the mediators list of colleagues. Now only Bob and Charlie are registered. 
    mediator.relay(colleague2, "Hello again") # Charlie received: Hello again (Bob has received this message too because he is still registered) 
                                               # but Alice has been unregistered so she will not receive this message.   
if __name__ == "__main__":
    main()

中介者模式在spring中的应用

中介者模式在Spring框架中的应用主要体现在Spring的事件监听机制中。

在Spring中，事件监听机制是一种观察者模式，它允许组件之间进行松耦合的通信。在事件监听机制中，中介者模式扮演着重要的角色。

具体来说，Spring的事件监听机制包括以下几个步骤：

1. 定义事件：首先需要定义一个事件类，该类通常继承自Spring的事件基类，例如ApplicationEvent。
2. 注册监听器：当某个组件需要监听某个事件时，它需要注册一个监听器。在Spring中，可以通过实现ApplicationListener接口或者使用@EventListener注解来注册监听器。
3. 触发事件：当某个事件被触发时，Spring的事件监听机制会通知所有注册的监听器。在通知监听器之前，Spring会先通过中介者模式将事件分发给对应的事件处理器进行处理。
4. 处理事件：事件处理器会根据事件的类型调用相应的处理方法，例如调用监听器的handle方法。

在Spring的事件监听机制中，中介者模式的作用是将事件分发给对应的事件处理器进行处理。具体来说，当某个事件被触发时，Spring会通过中介者模式将该事件分发给对应的事件处理器进行处理。这样，不同的组件可以独立地处理不同的事件，而不需要相互依赖。

中介者模式在Spring框架中的应用主要体现在Spring的事件监听机制中，它使得组件之间的通信更加灵活和可扩展。