手搓责任链框架 3：处理器实现

杨杨杨大侠2025-09-03 10:23

处理器实现

概述

处理器是责任链框架的核心组件，负责执行具体的业务逻辑。一个好的处理器实现应该遵循单一职责原则，具有清晰的处理逻辑和明确的终止条件。本章将详细介绍如何实现高质量的处理器。

处理器实现规范

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;
        }
    }
}

总结

处理器实现是责任链框架的核心，需要遵循以下原则：

  1. 单一职责：每个处理器只负责一个特定的功能
  2. 状态无关：处理器应该是无状态的，确保线程安全
  3. 明确终止：清晰地定义何时继续传递，何时终止链
  4. 异常处理：合理处理各种异常情况
  5. 性能监控：记录处理时间和结果，便于性能分析
  6. 日志记录：提供详细的日志信息，便于问题排查

在下一章中，我们将介绍如何使用构建器模式来优雅地构建责任链。

相关推荐
舒一笑8 分钟前
PandaCoder 1.1.8 发布：中文开发者的智能编码助手全面升级
java·后端·intellij idea
这周也會开心11 分钟前
Spring-MVC
java·spring·mvc
SimonKing14 分钟前
跨域，总在发OPTIONS请求？这次终于搞懂CORS预检了
java·后端·程序员
考虑考虑35 分钟前
dubbo3超时时间延长
java·后端·dubbo
boy快快长大43 分钟前
【Spring AI】简单入门（一）
java·人工智能·spring
Rhys..1 小时前
Git & GitHub 个人账户创建教程
git·github
失散131 小时前
分布式专题——15 ZooKeeper特性与节点数据类型详解
java·分布式·zookeeper·云原生·架构
ThisIsMirror1 小时前
Spring的三级缓存如何解决单例Bean循环依赖
java·spring·缓存
菠菠萝宝1 小时前
【Java八股文】12-分布式面试篇
java·分布式·zookeeper·面试·seata·redisson
yk100101 小时前
Spring DefaultSingletonBeanRegistry
java·后端·spring
热门推荐
01UV 工具安装与国内镜像源配置指南02GitHub 镜像站点03Spec-Kit 使用指南04UV安装并设置国内源0546个Nano-banana 精选提示词，持续更新中062025年华为杯研赛数学建模竞赛C题完整参考论文 （含模型、MATLAB和Python代码）07保姆级教程：手把手教你用Dify实现完美多轮对话（附Chatflow和提示词）08KGG转MP3工具|非KGM文件|解密音频09Linux下V2Ray安装配置指南10jdk21下载、安装（Windows、Linux、macOS）