链式构建
概述
链式构建是责任链框架中的重要组成部分，它提供了一种优雅、灵活的方式来组装责任链。通过应用构建器模式，我们可以实现流式API，使得责任链的构建更加直观和易用。本章将详细介绍如何设计和实现链式构建器。
构建器模式应用
1. 构建器模式的优势
graph TD
A[客户端代码] --> B[ChainBuilder]
B --> C[添加处理器]
C --> D[配置处理器]
D --> E[构建责任链]
E --> F[返回链头节点]
G[传统方式] --> H[手动设置next]
H --> I[容易出错]
I --> J[代码冗长]
B --> K[流式API]
K --> L[类型安全]
L --> M[易于维护]
构建器模式的优势：
- 流式API：支持链式调用，代码更加简洁
- 类型安全：编译时检查，减少运行时错误
- 灵活配置：支持动态添加、删除、重排序处理器
- 易于测试：可以轻松构建测试用的责任链
2. 基本构建器接口
java
/**
* 责任链构建器接口
* 提供流式API来构建责任链
*/
public interface ChainBuilder<T, R> {
/**
* 添加处理器到链的末尾
* @param handler 处理器实例
* @return 构建器实例，支持链式调用
*/
ChainBuilder<T, R> addHandler(Handler handler);
/**
* 添加处理器类型，由构建器负责实例化
* @param handlerClass 处理器类
* @return 构建器实例，支持链式调用
*/
ChainBuilder<T, R> addHandler(Class<? extends Handler> handlerClass);
/**
* 在指定位置插入处理器
* @param index 插入位置
* @param handler 处理器实例
* @return 构建器实例，支持链式调用
*/
ChainBuilder<T, R> insertHandler(int index, Handler handler);
/**
* 移除指定的处理器
* @param handler 要移除的处理器
* @return 构建器实例，支持链式调用
*/
ChainBuilder<T, R> removeHandler(Handler handler);
/**
* 移除指定位置的处理器
* @param index 要移除的位置
* @return 构建器实例，支持链式调用
*/
ChainBuilder<T, R> removeHandler(int index);
/**
* 移除指定类型的所有处理器
* @param handlerClass 处理器类型
* @return 构建器实例，支持链式调用
*/
ChainBuilder<T, R> removeHandlers(Class<? extends Handler> handlerClass);
/**
* 清空所有处理器
* @return 构建器实例，支持链式调用
*/
ChainBuilder<T, R> clear();
/**
* 构建责任链
* @return 责任链的头节点
*/
Handler build();
/**
* 获取当前链中的处理器数量
* @return 处理器数量
*/
int size();
/**
* 判断链是否为空
* @return true表示为空，false表示不为空
*/
boolean isEmpty();
}链式API设计
1. 基础链式构建器实现
java
/**
* 默认的责任链构建器实现
* @param <T> 请求类型
* @param <R> 响应类型
*/
public class DefaultChainBuilder<T, R> implements ChainBuilder<T, R> {
private final List<Handler> handlers;
private final HandlerFactory handlerFactory;
private static final Logger logger = LoggerFactory.getLogger(DefaultChainBuilder.class);
public DefaultChainBuilder() {
this.handlers = new ArrayList<>();
this.handlerFactory = new DefaultHandlerFactory();
}
public DefaultChainBuilder(HandlerFactory handlerFactory) {
this.handlers = new ArrayList<>();
this.handlerFactory = handlerFactory;
}
@Override
public ChainBuilder<T, R> addHandler(Handler handler) {
if (handler == null) {
throw new IllegalArgumentException("Handler cannot be null");
}
handlers.add(handler);
logger.debug("Added handler: {}", handler.getClass().getSimpleName());
return this;
}
@Override
public ChainBuilder<T, R> addHandler(Class<? extends Handler> handlerClass) {
if (handlerClass == null) {
throw new IllegalArgumentException("Handler class cannot be null");
}
Handler handler = handlerFactory.createHandler(handlerClass);
return addHandler(handler);
}
@Override
public ChainBuilder<T, R> insertHandler(int index, Handler handler) {
if (handler == null) {
throw new IllegalArgumentException("Handler cannot be null");
}
if (index < 0 || index > handlers.size()) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + handlers.size());
}
handlers.add(index, handler);
logger.debug("Inserted handler at index {}: {}", index, handler.getClass().getSimpleName());
return this;
}
@Override
public ChainBuilder<T, R> removeHandler(Handler handler) {
if (handlers.remove(handler)) {
logger.debug("Removed handler: {}", handler.getClass().getSimpleName());
}
return this;
}
@Override
public ChainBuilder<T, R> removeHandler(int index) {
if (index < 0 || index >= handlers.size()) {
throw new IndexOutOfBoundsException("Index: " + index + ", Size: " + handlers.size());
}
Handler removed = handlers.remove(index);
logger.debug("Removed handler at index {}: {}", index, removed.getClass().getSimpleName());
return this;
}
@Override
public ChainBuilder<T, R> removeHandlers(Class<? extends Handler> handlerClass) {
handlers.removeIf(handler -> handlerClass.isInstance(handler));
logger.debug("Removed all handlers of type: {}", handlerClass.getSimpleName());
return this;
}
@Override
public ChainBuilder<T, R> clear() {
handlers.clear();
logger.debug("Cleared all handlers");
return this;
}
@Override
public Handler build() {
if (handlers.isEmpty()) {
logger.warn("Building empty chain");
return new EmptyHandler();
}
// 链接所有处理器
for (int i = 0; i < handlers.size() - 1; i++) {
handlers.get(i).setNext(handlers.get(i + 1));
}
Handler head = handlers.get(0);
logger.info("Built chain with {} handlers", handlers.size());
return head;
}
@Override
public int size() {
return handlers.size();
}
@Override
public boolean isEmpty() {
return handlers.isEmpty();
}
/**
* 获取处理器列表的副本
* @return 处理器列表副本
*/
public List<Handler> getHandlers() {
return new ArrayList<>(handlers);
}
}2. 高级链式构建器
java
/**
* 高级责任链构建器
* 提供更多高级功能，如条件添加、批量操作等
*/
public class AdvancedChainBuilder<T, R> extends DefaultChainBuilder<T, R> {
private final Map<String, Object> properties;
public AdvancedChainBuilder() {
super();
this.properties = new HashMap<>();
}
/**
* 条件性添加处理器
* @param condition 条件
* @param handler 处理器
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> addHandlerIf(boolean condition, Handler handler) {
if (condition) {
addHandler(handler);
}
return this;
}
/**
* 条件性添加处理器
* @param condition 条件供应商
* @param handler 处理器
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> addHandlerIf(Supplier<Boolean> condition, Handler handler) {
if (condition.get()) {
addHandler(handler);
}
return this;
}
/**
* 批量添加处理器
* @param handlers 处理器数组
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> addHandlers(Handler... handlers) {
for (Handler handler : handlers) {
addHandler(handler);
}
return this;
}
/**
* 批量添加处理器类型
* @param handlerClasses 处理器类型数组
* @return 构建器实例
*/
@SafeVarargs
public final AdvancedChainBuilder<T, R> addHandlers(Class<? extends Handler>... handlerClasses) {
for (Class<? extends Handler> handlerClass : handlerClasses) {
addHandler(handlerClass);
}
return this;
}
/**
* 从集合添加处理器
* @param handlers 处理器集合
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> addHandlers(Collection<Handler> handlers) {
for (Handler handler : handlers) {
addHandler(handler);
}
return this;
}
/**
* 设置构建器属性
* @param key 属性键
* @param value 属性值
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> setProperty(String key, Object value) {
properties.put(key, value);
return this;
}
/**
* 获取构建器属性
* @param key 属性键
* @return 属性值
*/
public Object getProperty(String key) {
return properties.get(key);
}
/**
* 根据条件过滤处理器
* @param predicate 过滤条件
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> filterHandlers(Predicate<Handler> predicate) {
List<Handler> currentHandlers = getHandlers();
clear();
currentHandlers.stream()
.filter(predicate)
.forEach(this::addHandler);
return this;
}
/**
* 对处理器进行排序
* @param comparator 比较器
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> sortHandlers(Comparator<Handler> comparator) {
List<Handler> currentHandlers = getHandlers();
currentHandlers.sort(comparator);
clear();
addHandlers(currentHandlers);
return this;
}
/**
* 在指定处理器之前插入新处理器
* @param targetHandler 目标处理器
* @param newHandler 新处理器
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> insertBefore(Handler targetHandler, Handler newHandler) {
List<Handler> currentHandlers = getHandlers();
int index = currentHandlers.indexOf(targetHandler);
if (index >= 0) {
insertHandler(index, newHandler);
}
return this;
}
/**
* 在指定处理器之后插入新处理器
* @param targetHandler 目标处理器
* @param newHandler 新处理器
* @return 构建器实例
*/
public AdvancedChainBuilder<T, R> insertAfter(Handler targetHandler, Handler newHandler) {
List<Handler> currentHandlers = getHandlers();
int index = currentHandlers.indexOf(targetHandler);
if (index >= 0 && index < currentHandlers.size() - 1) {
insertHandler(index + 1, newHandler);
} else if (index == currentHandlers.size() - 1) {
addHandler(newHandler);
}
return this;
}
}动态添加处理器
1. 处理器工厂
java
/**
* 处理器工厂接口
* 负责创建处理器实例
*/
public interface HandlerFactory {
/**
* 根据类型创建处理器
* @param handlerClass 处理器类型
* @return 处理器实例
*/
Handler createHandler(Class<? extends Handler> handlerClass);
/**
* 根据名称创建处理器
* @param handlerName 处理器名称
* @return 处理器实例
*/
Handler createHandler(String handlerName);
/**
* 注册处理器类型
* @param name 处理器名称
* @param handlerClass 处理器类型
*/
void registerHandler(String name, Class<? extends Handler> handlerClass);
}
/**
* 默认处理器工厂实现
*/
public class DefaultHandlerFactory implements HandlerFactory {
private final Map<String, Class<? extends Handler>> handlerRegistry;
private static final Logger logger = LoggerFactory.getLogger(DefaultHandlerFactory.class);
public DefaultHandlerFactory() {
this.handlerRegistry = new ConcurrentHashMap<>();
registerDefaultHandlers();
}
@Override
public Handler createHandler(Class<? extends Handler> handlerClass) {
try {
Constructor<? extends Handler> constructor = handlerClass.getDeclaredConstructor();
constructor.setAccessible(true);
Handler handler = constructor.newInstance();
logger.debug("Created handler: {}", handlerClass.getSimpleName());
return handler;
} catch (Exception e) {
throw new HandlerCreationException("Failed to create handler: " + handlerClass.getName(), e);
}
}
@Override
public Handler createHandler(String handlerName) {
Class<? extends Handler> handlerClass = handlerRegistry.get(handlerName);
if (handlerClass == null) {
throw new HandlerCreationException("Unknown handler: " + handlerName);
}
return createHandler(handlerClass);
}
@Override
public void registerHandler(String name, Class<? extends Handler> handlerClass) {
handlerRegistry.put(name, handlerClass);
logger.info("Registered handler: {} -> {}", name, handlerClass.getName());
}
private void registerDefaultHandlers() {
// 注册默认的处理器类型
registerHandler("auth", AuthenticationHandler.class);
registerHandler("validation", ValidationHandler.class);
registerHandler("business", BusinessLogicHandler.class);
}
}2. Spring集成的处理器工厂
java
/**
* Spring集成的处理器工厂
* 利用Spring容器来创建和管理处理器
*/
@Component
public class SpringHandlerFactory implements HandlerFactory, ApplicationContextAware {
private ApplicationContext applicationContext;
private final Map<String, Class<? extends Handler>> handlerRegistry;
public SpringHandlerFactory() {
this.handlerRegistry = new ConcurrentHashMap<>();
}
@Override
public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
this.applicationContext = applicationContext;
scanAndRegisterHandlers();
}
@Override
public Handler createHandler(Class<? extends Handler> handlerClass) {
try {
// 尝试从Spring容器获取
return applicationContext.getBean(handlerClass);
} catch (NoSuchBeanDefinitionException e) {
// 如果容器中没有，则手动创建
return createHandlerManually(handlerClass);
}
}
@Override
public Handler createHandler(String handlerName) {
try {
// 尝试从Spring容器获取
return applicationContext.getBean(handlerName, Handler.class);
} catch (NoSuchBeanDefinitionException e) {
// 如果容器中没有，则查找注册的类型
Class<? extends Handler> handlerClass = handlerRegistry.get(handlerName);
if (handlerClass != null) {
return createHandler(handlerClass);
}
throw new HandlerCreationException("Unknown handler: " + handlerName);
}
}
@Override
public void registerHandler(String name, Class<? extends Handler> handlerClass) {
handlerRegistry.put(name, handlerClass);
}
private Handler createHandlerManually(Class<? extends Handler> handlerClass) {
try {
Constructor<? extends Handler> constructor = handlerClass.getDeclaredConstructor();
constructor.setAccessible(true);
Handler handler = constructor.newInstance();
// 如果是Spring Bean，进行依赖注入
applicationContext.getAutowireCapableBeanFactory().autowireBean(handler);
return handler;
} catch (Exception e) {
throw new HandlerCreationException("Failed to create handler: " + handlerClass.getName(), e);
}
}
private void scanAndRegisterHandlers() {
// 扫描所有Handler类型的Bean
Map<String, Handler> handlerBeans = applicationContext.getBeansOfType(Handler.class);
for (Map.Entry<String, Handler> entry : handlerBeans.entrySet()) {
String beanName = entry.getKey();
Class<? extends Handler> handlerClass = entry.getValue().getClass();
registerHandler(beanName, handlerClass);
}
}
}3. 配置驱动的链构建
java
/**
* 配置驱动的链构建器
* 支持从配置文件或数据库加载链配置
*/
public class ConfigurableChainBuilder<T, R> extends AdvancedChainBuilder<T, R> {
private final HandlerFactory handlerFactory;
public ConfigurableChainBuilder(HandlerFactory handlerFactory) {
super();
this.handlerFactory = handlerFactory;
}
/**
* 从配置加载链
* @param config 链配置
* @return 构建器实例
*/
public ConfigurableChainBuilder<T, R> loadFromConfig(ChainConfig config) {
clear();
for (HandlerConfig handlerConfig : config.getHandlers()) {
Handler handler = createHandlerFromConfig(handlerConfig);
addHandler(handler);
}
return this;
}
/**
* 从JSON配置加载链
* @param jsonConfig JSON配置字符串
* @return 构建器实例
*/
public ConfigurableChainBuilder<T, R> loadFromJson(String jsonConfig) {
try {
ObjectMapper mapper = new ObjectMapper();
ChainConfig config = mapper.readValue(jsonConfig, ChainConfig.class);
return loadFromConfig(config);
} catch (Exception e) {
throw new ChainConfigurationException("Failed to load chain from JSON", e);
}
}
/**
* 从YAML配置加载链
* @param yamlConfig YAML配置字符串
* @return 构建器实例
*/
public ConfigurableChainBuilder<T, R> loadFromYaml(String yamlConfig) {
try {
ObjectMapper mapper = new ObjectMapper(new YAMLFactory());
ChainConfig config = mapper.readValue(yamlConfig, ChainConfig.class);
return loadFromConfig(config);
} catch (Exception e) {
throw new ChainConfigurationException("Failed to load chain from YAML", e);
}
}
private Handler createHandlerFromConfig(HandlerConfig handlerConfig) {
Handler handler;
if (handlerConfig.getClassName() != null) {
try {
Class<? extends Handler> handlerClass =
(Class<? extends Handler>) Class.forName(handlerConfig.getClassName());
handler = handlerFactory.createHandler(handlerClass);
} catch (ClassNotFoundException e) {
throw new ChainConfigurationException("Handler class not found: " + handlerConfig.getClassName(), e);
}
} else if (handlerConfig.getName() != null) {
handler = handlerFactory.createHandler(handlerConfig.getName());
} else {
throw new ChainConfigurationException("Handler configuration must specify either className or name");
}
// 设置处理器属性
setHandlerProperties(handler, handlerConfig.getProperties());
return handler;
}
private void setHandlerProperties(Handler handler, Map<String, Object> properties) {
if (properties == null || properties.isEmpty()) {
return;
}
// 使用反射设置属性
Class<?> handlerClass = handler.getClass();
for (Map.Entry<String, Object> entry : properties.entrySet()) {
try {
Field field = handlerClass.getDeclaredField(entry.getKey());
field.setAccessible(true);
field.set(handler, entry.getValue());
} catch (Exception e) {
logger.warn("Failed to set property {} on handler {}",
entry.getKey(), handlerClass.getSimpleName(), e);
}
}
}
}使用示例
1. 基本使用
java
public class BasicChainBuildingExample {
public void buildBasicChain() {
// 使用流式API构建链
Handler chain = new DefaultChainBuilder<UserRequest, UserResponse>()
.addHandler(new AuthenticationHandler())
.addHandler(new ValidationHandler())
.addHandler(new BusinessLogicHandler())
.build();
// 执行链
Context<UserRequest, UserResponse> context =
new DefaultContext<>(new UserRequest());
chain.handle(context);
}
}2. 高级使用
java
public class AdvancedChainBuildingExample {
public void buildAdvancedChain() {
boolean enableAuth = true;
boolean enableValidation = false;
Handler chain = new AdvancedChainBuilder<UserRequest, UserResponse>()
// 条件性添加处理器
.addHandlerIf(enableAuth, new AuthenticationHandler())
.addHandlerIf(enableValidation, new ValidationHandler())
// 批量添加处理器
.addHandlers(
new AuthorizationHandler(),
new BusinessLogicHandler(),
new AuditHandler()
)
// 设置属性
.setProperty("environment", "production")
.setProperty("debug", false)
// 过滤处理器
.filterHandlers(handler -> !(handler instanceof AuditHandler))
.build();
}
}3. 配置驱动使用
yaml
# chain-config.yaml
handlers:
- name: "auth"
properties:
timeout: 5000
retries: 3
- className: "com.example.ValidationHandler"
properties:
strict: true
- name: "business"
java
public class ConfigDrivenChainExample {
public void buildFromConfig() {
HandlerFactory factory = new SpringHandlerFactory();
Handler chain = new ConfigurableChainBuilder<UserRequest, UserResponse>(factory)
.loadFromYaml(loadYamlConfig())
.build();
}
private String loadYamlConfig() {
// 从文件或资源加载YAML配置
return "...";
}
}4. 动态链构建
java
public class DynamicChainExample {
public void buildDynamicChain() {
AdvancedChainBuilder<UserRequest, UserResponse> builder =
new AdvancedChainBuilder<>();
// 根据运行时条件动态添加处理器
if (isProductionEnvironment()) {
builder.addHandler(new SecurityHandler())
.addHandler(new AuditHandler());
}
if (isDebugMode()) {
builder.addHandler(new DebugHandler());
}
// 根据用户角色添加不同的处理器
String userRole = getCurrentUserRole();
switch (userRole) {
case "ADMIN":
builder.addHandler(new AdminHandler());
break;
case "USER":
builder.addHandler(new UserHandler());
break;
default:
builder.addHandler(new GuestHandler());
}
Handler chain = builder.build();
}
private boolean isProductionEnvironment() {
return "production".equals(System.getProperty("environment"));
}
private boolean isDebugMode() {
return Boolean.parseBoolean(System.getProperty("debug"));
}
private String getCurrentUserRole() {
// 获取当前用户角色
return "USER";
}
}最佳实践
1. 构建器复用
java
public class ChainBuilderReuse {
// 创建可复用的构建器模板
public static ChainBuilder<UserRequest, UserResponse> createBaseBuilder() {
return new AdvancedChainBuilder<UserRequest, UserResponse>()
.addHandler(new AuthenticationHandler())
.addHandler(new ValidationHandler());
}
// 基于模板创建特定的链
public Handler createUserChain() {
return createBaseBuilder()
.addHandler(new UserBusinessHandler())
.build();
}
public Handler createAdminChain() {
return createBaseBuilder()
.addHandler(new AdminBusinessHandler())
.addHandler(new AuditHandler())
.build();
}
}2. 链验证
java
public class ChainValidation {
public static void validateChain(ChainBuilder builder) {
if (builder.isEmpty()) {
throw new IllegalStateException("Chain cannot be empty");
}
List<Handler> handlers = ((AdvancedChainBuilder) builder).getHandlers();
// 检查必需的处理器
boolean hasAuth = handlers.stream()
.anyMatch(h -> h instanceof AuthenticationHandler);
if (!hasAuth) {
throw new IllegalStateException("Chain must contain AuthenticationHandler");
}
// 检查处理器顺序
int authIndex = findHandlerIndex(handlers, AuthenticationHandler.class);
int businessIndex = findHandlerIndex(handlers, BusinessLogicHandler.class);
if (authIndex > businessIndex) {
throw new IllegalStateException("AuthenticationHandler must come before BusinessLogicHandler");
}
}
private static int findHandlerIndex(List<Handler> handlers, Class<?> handlerClass) {
for (int i = 0; i < handlers.size(); i++) {
if (handlerClass.isInstance(handlers.get(i))) {
return i;
}
}
return -1;
}
}3. 性能优化
java
public class PerformanceOptimization {
// 使用对象池减少创建开销
private static final ObjectPool<DefaultChainBuilder> BUILDER_POOL =
new GenericObjectPool<>(new ChainBuilderFactory());
public static ChainBuilder borrowBuilder() {
try {
return BUILDER_POOL.borrowObject();
} catch (Exception e) {
return new DefaultChainBuilder();
}
}
public static void returnBuilder(ChainBuilder builder) {
try {
builder.clear(); // 清理状态
BUILDER_POOL.returnObject((DefaultChainBuilder) builder);
} catch (Exception e) {
// 忽略归还失败
}
}
// 缓存常用的链
private static final Map<String, Handler> CHAIN_CACHE = new ConcurrentHashMap<>();
public static Handler getCachedChain(String chainType) {
return CHAIN_CACHE.computeIfAbsent(chainType, type -> {
switch (type) {
case "user":
return createUserChain();
case "admin":
return createAdminChain();
default:
return createDefaultChain();
}
});
}
}总结
链式构建是责任链框架的重要特性，它提供了：
- 流式API：使链的构建更加直观和易读
- 灵活配置：支持动态添加、删除、重排序处理器
- 类型安全：编译时检查，减少运行时错误
- 配置驱动：支持从外部配置文件加载链定义
- Spring集成：与Spring框架无缝集成
通过合理使用构建器模式，我们可以创建出既强大又易用的责任链框架。在下一章中，我们将详细介绍责任链的执行流程。