Jul 15 2022

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

作者： 绝缘体..   发布： 2022-07-15 11:25   分类： 未分类   阅读：   抢沙发  
 
更多

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

引言

在现代微服务架构中，异常处理是确保系统稳定性和用户体验的关键环节。随着服务拆分粒度的细化，单个服务的异常可能会影响到整个微服务生态系统的正常运行。因此，设计一套完善的统一异常处理框架显得尤为重要。

Spring Boot作为当前主流的微服务开发框架，提供了丰富的异常处理机制。然而，在实际项目中，简单的异常处理往往无法满足复杂业务场景的需求。本文将深入探讨如何在Spring Boot微服务架构下设计和实现一套完整的统一异常处理框架，包括全局异常处理器、自定义异常类、异常日志记录等核心组件的设计与实现。

一、微服务异常处理的重要性

1.1 微服务架构下的异常特点

在微服务架构中，异常处理面临以下挑战：

  • 分布式特性：服务间调用可能出现网络超时、服务不可用等问题
  • 异构性：不同服务可能使用不同的技术栈和异常类型
  • 链式调用：一个服务的异常可能沿着调用链传播
  • 用户体验：需要向客户端提供友好的错误信息，避免暴露内部实现细节

1.2 异常处理的目标

良好的异常处理应该实现：

  • 一致性：统一的异常格式和响应结构
  • 可追溯性：完整的异常日志和追踪信息
  • 安全性：避免敏感信息泄露
  • 用户友好：提供清晰的错误提示信息

二、统一异常处理框架设计原则

2.1 核心设计理念

统一异常处理框架应遵循以下设计原则：

  1. 集中化管理：通过全局异常处理器统一处理所有异常
  2. 层次化处理：区分业务异常和系统异常，采用不同处理策略
  3. 可扩展性：支持自定义异常类型和处理逻辑
  4. 日志记录：完整记录异常信息用于问题排查
  5. 安全考虑：保护敏感信息不被泄露

2.2 架构设计思路

┌─────────────────┐    ┌─────────────────┐    ┌─────────────────┐
│   Controller    │    │   Service层     │    │   Repository    │
└─────────────────┘    └─────────────────┘    └─────────────────┘
         │                       │                       │
         └───────────────────────┼───────────────────────┘
                                  │
                    ┌─────────────────┐
                    │  全局异常处理器 │
                    └─────────────────┘
                                  │
                    ┌─────────────────┐
                    │  异常响应封装   │
                    └─────────────────┘
                                  │
                    ┌─────────────────┐
                    │  异常日志记录   │
                    └─────────────────┘

三、核心组件实现

3.1 自定义异常类设计

首先，我们需要定义一套完整的异常体系来支持业务异常和系统异常的分类处理。

// 基础异常类
public abstract class BaseException extends RuntimeException {
    private final String code;
    private final String message;
    
    public BaseException(String code, String message) {
        super(message);
        this.code = code;
        this.message = message;
    }
    
    public BaseException(String code, String message, Throwable cause) {
        super(message, cause);
        this.code = code;
        this.message = message;
    }
    
    // getter方法
    public String getCode() {
        return code;
    }
    
    @Override
    public String getMessage() {
        return message;
    }
}

// 业务异常类
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);
    }
}

// 系统异常类
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);
    }
}

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

3.2 统一响应结构设计

为了保证API响应的一致性，我们需要设计统一的响应结构：

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ApiResponse<T> {
    /**
     * 响应码
     */
    private String code;
    
    /**
     * 响应消息
     */
    private String message;
    
    /**
     * 响应数据
     */
    private T data;
    
    /**
     * 时间戳
     */
    private Long timestamp;
    
    /**
     * 请求ID，用于追踪请求
     */
    private String requestId;
    
    // 静态方法创建成功响应
    public static <T> ApiResponse<T> success(T data) {
        return ApiResponse.<T>builder()
                .code("00000")
                .message("success")
                .data(data)
                .timestamp(System.currentTimeMillis())
                .requestId(UUID.randomUUID().toString())
                .build();
    }
    
    // 静态方法创建失败响应
    public static <T> ApiResponse<T> error(String code, String message) {
        return ApiResponse.<T>builder()
                .code(code)
                .message(message)
                .timestamp(System.currentTimeMillis())
                .requestId(UUID.randomUUID().toString())
                .build();
    }
    
    // 静态方法创建失败响应（带数据）
    public static <T> ApiResponse<T> error(String code, String message, T data) {
        return ApiResponse.<T>builder()
                .code(code)
                .message(message)
                .data(data)
                .timestamp(System.currentTimeMillis())
                .requestId(UUID.randomUUID().toString())
                .build();
    }
}

3.3 全局异常处理器实现

全局异常处理器是统一异常处理框架的核心组件：

@RestControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    
    /**
     * 处理业务异常
     */
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ApiResponse<Object>> handleBusinessException(BusinessException e) {
        log.warn("业务异常: {}", e.getMessage(), e);
        
        ApiResponse<Object> response = ApiResponse.error(e.getCode(), e.getMessage());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    /**
     * 处理参数校验异常
     */
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ApiResponse<Object>> handleValidationException(ValidationException e) {
        log.warn("参数校验异常: {}", e.getMessage(), e);
        
        ApiResponse<Object> response = ApiResponse.error(e.getCode(), e.getMessage());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    /**
     * 处理方法参数不匹配异常
     */
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiResponse<Object>> handleMethodArgumentNotValidException(
            MethodArgumentNotValidException e) {
        log.warn("参数校验异常: {}", e.getMessage(), e);
        
        // 提取验证错误信息
        StringBuilder errorMsg = new StringBuilder();
        e.getBindingResult().getFieldErrors().forEach(error -> 
            errorMsg.append(error.getField()).append(": ").append(error.getDefaultMessage()).append("; ")
        );
        
        ApiResponse<Object> response = ApiResponse.error("VALIDATION_ERROR", errorMsg.toString());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    /**
     * 处理参数类型转换异常
     */
    @ExceptionHandler(MethodArgumentTypeMismatchException.class)
    public ResponseEntity<ApiResponse<Object>> handleMethodArgumentTypeMismatchException(
            MethodArgumentTypeMismatchException e) {
        log.warn("参数类型转换异常: {}", e.getMessage(), e);
        
        String message = String.format("参数[%s]类型不匹配，期望类型为[%s]", 
            e.getName(), e.getRequiredType().getSimpleName());
        
        ApiResponse<Object> response = ApiResponse.error("PARAMETER_TYPE_ERROR", message);
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    /**
     * 处理未捕获的运行时异常
     */
    @ExceptionHandler(RuntimeException.class)
    public ResponseEntity<ApiResponse<Object>> handleRuntimeException(RuntimeException e) {
        log.error("未预期的运行时异常: ", e);
        
        ApiResponse<Object> response = ApiResponse.error("SYSTEM_ERROR", "系统异常，请稍后重试");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
    }
    
    /**
     * 处理系统异常
     */
    @ExceptionHandler(SystemException.class)
    public ResponseEntity<ApiResponse<Object>> handleSystemException(SystemException e) {
        log.error("系统异常: {}", e.getMessage(), e);
        
        ApiResponse<Object> response = ApiResponse.error(e.getCode(), e.getMessage());
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
    }
    
    /**
     * 处理所有其他异常
     */
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Object>> handleException(Exception e) {
        log.error("未知异常: ", e);
        
        ApiResponse<Object> response = ApiResponse.error("UNKNOWN_ERROR", "未知异常，请联系管理员");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
    }
}

3.4 异常日志记录增强

为了更好地追踪和分析异常，我们需要增强日志记录功能：

@Component
@Slf4j
public class ExceptionLogger {
    
    public void logException(Exception exception, HttpServletRequest request) {
        // 获取请求信息
        String requestUrl = request.getRequestURL().toString();
        String method = request.getMethod();
        String userAgent = request.getHeader("User-Agent");
        String remoteAddr = getClientIpAddress(request);
        
        // 构建异常日志
        StringBuilder logBuilder = new StringBuilder();
        logBuilder.append("\n=== 异常日志 ===\n")
                  .append("请求URL: ").append(requestUrl).append("\n")
                  .append("请求方法: ").append(method).append("\n")
                  .append("客户端IP: ").append(remoteAddr).append("\n")
                  .append("User-Agent: ").append(userAgent).append("\n")
                  .append("异常类型: ").append(exception.getClass().getName()).append("\n")
                  .append("异常信息: ").append(exception.getMessage()).append("\n")
                  .append("堆栈跟踪:\n").append(getStackTrace(exception)).append("\n")
                  .append("==================");
        
        log.error(logBuilder.toString());
    }
    
    private String getClientIpAddress(HttpServletRequest request) {
        String ip = request.getHeader("X-Forwarded-For");
        if (ip != null && ip.length() != 0 && !"unknown".equalsIgnoreCase(ip)) {
            // 多级代理的情况
            int index = ip.indexOf(",");
            if (index != -1) {
                ip = ip.substring(0, index);
            }
        } else {
            ip = request.getHeader("X-Real-IP");
        }
        if (ip == null || ip.length() == 0 || "unknown".equalsIgnoreCase(ip)) {
            ip = request.getRemoteAddr();
        }
        return ip;
    }
    
    private String getStackTrace(Exception exception) {
        StringWriter sw = new StringWriter();
        PrintWriter pw = new PrintWriter(sw);
        exception.printStackTrace(pw);
        return sw.toString();
    }
}

3.5 异常处理增强版全局处理器

结合日志记录的增强版全局异常处理器：

@RestControllerAdvice
@Slf4j
public class EnhancedGlobalExceptionHandler {
    
    @Autowired
    private ExceptionLogger exceptionLogger;
    
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ApiResponse<Object>> handleBusinessException(BusinessException e, 
            HttpServletRequest request) {
        exceptionLogger.logException(e, request);
        
        ApiResponse<Object> response = ApiResponse.error(e.getCode(), e.getMessage());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ApiResponse<Object>> handleValidationException(ValidationException e,
            HttpServletRequest request) {
        exceptionLogger.logException(e, request);
        
        ApiResponse<Object> response = ApiResponse.error(e.getCode(), e.getMessage());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ApiResponse<Object>> handleMethodArgumentNotValidException(
            MethodArgumentNotValidException e, HttpServletRequest request) {
        exceptionLogger.logException(e, request);
        
        StringBuilder errorMsg = new StringBuilder();
        e.getBindingResult().getFieldErrors().forEach(error -> 
            errorMsg.append(error.getField()).append(": ").append(error.getDefaultMessage()).append("; ")
        );
        
        ApiResponse<Object> response = ApiResponse.error("VALIDATION_ERROR", errorMsg.toString());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(response);
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Object>> handleException(Exception e, HttpServletRequest request) {
        exceptionLogger.logException(e, request);
        
        ApiResponse<Object> response = ApiResponse.error("SYSTEM_ERROR", "系统异常，请稍后重试");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(response);
    }
}

四、业务场景中的异常处理实践

4.1 用户服务异常处理示例

@Service
public class UserService {
    
    @Autowired
    private UserRepository userRepository;
    
    public User getUserById(Long id) {
        try {
            User user = userRepository.findById(id);
            if (user == null) {
                throw new BusinessException("USER_NOT_FOUND", "用户不存在");
            }
            return user;
        } catch (DataAccessException e) {
            throw new SystemException("DATABASE_ERROR", "数据库访问异常", e);
        }
    }
    
    public User createUser(CreateUserRequest request) {
        try {
            // 参数校验
            validateCreateUserRequest(request);
            
            // 检查用户是否已存在
            if (userRepository.existsByUsername(request.getUsername())) {
                throw new BusinessException("USER_EXISTS", "用户名已存在");
            }
            
            // 创建用户
            User user = new User();
            user.setUsername(request.getUsername());
            user.setEmail(request.getEmail());
            user.setPassword(passwordEncoder.encode(request.getPassword()));
            
            return userRepository.save(user);
        } catch (ValidationException e) {
            throw e; // 直接抛出，由全局处理器处理
        } catch (DataAccessException e) {
            throw new SystemException("DATABASE_ERROR", "创建用户失败", e);
        }
    }
    
    private void validateCreateUserRequest(CreateUserRequest request) {
        if (StringUtils.isEmpty(request.getUsername())) {
            throw new ValidationException("USERNAME_REQUIRED", "用户名不能为空");
        }
        if (StringUtils.isEmpty(request.getEmail())) {
            throw new ValidationException("EMAIL_REQUIRED", "邮箱不能为空");
        }
        if (!isValidEmail(request.getEmail())) {
            throw new ValidationException("INVALID_EMAIL", "邮箱格式不正确");
        }
        if (StringUtils.isEmpty(request.getPassword())) {
            throw new ValidationException("PASSWORD_REQUIRED", "密码不能为空");
        }
    }
    
    private boolean isValidEmail(String email) {
        return email.matches("^[A-Za-z0-9+_.-]+@(.+)$");
    }
}

4.2 控制器层异常处理

@RestController
@RequestMapping("/api/users")
@Slf4j
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/{id}")
    public ApiResponse<User> getUser(@PathVariable Long id) {
        User user = userService.getUserById(id);
        return ApiResponse.success(user);
    }
    
    @PostMapping
    public ApiResponse<User> createUser(@Valid @RequestBody CreateUserRequest request) {
        User user = userService.createUser(request);
        return ApiResponse.success(user);
    }
    
    @PutMapping("/{id}")
    public ApiResponse<User> updateUser(@PathVariable Long id, 
                                       @Valid @RequestBody UpdateUserRequest request) {
        User user = userService.updateUser(id, request);
        return ApiResponse.success(user);
    }
}

五、高级异常处理特性

5.1 异常重试机制

对于某些临时性异常，可以实现重试机制：

@Component
public class RetryableExceptionHandler {
    
    private static final int MAX_RETRY_ATTEMPTS = 3;
    private static final long RETRY_DELAY_MS = 1000;
    
    public <T> T executeWithRetry(Supplier<T> operation, Class<? extends Exception>[] retryableExceptions) {
        Exception lastException = null;
        
        for (int attempt = 1; attempt <= MAX_RETRY_ATTEMPTS; attempt++) {
            try {
                return operation.get();
            } catch (Exception e) {
                lastException = e;
                
                // 检查是否应该重试
                if (shouldRetry(e, retryableExceptions) && attempt < MAX_RETRY_ATTEMPTS) {
                    log.warn("操作失败，第{}次重试，异常: {}", attempt, e.getMessage());
                    try {
                        Thread.sleep(RETRY_DELAY_MS * attempt); // 指数退避
                    } catch (InterruptedException ie) {
                        Thread.currentThread().interrupt();
                        throw new RuntimeException("重试被中断", ie);
                    }
                } else {
                    break;
                }
            }
        }
        
        throw new RuntimeException("操作失败，已达到最大重试次数", lastException);
    }
    
    private boolean shouldRetry(Exception exception, Class<? extends Exception>[] retryableExceptions) {
        return Arrays.stream(retryableExceptions)
                .anyMatch(clazz -> clazz.isInstance(exception));
    }
}

5.2 异常监控和告警

@Component
@Slf4j
public class ExceptionMonitor {
    
    private static final Set<String> MONITOR_EXCEPTIONS = Set.of(
        "DATABASE_ERROR", "SERVICE_UNAVAILABLE", "TIMEOUT_ERROR"
    );
    
    private final MeterRegistry meterRegistry;
    
    public ExceptionMonitor(MeterRegistry meterRegistry) {
        this.meterRegistry = meterRegistry;
    }
    
    public void monitorException(String exceptionCode, String exceptionMessage) {
        // 记录异常计数
        Counter.builder("exception.count")
                .tag("code", exceptionCode)
                .tag("message", exceptionMessage)
                .register(meterRegistry)
                .increment();
        
        // 如果是关键异常，触发告警
        if (MONITOR_EXCEPTIONS.contains(exceptionCode)) {
            log.warn("检测到关键异常: {} - {}", exceptionCode, exceptionMessage);
            // 这里可以集成告警系统，如发送邮件、短信等
            sendAlert(exceptionCode, exceptionMessage);
        }
    }
    
    private void sendAlert(String exceptionCode, String exceptionMessage) {
        // 实现具体的告警逻辑
        log.info("发送告警通知: {} - {}", exceptionCode, exceptionMessage);
    }
}

六、性能优化和最佳实践

6.1 异常处理性能优化

@RestControllerAdvice
@Slf4j
public class OptimizedGlobalExceptionHandler {
    
    // 缓存常见的异常类型，避免重复反射查找
    private static final Set<Class<? extends Exception>> COMMON_EXCEPTIONS = 
        Set.of(BusinessException.class, ValidationException.class, 
               MethodArgumentNotValidException.class);
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ApiResponse<Object>> handleException(Exception e) {
        // 快速判断是否为常见异常
        if (COMMON_EXCEPTIONS.stream().anyMatch(clazz -> clazz.isInstance(e))) {
            return handleCommonException(e);
        }
        
        // 对于非常见异常，使用更详细的日志记录
        return handleUnknownException(e);
    }
    
    private ResponseEntity<ApiResponse<Object>> handleCommonException(Exception e) {
        // 常见异常处理逻辑
        return ResponseEntity.status(HttpStatus.BAD_REQUEST)
                .body(ApiResponse.error("ERROR", "请求处理失败"));
    }
    
    private ResponseEntity<ApiResponse<Object>> handleUnknownException(Exception e) {
        // 未知异常处理逻辑
        log.error("未知异常: ", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(ApiResponse.error("SYSTEM_ERROR", "系统异常"));
    }
}

6.2 异常处理配置

# application.yml
spring:
  main:
    allow-bean-definition-overriding: true

logging:
  level:
    com.yourcompany.exception: DEBUG
    org.springframework.web: DEBUG

exception:
  handler:
    # 是否启用详细异常信息记录
    detailed-logging: true
    # 异常监控开关
    monitor-enabled: true
    # 最大异常日志保留天数
    max-log-retention-days: 30

七、测试和验证

7.1 异常处理单元测试

@SpringBootTest
@AutoConfigureTestDatabase(replace = AutoConfigureTestDatabase.Replace.NONE)
class GlobalExceptionHandlerTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void testBusinessException() {
        ResponseEntity<ApiResponse<Object>> response = restTemplate.getForEntity(
            "/api/users/999999", ApiResponse.class);
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
        assertThat(response.getBody().getCode()).isEqualTo("USER_NOT_FOUND");
    }
    
    @Test
    void testValidationException() {
        CreateUserRequest request = new CreateUserRequest();
        ResponseEntity<ApiResponse<Object>> response = restTemplate.postForEntity(
            "/api/users", request, ApiResponse.class);
        
        assertThat(response.getStatusCode()).isEqualTo(HttpStatus.BAD_REQUEST);
        assertThat(response.getBody().getCode()).isEqualTo("VALIDATION_ERROR");
    }
}

7.2 异常处理集成测试

@Test
void testExceptionHandlingIntegration() {
    // 测试各种异常场景
    List<ExceptionTestCase> testCases = Arrays.asList(
        new ExceptionTestCase("用户不存在", "/api/users/999999", HttpStatus.BAD_REQUEST),
        new ExceptionTestCase("参数校验失败", "/api/users", HttpStatus.BAD_REQUEST),
        new ExceptionTestCase("数据库异常", "/api/users/1", HttpStatus.INTERNAL_SERVER_ERROR)
    );
    
    for (ExceptionTestCase testCase : testCases) {
        // 执行测试逻辑
        ResponseEntity<ApiResponse<Object>> response = 
            restTemplate.getForEntity(testCase.getUrl(), ApiResponse.class);
        
        assertThat(response.getStatusCode()).isEqualTo(testCase.getExpectedStatus());
        // 验证响应格式正确性
        assertThat(response.getBody()).isNotNull();
        assertThat(response.getBody().getCode()).isNotNull();
    }
}

八、总结与展望

通过本文的详细介绍，我们构建了一套完整的Spring Boot微服务统一异常处理框架。该框架具有以下特点：

  1. 层次化设计：通过自定义异常类实现业务异常和系统异常的清晰分离
  2. 统一响应格式：提供一致的API响应结构，便于前端处理
  3. 完善日志记录：详细的异常日志记录，便于问题排查
  4. 可扩展性强：易于添加新的异常类型和处理逻辑
  5. 性能优化：考虑了异常处理的性能影响

在实际应用中，还需要根据具体业务需求进行调整和优化。未来的发展方向包括：

  • 集成更智能的异常预测和自动修复机制
  • 支持分布式链路追踪中的异常上下文传递
  • 建立异常处理的监控仪表板
  • 实现基于机器学习的异常模式识别

这套统一异常处理框架不仅能够提升系统的稳定性和可靠性，还能显著改善用户体验，是构建高质量微服务系统的重要基础设施。

本文来自极简博客，作者：算法架构师，转载请注明原文链接：Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现

打赏

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

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

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

  1. 使用中间件记录Laravel慢请求
  2. mysql 配置ssl ，java应用连接
  3. MariaDB/MySQL配置文件my.cnf解读
  4. MikroTik RouterOS 中的 system history 功能
  5. Java中的IO操作与流处理
  6. 通过K8S实现微服务架构的演进
  7. 使用Spring Boot Actuator实现应用监控
  8. Java 21虚拟线程性能优化实测：对比传统线程模型
  9. Spring Boot快速入门与实践
  10. 使用Spring Boot快速搭建Java应用
  11. 如何构建一个响应式的导航栏
  12. Spring Cloud Alibaba实践-Nacos
  13. Cassandra数据库在大数据存储中的应用
  14. 云原生架构下的微服务性能优化全攻略：从容器资源
  15. 通过API网关实现微服务的统一入口
  16. Spring Boot入门指南

Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter