设计模式-调停者模式

设计模式专栏

---

---

模式介绍

调停者模式是一种软件设计模式，主要用于模块间的解耦，通过避免对象之间显式的互相指向，降低耦合度。这种模式通常用于解决多个对象之间重复访问、无规律性、交互方式复杂且通常存在非结构依赖的问题。

在调停者模式中，通常会有一个抽象调停者（Mediator）类，它定义了同事对象与调停者对象之间的接口，主要方法是一个或多个事件方法。具体调停者（ConcreteMediator）类则实现了抽象调停者所声明的事件方法，负责具体的协调各同事对象的交互关系。此外，还有一个抽象同事类（Colleague），它定义了调停者到同事对象的接口，同事对象只知道调停者而不知道其余的同事对象。

调停者模式将多对多的相互作用转化为一对多的相互作用，将对象的行为和协作抽象化，把对象在小尺度的行为上与其他对象的相互作用分开处理。通过使用中介对象封装一系列的对象交互，各对象不需要显式地相互引用，从而使其耦合松散，而且可以独立地改变它们之间的交互。这种模式有助于降低系统的复杂性，提高可维护性和可扩展性。

模式特点

调停者模式的特点主要包括以下几个方面：

1. 封装交互 ：调停者模式将一系列对象之间的交互封装在一个单独的调停者对象中，使得这些对象之间不需要相互明显引用，从而降低了耦合度。
2. 抽象化 ：调停者模式将对象的行为和协作抽象化，将小尺度的行为上与其他对象的相互作用分开处理，使得对象之间的关系更加易于维护和理解。
3. 转化交互方式 ：调停者模式将多对多的相互作用转化为一对多的相互作用，使得对象之间的关系更加清晰和易于管理。
4. 提供可扩展性 ：调停者模式为同事对象提供可扩展性，使得系统可以在不改变现有类的情况下进行扩展。
5. 控制集中化 ：调停者模式将控制集中在一个对象上，可能会使得这个对象变得复杂且难于管理。
6. 适用场景 ：调停者模式适用于解决多个对象之间存在复杂交互、行为变化多样且不规律的问题，尤其在涉及不同对象的协同工作、请求分发、业务逻辑协调等场景中能够发挥重要作用。

调停者模式通过封装交互、抽象化、转化交互方式等特点，降低了系统的耦合度，使得对象间的交互行为更加清晰和易于管理，提高了系统的可维护性和可扩展性。同时，需要注意控制集中化的问题，并合理选择适用场景。

应用场景

调停者模式的应用场景主要包括：

1. 当一个系统内部存在许多类，它们之间相互调用以完成一系列功能时，一旦某个类发生问题或需要进行修改，这可能会导致对所有调用它的类产生影响，此时就可以采用调停者模式。通过引入调停者类来封装所有类之间的交互，使原本复杂的网状结构变得简单，形成星型结构，降低了类与类之间的耦合度。
2. 在处理对象之间存在复杂交互、行为变化多样且不规律的情况下，调停者模式可以起到很好的作用。
3. 存在非结构化依赖的情况下，使用调停者模式能够简化对象的相互依赖关系，降低维护和扩展的难度。
4. 涉及不同对象的协同工作、请求分发、业务逻辑协调等场景，也可以考虑使用调停者模式。

调停者模式能够将对象间的直接调用解耦，使得对象间的交互行为集中化管理，方便维护和扩展。然而，这种模式也有其局限性，如可能导致控制集中化，使得调停者类变得复杂且难于管理。在实际应用中，需要根据具体问题来决定是否采用调停者模式。

调停者模式与命令模式的比较

调停者模式与命令模式是两种不同的软件设计模式，它们有不同的应用场景和特点。

调停者模式主要用于解决多个对象之间的交互问题，通过引入一个调停者对象来封装和协调各个对象之间的交互，降低系统的耦合度，使得对象间的交互行为更加清晰和易于管理。其主要特点是能够将多个对象的交互行为集中在一个对象中管理，使得对象的相互依赖关系变得简单，降低系统的复杂性和维护成本。

命令模式是一种行为型设计模式，它主要处理在不同对象之间指定责任的细节，描述对象间的通信机制，定义一种机制以便在运行时根据不同的对象选择不同的逻辑。其主要特点是将请求或操作封装到一个对象中，通过使用命令对象来请求一个操作的对象与知道怎么执行一个操作的对象解耦，使得请求可以被取消、恢复或者组合。

调停者模式与命令模式的不同点在于，调停者模式主要关注多个对象之间的交互解耦，而命令模式主要关注请求或操作的封装、排队和撤销等控制功能。此外，调停者模式通常用于协调对象之间的交互行为，而命令模式通常用于处理请求或操作的控制流程。

相同点方面，调停者模式和命令模式都关注降低系统的耦合度，提高系统的可维护性和可扩展性。它们都通过封装请求或操作来实现对请求的控制，包括排队、顺序执行和撤销等。同时，它们都需要在请求的发送者和接收者之间建立一种抽象的通信机制，以便在运行时根据不同的对象选择不同的逻辑。

调停者模式和命令模式在应用场景、作用和使用特点等方面存在明显的差异，但两者在抽象通信机制和降低系统耦合度方面有一定的相似性。在实际应用中，根据具体的问题和需求选择合适的模式是重要的。

代码示例

Java实现调停者模式

以下是一个简单的Java实现调停者模式的示例：

// 抽象调停者
interface Mediator {
    void register(Colleague colleague);
    void handleMessage(Colleague colleague, Object message);
}

// 具体调停者
class ConcreteMediator implements Mediator {
    private Map<Colleague, Handler> handlers = new HashMap<>();

    @Override
    public void register(Colleague colleague) {
        handlers.put(colleague, new Handler(colleague));
    }

    @Override
    public void handleMessage(Colleague colleague, Object message) {
        Handler handler = handlers.get(colleague);
        if (handler != null) {
            handler.handleMessage(message);
        }
    }

    class Handler {
        private Colleague colleague;

        public Handler(Colleague colleague) {
            this.colleague = colleague;
        }

        public void handleMessage(Object message) {
            // 处理消息逻辑，根据具体需求实现
            System.out.println("ConcreteMediator handled message for Colleague " + colleague);
        }
    }
}

// 抽象同事类
interface Colleague {
    void setMediator(Mediator mediator);
    void sendMessage(Object message);
}

// 具体同事类1
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 sendMessage(Object message) {
        mediator.handleMessage(this, message);
    }

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

// 具体同事类2
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 sendMessage(Object message) {
        mediator.handleMessage(this, message);
    }

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

Python实现调停者模式

以下是Python实现调停者模式的示例代码：

from abc import ABC, abstractmethod

# 抽象调停者
class Mediator(ABC):
    @abstractmethod
    def register(self, colleague):
        pass

    @abstractmethod
    def handle_message(self, colleague, message):
        pass

# 具体调停者
class ConcreteMediator(Mediator):
    def __init__(self):
        self.colleagues = []

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

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

# 抽象同事类
class Colleague(ABC):
    @abstractmethod
    def set_mediator(self, mediator):
        pass

    @abstractmethod
    def send_message(self, message):
        pass

# 具体同事类1
class ConcreteColleague1(Colleague):
    def __init__(self, name):
        self.name = name
        self.mediator = None

    def set_mediator(self, mediator):
        self.mediator = mediator
        mediator.register(self)

    def send_message(self, message):
        self.mediator.handle_message(self, message)
        print(f"{self.name} sent message: {message}")

# 具体同事类2
class ConcreteColleague2(Colleague):
    def __init__(self, name):
        self.name = name
        self.mediator = None

    def set_mediator(self, mediator):
        self.mediator = mediator
        mediator.register(self)

    def send_message(self, message):
        self.mediator.handle_message(self, message)
        print(f"{self.name} sent message: {message}")

调停者模式在spring中的应用

在Spring框架中，调停者模式可以应用于许多场景，其中最常见的是事件监听和通知机制。Spring的事件监听器模式就是一个典型的调停者模式的实现。

在Spring中，可以使用ApplicationListener接口和ApplicationEvent类来实现事件监听和通知。ApplicationListener接口定义了一个onApplicationEvent方法，该方法在接收到事件时会触发。ApplicationEvent类是事件的抽象类，它定义了一些常用的方法，如获取事件的来源和时间等。

具体实现时，首先需要创建一个继承自ApplicationEvent的事件类，例如：

public class MyCustomEvent extends ApplicationEvent {
    private String message;

    public MyCustomEvent(Object source, String message) {
        super(source);
        this.message = message;
    }

    public String getMessage() {
        return message;
    }
}

然后，创建一个实现ApplicationListener接口的监听器类，例如：

import org.springframework.context.ApplicationListener;
import org.springframework.stereotype.Component;

@Component
public class MyCustomEventListener implements ApplicationListener<MyCustomEvent> {
    @Override
    public void onApplicationEvent(MyCustomEvent event) {
        System.out.println("Received MyCustomEvent - " + event.getMessage());
    }
}

最后，在需要发布事件的类中，使用ApplicationContext的publishEvent方法发布事件：

import org.springframework.context.ApplicationContext;
import org.springframework.context.annotation.AnnotationConfigApplicationContext;
import org.springframework.context.support.ClassPathXmlApplicationContext;
import org.springframework.stereotype.Component;

@Component
public class EventPublisher {
    private ApplicationContext applicationContext;

    public EventPublisher(ApplicationContext applicationContext) {
        this.applicationContext = applicationContext;
    }

    public void publishEvent() {
        String message = "Hello, Spring!";
        MyCustomEvent event = new MyCustomEvent(this, message);
        applicationContext.publishEvent(event);
    }
}

在上面的示例中，EventPublisher组件发布了一个自定义的事件，所有实现了MyCustomEventListener接口的组件都会接收到该事件，并执行相应的逻辑。这就是Spring中调停者模式的典型应用。

设计模式-过滤器模式

设计模式-门面模式