Oct 18 2022

Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别脏乱差的错误处理方式

作者： 绝缘体..   发布： 2022-10-18 10:44   分类： 未分类   阅读：   抢沙发  
 
更多

Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现

引言

在现代微服务架构中，异常处理是保证系统稳定性和用户体验的关键环节。一个良好的异常处理机制不仅能帮助开发者快速定位问题，还能为用户提供友好的错误信息。然而，在实际开发过程中，很多团队往往采用简单粗暴的异常处理方式，导致代码混乱、维护困难、用户体验差等问题。

本文将深入探讨Spring Boot微服务中的异常处理机制，从@ControllerAdvice统一异常处理到自定义异常体系设计，提供完整的异常处理解决方案。我们将重点介绍异常日志记录、错误码规范、响应格式标准化等核心内容，帮助开发者告别脏乱差的错误处理方式。

一、微服务异常处理面临的挑战

1.1 异常处理的复杂性

在微服务架构中，服务间调用频繁，异常可能出现在任何环节。传统的异常处理方式往往存在以下问题：

  • 分散处理：每个Controller都独立处理异常，代码重复冗余
  • 缺乏规范：不同服务的异常处理方式不一致，难以维护
  • 用户体验差：错误信息不统一，用户无法获得清晰的反馈
  • 调试困难：缺少统一的日志记录和监控机制

1.2 微服务架构的特殊需求

微服务架构对异常处理提出了更高的要求：

  • 服务间通信异常：需要处理远程调用失败、超时等问题
  • 分布式事务异常：需要考虑事务回滚和补偿机制
  • 统一监控告警：需要集中化的异常监控和告警
  • API标准化：需要统一的错误响应格式

二、统一异常处理框架设计思路

2.1 核心设计理念

构建统一异常处理框架的核心理念是：

  1. 集中化管理：通过@ControllerAdvice统一处理所有异常
  2. 标准化输出：统一的错误响应格式和错误码规范
  3. 可扩展性：支持自定义异常类型和处理逻辑
  4. 可维护性：清晰的代码结构和文档说明

2.2 架构设计图

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Controller    │    │  Service Layer  │    │  Repository     │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────┬───────────────┘                       │
                 │                                       │
         ┌─────────────────┐                    ┌─────────────────┐
         │   Exception     │                    │   Exception     │
         │   Handler       │                    │   Handler       │
         └─────────────────┘                    └─────────────────┘
                 │                                       │
         ┌─────────────────┐                    ┌─────────────────┐
         │   Global        │                    │   Custom        │
         │   Exception     │                    │   Exception     │
         │   Handler       │                    │   Handler       │
         └─────────────────┘                    └─────────────────┘
                 │                                       │
         ┌─────────────────┐                    ┌─────────────────┐
         │   Error Response│                    │   Error Code    │
         │   Builder       │                    │   Manager       │
         └─────────────────┘                    └─────────────────┘
                 │                                       │
         ┌─────────────────┐                    ┌─────────────────┐
         │   Log Manager   │                    │   Monitor       │
         │   (Optional)    │                    │   Service       │
         └─────────────────┘                    └─────────────────┘

三、基础异常类设计

3.1 自定义异常基类

/**
 * 自定义业务异常基类
 */
public abstract class BaseException extends RuntimeException {
    
    private static final long serialVersionUID = 1L;
    
    /**
     * 错误码
     */
    private final String code;
    
    /**
     * 错误信息
     */
    private final String message;
    
    /**
     * 原始异常
     */
    private final Throwable cause;
    
    public BaseException(String code, String message) {
        this(code, message, null);
    }
    
    public BaseException(String code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
        this.message = message;
        this.cause = cause;
    }
    
    public BaseException(String code, String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace) {
        super(message, cause, enableSuppression, writableStackTrace);
        this.code = code;
        this.message = message;
        this.cause = cause;
    }
    
    // Getters
    public String getCode() {
        return code;
    }
    
    @Override
    public String getMessage() {
        return message;
    }
    
    @Override
    public Throwable getCause() {
        return cause;
    }
}

3.2 通用业务异常

/**
 * 通用业务异常
 */
public class BusinessException extends BaseException {
    
    public BusinessException(String code, String message) {
        super(code, message);
    }
    
    public BusinessException(String code, String message, Throwable cause) {
        super(code, message, cause);
    }
}

3.3 参数校验异常

/**
 * 参数校验异常
 */
public class ValidationException extends BaseException {
    
    public ValidationException(String code, String message) {
        super(code, message);
    }
    
    public ValidationException(String code, String message, Throwable cause) {
        super(code, message, cause);
    }
}

3.4 系统异常

/**
 * 系统异常
 */
public class SystemException extends BaseException {
    
    public SystemException(String code, String message) {
        super(code, message);
    }
    
    public SystemException(String code, String message, Throwable cause) {
        super(code, message, cause);
    }
}

四、统一异常处理器实现

4.1 全局异常处理器

/**
 * 全局异常处理器
 */
@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    
    /**
     * 处理自定义业务异常
     */
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException ex) {
        log.warn("业务异常: {}", ex.getMessage(), ex);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
                .code(ex.getCode())
                .message(ex.getMessage())
                .timestamp(LocalDateTime.now())
                .build();
                
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    /**
     * 处理参数校验异常
     */
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(ValidationException ex) {
        log.warn("参数校验异常: {}", ex.getMessage(), ex);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
                .code(ex.getCode())
                .message(ex.getMessage())
                .timestamp(LocalDateTime.now())
                .build();
                
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    /**
     * 处理方法参数验证异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleMethodArgumentNotValidException(
            MethodArgumentNotValidException ex) {
        log.warn("参数验证失败: {}", ex.getMessage());
        
        StringBuilder errorMessage = new StringBuilder();
        ex.getBindingResult().getFieldErrors().forEach(error -> 
            errorMessage.append(error.getField()).append(": ").append(error.getDefaultMessage()).append("; ")
        );
        
        ErrorResponse errorResponse = ErrorResponse.builder()
                .code("VALIDATION_ERROR")
                .message(errorMessage.toString())
                .timestamp(LocalDateTime.now())
                .build();
                
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    /**
     * 处理请求参数类型转换异常
     */
    @ExceptionHandler(TypeMismatchException.class)
    public ResponseEntity<ErrorResponse> handleTypeMismatchException(TypeMismatchException ex) {
        log.warn("参数类型转换异常: {}", ex.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
                .code("TYPE_MISMATCH_ERROR")
                .message("参数类型不匹配: " + ex.getMessage())
                .timestamp(LocalDateTime.now())
                .build();
                
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    /**
     * 处理资源未找到异常
     */
    @ExceptionHandler(NoSuchElementException.class)
    public ResponseEntity<ErrorResponse> handleNoSuchElementException(NoSuchElementException ex) {
        log.warn("资源未找到: {}", ex.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
                .code("RESOURCE_NOT_FOUND")
                .message("请求的资源不存在")
                .timestamp(LocalDateTime.now())
                .build();
                
        return ResponseEntity.status(HttpStatus.NOT_FOUND).body(errorResponse);
    }
    
    /**
     * 处理系统异常
     */
    @ExceptionHandler(SystemException.class)
    public ResponseEntity<ErrorResponse> handleSystemException(SystemException ex) {
        log.error("系统异常: {}", ex.getMessage(), ex);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
                .code(ex.getCode())
                .message("系统内部错误，请稍后重试")
                .timestamp(LocalDateTime.now())
                .build();
                
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
    
    /**
     * 处理所有未捕获的异常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleAllExceptions(Exception ex) {
        log.error("未预期的异常: ", ex);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
                .code("INTERNAL_ERROR")
                .message("服务器内部错误，请联系管理员")
                .timestamp(LocalDateTime.now())
                .build();
                
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

4.2 错误响应对象

/**
 * 错误响应对象
 */
@Data
@Builder
@NoArgsConstructor
@AllArgsConstructor
public class ErrorResponse {
    
    /**
     * 错误码
     */
    private String code;
    
    /**
     * 错误信息
     */
    private String message;
    
    /**
     * 时间戳
     */
    private LocalDateTime timestamp;
    
    /**
     * 请求ID（用于追踪）
     */
    private String requestId;
    
    /**
     * 调试信息（生产环境应隐藏）
     */
    private String debugInfo;
}

五、错误码管理系统

5.1 错误码枚举定义

/**
 * 错误码枚举
 */
public enum ErrorCode {
    
    // 通用错误码
    SUCCESS("0000", "操作成功"),
    SYSTEM_ERROR("9999", "系统内部错误"),
    VALIDATION_ERROR("1001", "参数校验失败"),
    RESOURCE_NOT_FOUND("1002", "资源未找到"),
    METHOD_NOT_ALLOWED("1003", "请求方法不允许"),
    INTERNAL_ERROR("1004", "内部服务器错误"),
    
    // 用户相关错误码
    USER_NOT_FOUND("2001", "用户不存在"),
    USER_PASSWORD_ERROR("2002", "密码错误"),
    USER_ALREADY_EXISTS("2003", "用户已存在"),
    USER_LOGIN_FAILED("2004", "登录失败"),
    
    // 订单相关错误码
    ORDER_NOT_FOUND("3001", "订单不存在"),
    ORDER_STATUS_ERROR("3002", "订单状态错误"),
    ORDER_CREATE_FAILED("3003", "订单创建失败"),
    
    // 商品相关错误码
    PRODUCT_NOT_FOUND("4001", "商品不存在"),
    PRODUCT_STOCK_INSUFFICIENT("4002", "商品库存不足"),
    PRODUCT_PRICE_ERROR("4003", "商品价格异常");
    
    private final String code;
    private final String message;
    
    ErrorCode(String code, String message) {
        this.code = code;
        this.message = message;
    }
    
    public String getCode() {
        return code;
    }
    
    public String getMessage() {
        return message;
    }
}

5.2 错误码管理器

/**
 * 错误码管理器
 */
@Component
public class ErrorCodeManager {
    
    private static final Map<String, String> ERROR_CODE_MAP = new HashMap<>();
    
    static {
        for (ErrorCode errorCode : ErrorCode.values()) {
            ERROR_CODE_MAP.put(errorCode.getCode(), errorCode.getMessage());
        }
    }
    
    /**
     * 获取错误码对应的描述信息
     */
    public static String getMessage(String code) {
        return ERROR_CODE_MAP.getOrDefault(code, "未知错误");
    }
    
    /**
     * 根据错误码创建业务异常
     */
    public static BusinessException createBusinessException(ErrorCode errorCode) {
        return new BusinessException(errorCode.getCode(), errorCode.getMessage());
    }
    
    /**
     * 根据错误码和参数创建业务异常
     */
    public static BusinessException createBusinessException(ErrorCode errorCode, Object... params) {
        String message = String.format(errorCode.getMessage(), params);
        return new BusinessException(errorCode.getCode(), message);
    }
}

六、高级异常处理功能

6.1 异常日志记录增强

/**
 * 增强型异常日志记录
 */
@Component
@Slf4j
public class ExceptionLogger {
    
    /**
     * 记录详细的异常日志
     */
    public void logException(Exception ex, String operation, String userId, String requestId) {
        StackTraceElement[] stackTrace = ex.getStackTrace();
        StringBuilder stackTraceStr = new StringBuilder();
        for (int i = 0; i < Math.min(stackTrace.length, 10); i++) {
            stackTraceStr.append("\tat ").append(stackTrace[i].toString()).append("\n");
        }
        
        log.error("异常详情 - 操作: {}, 用户ID: {}, 请求ID: {}, 异常类型: {}, 异常消息: {}, 堆栈信息: {}",
                operation, userId, requestId, ex.getClass().getSimpleName(), ex.getMessage(), stackTraceStr.toString());
    }
    
    /**
     * 记录敏感信息过滤的异常日志
     */
    public void logFilteredException(Exception ex, String operation, String userId, String requestId) {
        log.error("异常详情 - 操作: {}, 用户ID: {}, 请求ID: {}, 异常类型: {}, 异常消息: {}",
                operation, userId, requestId, ex.getClass().getSimpleName(), filterSensitiveInfo(ex.getMessage()));
    }
    
    /**
     * 过滤敏感信息
     */
    private String filterSensitiveInfo(String message) {
        if (message == null) {
            return "";
        }
        // 这里可以添加更多的敏感信息过滤规则
        return message.replaceAll("(password|pwd|secret|token)\\s*=\\s*[^\\s]+", "$1=***");
    }
}

6.2 异常链追踪

/**
 * 异常链追踪工具类
 */
@Component
public class ExceptionTracer {
    
    /**
     * 创建带追踪信息的异常
     */
    public static BusinessException traceException(String code, String message, Exception originalException) {
        // 添加追踪信息到异常堆栈中
        Throwable cause = originalException;
        while (cause != null && cause.getCause() != null) {
            cause = cause.getCause();
        }
        
        return new BusinessException(code, message, originalException);
    }
    
    /**
     * 记录异常链信息
     */
    public static void logExceptionChain(Exception ex) {
        log.error("异常链追踪:", ex);
        Throwable cause = ex.getCause();
        int depth = 1;
        while (cause != null) {
            log.error("异常链第{}层: {}", depth, cause.getClass().getSimpleName());
            cause = cause.getCause();
            depth++;
        }
    }
}

6.3 异常监控告警

/**
 * 异常监控告警组件
 */
@Component
public class ExceptionMonitor {
    
    private static final Logger monitorLog = LoggerFactory.getLogger("exception-monitor");
    
    /**
     * 发送异常告警
     */
    public void sendAlert(String exceptionType, String message, String level) {
        // 这里可以集成邮件、短信、钉钉等告警方式
        monitorLog.warn("异常告警 - 类型: {}, 级别: {}, 消息: {}", exceptionType, level, message);
        
        // 可以添加具体的告警逻辑
        // 如发送邮件、调用告警接口等
    }
    
    /**
     * 统计异常频率
     */
    public void countException(String exceptionType) {
        // 统计异常发生次数，用于监控
        // 可以集成到Prometheus、Grafana等监控系统
    }
}

七、实际应用示例

7.1 服务层异常处理

/**
 * 用户服务实现类
 */
@Service
@Slf4j
public class UserServiceImpl implements UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    @Override
    public User getUserById(Long id) {
        try {
            Optional<User> userOpt = userRepository.findById(id);
            if (!userOpt.isPresent()) {
                throw ErrorCodeManager.createBusinessException(ErrorCode.USER_NOT_FOUND);
            }
            return userOpt.get();
        } catch (Exception e) {
            log.error("获取用户失败，用户ID: {}", id, e);
            throw ExceptionTracer.traceException(
                ErrorCode.INTERNAL_ERROR.getCode(),
                "获取用户信息失败",
                e
            );
        }
    }
    
    @Override
    public User createUser(CreateUserRequest request) {
        try {
            // 参数校验
            validateCreateUserRequest(request);
            
            // 检查用户是否已存在
            if (userRepository.existsByUsername(request.getUsername())) {
                throw ErrorCodeManager.createBusinessException(ErrorCode.USER_ALREADY_EXISTS);
            }
            
            // 创建用户
            User user = User.builder()
                    .username(request.getUsername())
                    .email(request.getEmail())
                    .createTime(LocalDateTime.now())
                    .build();
                    
            return userRepository.save(user);
        } catch (BusinessException e) {
            // 业务异常直接抛出
            throw e;
        } catch (Exception e) {
            log.error("创建用户失败，请求参数: {}", request, e);
            throw ExceptionTracer.traceException(
                ErrorCode.INTERNAL_ERROR.getCode(),
                "创建用户失败",
                e
            );
        }
    }
    
    private void validateCreateUserRequest(CreateUserRequest request) {
        if (request.getUsername() == null || request.getUsername().trim().isEmpty()) {
            throw new ValidationException("USERNAME_REQUIRED", "用户名不能为空");
        }
        if (request.getEmail() == null || !isValidEmail(request.getEmail())) {
            throw new ValidationException("EMAIL_INVALID", "邮箱格式不正确");
        }
    }
    
    private boolean isValidEmail(String email) {
        return email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
    }
}

7.2 控制器层使用示例

/**
 * 用户控制器
 */
@RestController
@RequestMapping("/api/users")
@Slf4j
public class UserController {
    
    @Autowired
    private UserService userService;
    
    /**
     * 获取用户信息
     */
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        log.info("获取用户信息，用户ID: {}", id);
        User user = userService.getUserById(id);
        return ResponseEntity.ok(user);
    }
    
    /**
     * 创建用户
     */
    @PostMapping
    public ResponseEntity<User> createUser(@Valid @RequestBody CreateUserRequest request) {
        log.info("创建用户，请求参数: {}", request);
        User user = userService.createUser(request);
        return ResponseEntity.status(HttpStatus.CREATED).body(user);
    }
    
    /**
     * 更新用户
     */
    @PutMapping("/{id}")
    public ResponseEntity<User> updateUser(@PathVariable Long id, @Valid @RequestBody UpdateUserRequest request) {
        log.info("更新用户，用户ID: {}, 请求参数: {}", id, request);
        // 实现更新逻辑
        return ResponseEntity.ok().build();
    }
}

八、测试验证

8.1 单元测试

/**
 * 异常处理测试类
 */
@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class ExceptionHandlerTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void testBusinessException() {
        ResponseEntity<ErrorResponse> response = restTemplate.getForEntity(
            "/api/users/999999", 
            ErrorResponse.class
        );
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
        assertThat(response.getBody().getCode()).isEqualTo("2001");
        assertThat(response.getBody().getMessage()).contains("用户不存在");
    }
    
    @Test
    void testValidationException() {
        // 测试参数校验异常
        ResponseEntity<ErrorResponse> response = restTemplate.postForEntity(
            "/api/users",
            new CreateUserRequest("", "invalid-email"),
            ErrorResponse.class
        );
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
        assertThat(response.getBody().getCode()).isEqualTo("VALIDATION_ERROR");
    }
    
    @Test
    void testSystemException() {
        // 模拟系统异常
        ResponseEntity<ErrorResponse> response = restTemplate.getForEntity(
            "/api/users/system-error",
            ErrorResponse.class
        );
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.INTERNAL_SERVER_ERROR);
        assertThat(response.getBody().getCode()).isEqualTo("INTERNAL_ERROR");
    }
}

8.2 集成测试

/**
 * 集成测试配置
 */
@TestPropertySource(properties = {
    "logging.level.com.yourcompany.exception=DEBUG"
})
class ExceptionIntegrationTest {
    
    @Test
    void testExceptionHandlingInProduction() {
        // 模拟生产环境下的异常处理
        // 验证错误响应格式的一致性
        // 验证日志记录的完整性
    }
}

九、性能优化建议

9.1 异常处理性能优化

/**
 * 性能优化的异常处理
 */
@Component
public class OptimizedExceptionHandler {
    
    // 缓存常用的错误码映射
    private static final Cache<String, String> errorCodeCache = Caffeine.newBuilder()
            .maximumSize(1000)
            .expireAfterWrite(1, TimeUnit.HOURS)
            .build();
    
    /**
     * 高性能的错误码查找
     */
    public String getErrorMessage(String code) {
        return errorCodeCache.get(code, key -> ErrorCodeManager.getMessage(key));
    }
}

9.2 异步日志记录

/**
 * 异步异常日志记录
 */
@Component
public class AsyncExceptionLogger {
    
    @Async
    public void asyncLogException(Exception ex, String operation, String userId, String requestId) {
        // 异步记录异常日志，避免阻塞主线程
        log.error("异步异常记录 - 操作: {}, 用户ID: {}, 请求ID: {}", operation, userId, requestId, ex);
    }
}

十、最佳实践总结

10.1 设计原则

  1. 单一职责原则：每个异常类型只处理特定类型的错误
  2. 开闭原则：易于扩展新的异常类型和处理逻辑
  3. 依赖倒置原则：依赖抽象而非具体实现
  4. 接口隔离原则：提供清晰的异常处理接口

10.2 实施建议

  1. 分层处理：在不同层级设置相应的异常处理机制
  2. 日志分级：根据异常严重程度设置不同的日志级别
  3. 监控告警：建立完善的异常监控和告警机制
  4. 文档完善：为每种异常类型提供详细的文档说明

10.3 常见陷阱避免

  1. 不要忽略异常：确保所有异常都被适当处理
  2. 避免异常吞掉：不要在catch块中什么都不做
  3. 合理使用异常：异常不应该用于正常的流程控制
  4. 注意性能影响：避免过度的异常处理影响系统性能

结语

通过本文的详细介绍，我们看到了一个完整的Spring Boot微服务异常处理框架的设计与实现。这个框架不仅解决了传统异常处理方式的问题，还提供了丰富的功能特性，包括统一的错误响应格式、标准的错误码管理、完善的日志记录和监控告警等。

关键在于，这套方案能够帮助团队建立起一套标准化、可维护、高性能的异常处理机制，从而提升整个微服务系统的稳定性和可维护性。在实际项目中，可以根据具体需求对框架进行定制和扩展，但核心的设计思想和最佳实践是值得借鉴和应用的。

记住，优秀的异常处理不仅仅是技术问题，更是用户体验和系统可靠性的重要保障。希望本文的内容能够帮助你在微服务开发中更好地处理异常，构建更加健壮和可靠的系统。

本文来自极简博客，作者：数据科学实验室，转载请注明原文链接：Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别脏乱差的错误处理方式

打赏

本文固定链接: https://www.cxy163.net/archives/6695 | 绝缘体

该日志由 绝缘体.. 于 2022年10月18日 发表在 未分类 分类下， 你可以发表评论，并在保留原文地址及作者的情况下引用到你的网站或博客。
原创文章转载请注明: Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别脏乱差的错误处理方式 | 绝缘体
关键字: , , , ,
【上一篇】
【下一篇】

您可能还会对这些文章感兴趣！

  1. 使用中间件记录Laravel慢请求
  2. Linux服务器添加crontab任务计划详解
  3. 快速了解什么是JWT（JSON Web Token）
  4. minio 2020版本修改用户密码（已经运行有环境的配
  5. mysql 配置ssl ，java应用连接
  6. MariaDB/MySQL配置文件my.cnf解读
  7. MikroTik RouterOS 中的 system history 功能
  8. Java中的IO操作与流处理
  9. 使用Spring Boot Actuator实现应用监控
  10. Java 21虚拟线程性能优化实测：对比传统线程模型
  11. Spring Boot快速入门与实践
  12. 使用Spring Boot快速搭建Java应用
  13. Spring Cloud Alibaba实践-Nacos
  14. Cassandra数据库在大数据存储中的应用
  15. 云原生架构下的微服务性能优化全攻略：从容器资源
  16. 程序开发中的常见安全漏洞与防范措施

Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别脏乱差的错误处理方式：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter