在软件开发中，设计模式是解决常见问题的有效工具。本文将通过一个事件处理系统的实现，探讨几种常用设计模式的应用，包括模板方法、责任链、策略、观察者和工厂模式。这些模式的结合使用可以构建出高效、灵活且可扩展的系统架构。
1. EventHandlerWrapper 类
EventHandlerWrapper 类的主要功能是包装事件处理器，并在处理事件时管理线程本地缓存。这对于需要在多线程环境中共享和管理缓存数据的应用非常有用。通过使用这种包装器类，可以确保每个线程都有一份独立的缓存副本，避免线程间的数据冲突。
代码实现
java
import java.lang.ref.SoftReference;
import java.util.Iterator;
import java.util.Map;
import java.util.concurrent.ConcurrentHashMap;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
// 事件处理包装类，用于处理并行事件
public class EventHandlerWrapper<Event> {
// 日志记录器
private static Logger logger = LoggerFactory.getLogger(EventHandlerWrapper.class);
// 事件处理器
private EventHandler<Event> eventHandler;
// 本地缓存，用于存储线程相关的数据
ConcurrentHashMap<String, Object> cache = null;
// 构造函数，初始化事件处理器和线程本地缓存
public EventHandlerWrapper(EventHandler<Event> h) {
this.eventHandler = h;
try {
// 获取所有线程本地缓存
ConcurrentHashMap<String, Object> parent = ThreadLocalHandlerCache.getAllThreadLocalCache();
if (parent != null && !parent.isEmpty()) {
// 初始化当前对象的缓存
this.cache = new ConcurrentHashMap<>(parent.size());
Iterator<Map.Entry<String, Object>> iterator = parent.entrySet().iterator();
while (iterator.hasNext()) {
Map.Entry<String, Object> entry = iterator.next();
if (entry != null) {
// 初始化子缓存值
Object target = this.initChildValue(entry.getValue());
if (target != null) {
this.cache.put(entry.getKey(), target);
}
}
}
}
} catch (Exception var6) {
logger.error("初始化并行处理器错误，原因是初始化子缓存:", var6);
}
}
// 初始化子缓存值
private <T> T initChildValue(Object source) {
Object target = source;
try {
if (source != null) {
boolean isOldSoft = SoftReference.class.isInstance(source);
if (isOldSoft) {
// 获取软引用的实际对象
target = ((SoftReference<?>) source).get();
}
if (target == null) {
return null;
}
if (Cachable.class.isInstance(target)) {
// 获取可缓存对象的当前缓存值
target = ((Cachable) target).getCurCachable();
}
if (target != null && isOldSoft && !SoftReference.class.isInstance(target)) {
// 如果目标对象不是软引用，则创建新的软引用
target = new SoftReference<>(target);
}
}
} catch (Exception var4) {
logger.error("线程本地子缓存转换错误:", var4);
}
return (T) target;
}
// 处理事件
public void onEvent(Event event) {
// 更新线程本地缓存值
this.updateThreadLocalValue();
try {
// 执行事件处理器
this.eventHandler.onEvent(event);
} catch (Exception var6) {
logger.error("并行处理器错误:" + var6.getMessage(), var6);
throw new RuntimeException(var6);
} finally {
// 移除线程本地缓存
ThreadLocalHandlerCache.removeThreadLocalCache();
}
}
// 更新线程本地缓存值
private void updateThreadLocalValue() {
try {
ConcurrentHashMap<String, Object> oldCache = ThreadLocalHandlerCache.getAllThreadLocalCache();
if (oldCache != null && !oldCache.isEmpty() || this.cache == null) {
return;
}
// 将当前缓存值放入线程本地缓存
ThreadLocalHandlerCache.putAllThreadLocalCache(this.cache);
} catch (Exception var2) {
logger.error("更新子线程本地错误:", var2);
}
}
// 包装事件处理器
public static <T> EventHandlerWrapper<T> wrapperEventHandler(EventHandler<T> h) {
return new EventHandlerWrapper<>(h);
}
}2. 模板方法模式
模板方法模式定义了一个操作中的算法骨架，而将一些步骤延迟到子类中。它允许子类在不改变算法结构的情况下重新定义算法中的某些步骤。
代码实现
java
// 模板方法模式：定义事件处理的模板
abstract class EventProcessorTemplate<Event> {
// 准备事件
abstract Event prepareEvent();
// 验证事件
abstract void validateEvent(Event event);
// 处理事件
abstract void processEvent(Event event);
// 模板方法，定义处理事件的流程
public final void handleEvent() {
Event event = prepareEvent();
validateEvent(event);
processEvent(event);
}
}3. 责任链模式
责任链模式通过给多个对象处理请求的机会来避免请求发送者与接收者之间的耦合。请求沿着链传递，直到有对象处理它为止。
代码实现
java
// 责任链模式：定义处理请求的接口
interface Handler {
void setNextHandler(Handler next);
void handleRequest(String request);
}
// 具体处理者A
class ConcreteHandlerA implements Handler {
private Handler next;
// 设置下一个处理者
@Override
public void setNextHandler(Handler next) {
this.next = next;
}
// 处理请求
@Override
public void handleRequest(String request) {
if (canHandle(request)) {
System.out.println("ConcreteHandlerA 处理请求: " + request);
} else if (next != null) {
next.handleRequest(request);
}
}
// 判断是否能处理请求
private boolean canHandle(String request) {
return "A".equals(request);
}
}4. 策略模式
策略模式定义了一系列算法，并将每个算法封装起来，使它们可以互换。策略模式使得算法可以在不影响客户端的情况下发生变化。
代码实现
java
// 策略模式：定义策略接口
interface Strategy {
void execute();
}
// 具体策略A
class ConcreteStrategyA implements Strategy {
@Override
public void execute() {
System.out.println("执行策略A");
}
}
// 上下文类，使用策略模式
class Context {
private Strategy strategy;
// 设置策略
public void setStrategy(Strategy strategy) {
this.strategy = strategy;
}
// 执行策略
public void executeStrategy() {
strategy.execute();
}
}5. 观察者模式
观察者模式定义了对象间的一对多依赖关系，使得每当一个对象改变状态，则所有依赖于它的对象都会得到通知并自动更新。
代码实现
java
// 观察者模式：定义观察者接口
interface Observer {
void update(String message);
}
// 具体观察者
class ConcreteObserver implements Observer {
@Override
public void update(String message) {
System.out.println("收到更新消息: " + message);
}
}
// 主题类，维护观察者列表
class Subject {
private List<Observer> observers = new ArrayList<>();
// 添加观察者
public void attach(Observer observer) {
observers.add(observer);
}
// 通知所有观察者
public void notifyObservers(String message) {
for (Observer observer : observers) {
observer.update(message);
}
}
}6. 工厂模式
工厂模式定义了一个创建对象的接口，让子类决定实例化哪一个类。工厂方法使得一个类的实例化延迟到其子类。
代码实现
java
// 工厂模式：定义产品接口
interface Product {
void use();
}
// 具体产品A
class ConcreteProductA implements Product {
@Override
public void use() {
System.out.println("使用产品A");
}
}
// 工厂类，创建产品
class Factory {
public static Product createProduct(String type) {
switch (type) {
case "A":
return new ConcreteProductA();
// 可以添加其他产品类型
default:
throw new IllegalArgumentException("未知的产品类型");
}
}
}总结
通过结合使用模板方法、责任链、策略、观察者和工厂模式，这个事件处理系统实现了高灵活性和可扩展性。设计模式不仅提高了代码的可维护性，还使得系统更容易适应变化的业务需求。理解并应用这些模式可以显著提高代码质量，希望本文能帮助你更好地理解这些模式及其在实际项目中的应用。