调停者模式是一种软件设计模式,主要用于模块间的解耦,通过避免对象之间显式的互相指向,降低耦合度。这种模式通常用于解决多个对象之间重复访问、无规律性、交互方式复杂且通常存在非结构依赖的问题。
在调停者模式中,通常会有一个抽象调停者(Mediator)类,它定义了同事对象与调停者对象之间的接口,主要方法是一个或多个事件方法。具体调停者(ConcreteMediator)类则实现了抽象调停者所声明的事件方法,负责具体的协调各同事对象的交互关系。此外,还有一个抽象同事类(Colleague),它定义了调停者到同事对象的接口,同事对象只知道调停者而不知道其余的同事对象。
调停者模式将多对多的相互作用转化为一对多的相互作用,将对象的行为和协作抽象化,把对象在小尺度的行为上与其他对象的相互作用分开处理。通过使用中介对象封装一系列的对象交互,各对象不需要显式地相互引用,从而使其耦合松散,而且可以独立地改变它们之间的交互。这种模式有助于降低系统的复杂性,提高可维护性和可扩展性。
调停者模式的特点主要包括以下几个方面:
调停者模式通过封装交互、抽象化、转化交互方式等特点,降低了系统的耦合度,使得对象间的交互行为更加清晰和易于管理,提高了系统的可维护性和可扩展性。同时,需要注意控制集中化的问题,并合理选择适用场景。
调停者模式的应用场景主要包括:
调停者模式能够将对象间的直接调用解耦,使得对象间的交互行为集中化管理,方便维护和扩展。然而,这种模式也有其局限性,如可能导致控制集中化,使得调停者类变得复杂且难于管理。在实际应用中,需要根据具体问题来决定是否采用调停者模式。
调停者模式与命令模式是两种不同的软件设计模式,它们有不同的应用场景和特点。
调停者模式主要用于解决多个对象之间的交互问题,通过引入一个调停者对象来封装和协调各个对象之间的交互,降低系统的耦合度,使得对象间的交互行为更加清晰和易于管理。其主要特点是能够将多个对象的交互行为集中在一个对象中管理,使得对象的相互依赖关系变得简单,降低系统的复杂性和维护成本。
命令模式是一种行为型设计模式,它主要处理在不同对象之间指定责任的细节,描述对象间的通信机制,定义一种机制以便在运行时根据不同的对象选择不同的逻辑。其主要特点是将请求或操作封装到一个对象中,通过使用命令对象来请求一个操作的对象与知道怎么执行一个操作的对象解耦,使得请求可以被取消、恢复或者组合。
调停者模式与命令模式的不同点在于,调停者模式主要关注多个对象之间的交互解耦,而命令模式主要关注请求或操作的封装、排队和撤销等控制功能。此外,调停者模式通常用于协调对象之间的交互行为,而命令模式通常用于处理请求或操作的控制流程。
相同点方面,调停者模式和命令模式都关注降低系统的耦合度,提高系统的可维护性和可扩展性。它们都通过封装请求或操作来实现对请求的控制,包括排队、顺序执行和撤销等。同时,它们都需要在请求的发送者和接收者之间建立一种抽象的通信机制,以便在运行时根据不同的对象选择不同的逻辑。
调停者模式和命令模式在应用场景、作用和使用特点等方面存在明显的差异,但两者在抽象通信机制和降低系统耦合度方面有一定的相似性。在实际应用中,根据具体的问题和需求选择合适的模式是重要的。
以下是一个简单的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实现调停者模式的示例代码:
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中,可以使用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中调停者模式的典型应用。
设计模式-过滤器模式
设计模式-门面模式