处理器实现
概述
处理器是责任链框架的核心组件,负责执行具体的业务逻辑。一个好的处理器实现应该遵循单一职责原则,具有清晰的处理逻辑和明确的终止条件。本章将详细介绍如何实现高质量的处理器。
处理器实现规范
1. 基本实现结构
classDiagram
class AbstractHandler {
<>
+handle(Context context) boolean
#doHandle(Context context) boolean*
#shouldSkip(Context context) boolean
#onBefore(Context context) void
#onAfter(Context context) void
#onError(Context context, Exception e) void
}
class ConcreteHandler {
+doHandle(Context context) boolean
+shouldSkip(Context context) boolean
-canHandle(Context context) boolean
-processRequest(Context context) void
-validateInput(Context context) boolean
}
AbstractHandler <|-- ConcreteHandler
2. 处理器实现模板
java
/**
* 处理器实现模板
* 展示了一个标准处理器的实现结构
*/
public class TemplateHandler extends AbstractHandler<RequestType, ResponseType> {
private static final Logger logger = LoggerFactory.getLogger(TemplateHandler.class);
@Override
protected boolean doHandle(Context<RequestType, ResponseType> context) {
// 1. 输入验证
if (!validateInput(context)) {
logger.warn("Input validation failed in {}", this.getClass().getSimpleName());
return false; // 验证失败,中断链
}
// 2. 检查是否能处理该请求
if (!canHandle(context)) {
logger.debug("Cannot handle request in {}", this.getClass().getSimpleName());
return true; // 不能处理,传递给下一个处理器
}
// 3. 执行具体的处理逻辑
try {
processRequest(context);
logger.info("Request processed successfully in {}", this.getClass().getSimpleName());
return true; // 处理成功,继续传递
} catch (BusinessException e) {
logger.error("Business error in {}: {}", this.getClass().getSimpleName(), e.getMessage());
handleBusinessError(context, e);
return false; // 业务异常,中断链
}
}
/**
* 验证输入参数
*/
private boolean validateInput(Context<RequestType, ResponseType> context) {
RequestType request = context.getRequest();
return request != null; // 简单的非空验证
}
/**
* 判断是否能处理该请求
*/
private boolean canHandle(Context<RequestType, ResponseType> context) {
// 根据请求类型、状态等判断是否能处理
return true;
}
/**
* 执行具体的处理逻辑
*/
private void processRequest(Context<RequestType, ResponseType> context) {
// 具体的业务逻辑实现
}
/**
* 处理业务异常
*/
private void handleBusinessError(Context<RequestType, ResponseType> context, BusinessException e) {
// 设置错误响应
ResponseType errorResponse = createErrorResponse(e.getMessage());
context.setResponse(errorResponse);
}
private ResponseType createErrorResponse(String message) {
// 创建错误响应对象
return null;
}
}
具体处理器实现示例
1. 认证处理器
java
/**
* 用户认证处理器
* 负责验证用户身份
*/
@Component
public class AuthenticationHandler extends AbstractHandler<UserRequest, UserResponse> {
private static final Logger logger = LoggerFactory.getLogger(AuthenticationHandler.class);
@Autowired
private UserService userService;
@Autowired
private TokenService tokenService;
@Override
protected boolean doHandle(Context<UserRequest, UserResponse> context) {
UserRequest request = context.getRequest();
// 1. 检查是否已经认证过
if (isAlreadyAuthenticated(context)) {
logger.debug("User already authenticated, skipping authentication");
return true;
}
// 2. 提取认证信息
String token = extractToken(request);
if (token == null) {
logger.warn("No authentication token found");
setAuthenticationError(context, "Missing authentication token");
return false;
}
// 3. 验证token
try {
User user = tokenService.validateToken(token);
if (user == null) {
logger.warn("Invalid authentication token");
setAuthenticationError(context, "Invalid authentication token");
return false;
}
// 4. 设置认证信息到上下文
context.setAttribute("authenticated_user", user);
context.setAttribute("user_id", user.getId());
context.setAttribute("user_roles", user.getRoles());
logger.info("User {} authenticated successfully", user.getUsername());
return true;
} catch (TokenExpiredException e) {
logger.warn("Authentication token expired");
setAuthenticationError(context, "Authentication token expired");
return false;
} catch (Exception e) {
logger.error("Authentication failed", e);
setAuthenticationError(context, "Authentication failed");
return false;
}
}
@Override
protected boolean shouldSkip(Context<UserRequest, ResponseType> context) {
// 如果是公开接口,跳过认证
UserRequest request = context.getRequest();
return request.isPublicEndpoint();
}
private boolean isAlreadyAuthenticated(Context<UserRequest, UserResponse> context) {
return context.getAttribute("authenticated_user") != null;
}
private String extractToken(UserRequest request) {
String authHeader = request.getHeader("Authorization");
if (authHeader != null && authHeader.startsWith("Bearer ")) {
return authHeader.substring(7);
}
return null;
}
private void setAuthenticationError(Context<UserRequest, UserResponse> context, String message) {
UserResponse response = new UserResponse();
response.setSuccess(false);
response.setErrorCode("AUTH_FAILED");
response.setErrorMessage(message);
context.setResponse(response);
}
}
2. 授权处理器
java
/**
* 用户授权处理器
* 负责检查用户权限
*/
@Component
public class AuthorizationHandler extends AbstractHandler<UserRequest, UserResponse> {
private static final Logger logger = LoggerFactory.getLogger(AuthorizationHandler.class);
@Autowired
private PermissionService permissionService;
@Override
protected boolean doHandle(Context<UserRequest, UserResponse> context) {
// 1. 获取认证用户信息
User user = context.getAttribute("authenticated_user", User.class);
if (user == null) {
logger.error("No authenticated user found, authorization cannot proceed");
setAuthorizationError(context, "User not authenticated");
return false;
}
// 2. 获取请求的资源和操作
UserRequest request = context.getRequest();
String resource = request.getResource();
String action = request.getAction();
// 3. 检查权限
try {
boolean hasPermission = permissionService.hasPermission(user, resource, action);
if (!hasPermission) {
logger.warn("User {} does not have permission to {} on {}",
user.getUsername(), action, resource);
setAuthorizationError(context, "Insufficient permissions");
return false;
}
// 4. 记录权限信息
context.setAttribute("authorized_resource", resource);
context.setAttribute("authorized_action", action);
logger.info("User {} authorized for {} on {}",
user.getUsername(), action, resource);
return true;
} catch (Exception e) {
logger.error("Authorization check failed", e);
setAuthorizationError(context, "Authorization check failed");
return false;
}
}
@Override
protected boolean shouldSkip(Context<UserRequest, UserResponse> context) {
// 如果是公开资源或者超级管理员,跳过授权检查
UserRequest request = context.getRequest();
if (request.isPublicResource()) {
return true;
}
User user = context.getAttribute("authenticated_user", User.class);
return user != null && user.isSuperAdmin();
}
private void setAuthorizationError(Context<UserRequest, UserResponse> context, String message) {
UserResponse response = new UserResponse();
response.setSuccess(false);
response.setErrorCode("AUTH_INSUFFICIENT_PERMISSIONS");
response.setErrorMessage(message);
context.setResponse(response);
}
}
3. 参数验证处理器
java
/**
* 参数验证处理器
* 负责验证请求参数的合法性
*/
@Component
public class ValidationHandler extends AbstractHandler<UserRequest, UserResponse> {
private static final Logger logger = LoggerFactory.getLogger(ValidationHandler.class);
@Autowired
private Validator validator;
@Override
protected boolean doHandle(Context<UserRequest, UserResponse> context) {
UserRequest request = context.getRequest();
// 1. 基本参数验证
List<String> errors = new ArrayList<>();
// 验证必填字段
validateRequiredFields(request, errors);
// 验证字段格式
validateFieldFormats(request, errors);
// 验证业务规则
validateBusinessRules(request, errors);
// 2. 使用Bean Validation
Set<ConstraintViolation<UserRequest>> violations = validator.validate(request);
for (ConstraintViolation<UserRequest> violation : violations) {
errors.add(violation.getMessage());
}
// 3. 检查验证结果
if (!errors.isEmpty()) {
logger.warn("Validation failed: {}", String.join(", ", errors));
setValidationError(context, errors);
return false;
}
logger.debug("Request validation passed");
return true;
}
private void validateRequiredFields(UserRequest request, List<String> errors) {
if (StringUtils.isBlank(request.getUserId())) {
errors.add("User ID is required");
}
if (StringUtils.isBlank(request.getAction())) {
errors.add("Action is required");
}
}
private void validateFieldFormats(UserRequest request, List<String> errors) {
// 验证邮箱格式
if (request.getEmail() != null && !isValidEmail(request.getEmail())) {
errors.add("Invalid email format");
}
// 验证手机号格式
if (request.getPhone() != null && !isValidPhone(request.getPhone())) {
errors.add("Invalid phone format");
}
}
private void validateBusinessRules(UserRequest request, List<String> errors) {
// 验证年龄范围
if (request.getAge() != null && (request.getAge() < 0 || request.getAge() > 150)) {
errors.add("Age must be between 0 and 150");
}
// 验证日期范围
if (request.getBirthDate() != null && request.getBirthDate().isAfter(LocalDate.now())) {
errors.add("Birth date cannot be in the future");
}
}
private boolean isValidEmail(String email) {
return email.matches("^[A-Za-z0-9+_.-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}$");
}
private boolean isValidPhone(String phone) {
return phone.matches("^1[3-9]\\d{9}$");
}
private void setValidationError(Context<UserRequest, UserResponse> context, List<String> errors) {
UserResponse response = new UserResponse();
response.setSuccess(false);
response.setErrorCode("VALIDATION_FAILED");
response.setErrorMessage("Validation failed: " + String.join(", ", errors));
response.setValidationErrors(errors);
context.setResponse(response);
}
}
4. 业务逻辑处理器
java
/**
* 业务逻辑处理器
* 负责执行核心业务逻辑
*/
@Component
public class BusinessLogicHandler extends AbstractHandler<UserRequest, UserResponse> {
private static final Logger logger = LoggerFactory.getLogger(BusinessLogicHandler.class);
@Autowired
private BusinessService businessService;
@Autowired
private AuditService auditService;
@Override
protected boolean doHandle(Context<UserRequest, UserResponse> context) {
UserRequest request = context.getRequest();
User user = context.getAttribute("authenticated_user", User.class);
try {
// 1. 记录审计日志
auditService.logBusinessOperation(user, request);
// 2. 执行业务逻辑
BusinessResult result = businessService.processRequest(request, user);
// 3. 构建响应
UserResponse response = buildSuccessResponse(result);
context.setResponse(response);
// 4. 设置处理结果到上下文
context.setAttribute("business_result", result);
context.setAttribute("processing_time", System.currentTimeMillis());
logger.info("Business logic processed successfully for user {}", user.getUsername());
return true;
} catch (BusinessException e) {
logger.error("Business logic failed: {}", e.getMessage());
setBusinessError(context, e);
return false;
} catch (Exception e) {
logger.error("Unexpected error in business logic", e);
setSystemError(context, e);
return false;
}
}
@Override
protected void onBefore(Context<UserRequest, UserResponse> context) {
// 记录开始时间
context.setAttribute("business_start_time", System.currentTimeMillis());
}
@Override
protected void onAfter(Context<UserRequest, UserResponse> context) {
// 计算处理时间
Long startTime = context.getAttribute("business_start_time", Long.class);
if (startTime != null) {
long duration = System.currentTimeMillis() - startTime;
context.setAttribute("business_duration", duration);
logger.debug("Business logic processing took {} ms", duration);
}
}
@Override
protected void onError(Context<UserRequest, UserResponse> context, Exception e) {
// 记录错误审计日志
User user = context.getAttribute("authenticated_user", User.class);
auditService.logBusinessError(user, context.getRequest(), e);
}
private UserResponse buildSuccessResponse(BusinessResult result) {
UserResponse response = new UserResponse();
response.setSuccess(true);
response.setData(result.getData());
response.setMessage("Operation completed successfully");
return response;
}
private void setBusinessError(Context<UserRequest, UserResponse> context, BusinessException e) {
UserResponse response = new UserResponse();
response.setSuccess(false);
response.setErrorCode(e.getErrorCode());
response.setErrorMessage(e.getMessage());
context.setResponse(response);
}
private void setSystemError(Context<UserRequest, UserResponse> context, Exception e) {
UserResponse response = new UserResponse();
response.setSuccess(false);
response.setErrorCode("SYSTEM_ERROR");
response.setErrorMessage("System error occurred");
context.setResponse(response);
}
}
处理逻辑实现要点
1. 输入验证
java
public class InputValidationExample {
/**
* 多层次输入验证
*/
private boolean validateInput(Context context) {
// 1. 空值检查
if (context.getRequest() == null) {
return false;
}
// 2. 类型检查
if (!(context.getRequest() instanceof ExpectedType)) {
return false;
}
// 3. 业务规则验证
return validateBusinessRules(context.getRequest());
}
/**
* 使用断言进行验证
*/
private void validateWithAssertions(UserRequest request) {
Assert.notNull(request, "Request cannot be null");
Assert.hasText(request.getUserId(), "User ID cannot be empty");
Assert.isTrue(request.getAge() >= 0, "Age cannot be negative");
}
}
2. 异常处理策略
java
public class ExceptionHandlingExample {
@Override
protected boolean doHandle(Context context) {
try {
return processRequest(context);
} catch (ValidationException e) {
// 验证异常 - 记录警告并返回错误
logger.warn("Validation failed: {}", e.getMessage());
setValidationError(context, e.getMessage());
return false;
} catch (BusinessException e) {
// 业务异常 - 记录错误并返回业务错误
logger.error("Business error: {}", e.getMessage());
setBusinessError(context, e);
return false;
} catch (SystemException e) {
// 系统异常 - 记录错误并重新抛出
logger.error("System error", e);
throw e;
} catch (Exception e) {
// 未知异常 - 包装后重新抛出
logger.error("Unexpected error", e);
throw new ChainExecutionException("Unexpected error in handler", e);
}
}
}
3. 性能监控
java
public class PerformanceMonitoringExample {
@Override
protected boolean doHandle(Context context) {
long startTime = System.currentTimeMillis();
try {
boolean result = processRequest(context);
// 记录成功处理的性能指标
long duration = System.currentTimeMillis() - startTime;
recordPerformanceMetrics(context, duration, true);
return result;
} catch (Exception e) {
// 记录失败处理的性能指标
long duration = System.currentTimeMillis() - startTime;
recordPerformanceMetrics(context, duration, false);
throw e;
}
}
private void recordPerformanceMetrics(Context context, long duration, boolean success) {
String handlerName = this.getClass().getSimpleName();
// 记录到监控系统
MetricsCollector.recordHandlerDuration(handlerName, duration);
MetricsCollector.recordHandlerResult(handlerName, success);
// 记录到上下文
context.setAttribute(handlerName + "_duration", duration);
context.setAttribute(handlerName + "_success", success);
}
}
终止条件判断
1. 基于返回值的终止
java
public class ReturnBasedTermination {
@Override
protected boolean doHandle(Context context) {
// 处理成功,继续链
if (processSuccessfully(context)) {
return true;
}
// 处理失败,终止链
return false;
}
}
2. 基于上下文状态的终止
java
public class ContextBasedTermination {
@Override
protected boolean doHandle(Context context) {
processRequest(context);
// 检查上下文中的终止标志
Boolean shouldTerminate = context.getAttribute("terminate_chain", Boolean.class);
return !Boolean.TRUE.equals(shouldTerminate);
}
}
3. 基于异常的终止
java
public class ExceptionBasedTermination {
@Override
protected boolean doHandle(Context context) {
try {
processRequest(context);
return true;
} catch (TerminateChainException e) {
// 特定异常表示需要终止链
logger.info("Chain terminated by handler: {}", e.getMessage());
return false;
}
}
}
最佳实践
1. 单一职责
java
// 好的实践:职责单一
public class AuthenticationHandler extends AbstractHandler {
// 只负责认证逻辑
}
public class AuthorizationHandler extends AbstractHandler {
// 只负责授权逻辑
}
// 不好的实践:职责混合
public class AuthHandler extends AbstractHandler {
// 既负责认证又负责授权,职责不清
}
2. 状态无关
java
// 好的实践:无状态处理器
public class StatelessHandler extends AbstractHandler {
// 不保存实例状态,线程安全
@Override
protected boolean doHandle(Context context) {
// 所有数据都从context获取
return true;
}
}
// 不好的实践:有状态处理器
public class StatefulHandler extends AbstractHandler {
private String lastProcessedId; // 实例状态,线程不安全
@Override
protected boolean doHandle(Context context) {
lastProcessedId = context.getRequest().getId();
return true;
}
}
3. 错误处理
java
public class ProperErrorHandling extends AbstractHandler {
@Override
protected boolean doHandle(Context context) {
try {
return processRequest(context);
} catch (RecoverableException e) {
// 可恢复异常,记录日志并继续
logger.warn("Recoverable error: {}", e.getMessage());
return true;
} catch (FatalException e) {
// 致命异常,记录日志并终止
logger.error("Fatal error: {}", e.getMessage());
setErrorResponse(context, e);
return false;
}
}
}
总结
处理器实现是责任链框架的核心,需要遵循以下原则:
- 单一职责:每个处理器只负责一个特定的功能
- 状态无关:处理器应该是无状态的,确保线程安全
- 明确终止:清晰地定义何时继续传递,何时终止链
- 异常处理:合理处理各种异常情况
- 性能监控:记录处理时间和结果,便于性能分析
- 日志记录:提供详细的日志信息,便于问题排查
在下一章中,我们将介绍如何使用构建器模式来优雅地构建责任链。