May 17 2017

Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别凌乱的try-catch代码

作者： 绝缘体..   发布： 2017-05-17 09:02   分类： 未分类   阅读：   抢沙发  
 
更多

Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别凌乱的try-catch代码

在构建Spring Boot微服务应用时，异常处理是一个至关重要的环节。良好的异常处理机制不仅能够提升系统的健壮性和可维护性，还能为用户提供更好的体验。然而，许多开发者在实际开发中往往采用分散的try-catch代码块，导致代码冗余、维护困难。本文将深入探讨Spring Boot微服务中异常处理的最佳实践方案，通过设计统一的异常处理框架，帮助开发者告别凌乱的try-catch代码。

为什么需要统一异常处理

在传统的Spring Boot应用开发中，我们经常看到这样的代码：

@RestController
@RequestMapping("/api/users")
public class UserController {
    
    @Autowired
    private UserService userService;
    
    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        try {
            User user = userService.findById(id);
            if (user == null) {
                return ResponseEntity.notFound().build();
            }
            return ResponseEntity.ok(user);
        } catch (DataAccessException e) {
            // 数据库访问异常处理
            log.error("数据库访问异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(null);
        } catch (IllegalArgumentException e) {
            // 参数异常处理
            log.warn("参数异常", e);
            return ResponseEntity.badRequest().body(null);
        } catch (Exception e) {
            // 其他异常处理
            log.error("未知异常", e);
            return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                .body(null);
        }
    }
}

这种处理方式存在诸多问题：

  1. 代码重复：每个控制器方法都需要编写类似的异常处理逻辑
  2. 维护困难：异常处理逻辑分散在各个方法中，难以统一管理和修改
  3. 响应格式不一致：不同接口返回的错误信息格式可能不同
  4. 业务逻辑与异常处理混合：影响代码的可读性和可维护性

统一异常处理框架设计

为了解决上述问题，我们需要设计一个统一的异常处理框架。该框架应该具备以下特性：

1. 全局异常处理器

Spring Boot提供了@ControllerAdvice注解，可以用来创建全局异常处理器。通过这个机制，我们可以集中处理所有控制器中抛出的异常。

@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    
    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException e) {
        log.warn("业务异常: {}", e.getMessage());
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code(e.getErrorCode())
            .message(e.getMessage())
            .timestamp(System.currentTimeMillis())
            .build();
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(ValidationException e) {
        log.warn("参数校验异常: {}", e.getMessage());
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code("VALIDATION_ERROR")
            .message(e.getMessage())
            .timestamp(System.currentTimeMillis())
            .build();
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception e) {
        log.error("系统异常", e);
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code("SYSTEM_ERROR")
            .message("系统内部错误")
            .timestamp(System.currentTimeMillis())
            .build();
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

2. 自定义异常类型设计

为了更好地管理不同类型的异常，我们需要设计一套自定义异常类型体系：

/**
 * 基础业务异常类
 */
@Data
@AllArgsConstructor
@NoArgsConstructor
public class BusinessException extends RuntimeException {
    private String errorCode;
    private String message;
    
    public BusinessException(String message) {
        this.message = message;
        this.errorCode = "BUSINESS_ERROR";
    }
    
    public BusinessException(String errorCode, String message) {
        this.errorCode = errorCode;
        this.message = message;
    }
}

/**
 * 参数校验异常
 */
public class ValidationException extends BusinessException {
    public ValidationException(String message) {
        super("VALIDATION_ERROR", message);
    }
}

/**
 * 资源未找到异常
 */
public class ResourceNotFoundException extends BusinessException {
    public ResourceNotFoundException(String resourceType, String identifier) {
        super("RESOURCE_NOT_FOUND", 
              String.format("%s not found with identifier: %s", resourceType, identifier));
    }
}

/**
 * 权限异常
 */
public class AuthorizationException extends BusinessException {
    public AuthorizationException(String message) {
        super("AUTHORIZATION_ERROR", message);
    }
}

3. 标准化错误响应格式

统一的错误响应格式对于API的使用者来说非常重要。我们可以定义一个标准的错误响应对象：

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ErrorResponse {
    private String code;
    private String message;
    private Long timestamp;
    private String path;
    private Object details;
    
    public static ErrorResponse of(String code, String message) {
        return ErrorResponse.builder()
            .code(code)
            .message(message)
            .timestamp(System.currentTimeMillis())
            .build();
    }
}

完整的异常处理框架实现

基于上述设计理念，我们来实现一个完整的异常处理框架：

1. 异常枚举定义

首先定义异常码枚举，统一管理所有异常码：

public enum ErrorCode {
    // 系统级异常
    SYSTEM_ERROR("SYSTEM_ERROR", "系统内部错误"),
    PARAMETER_ERROR("PARAMETER_ERROR", "参数错误"),
    VALIDATION_ERROR("VALIDATION_ERROR", "参数校验失败"),
    
    // 业务级异常
    USER_NOT_FOUND("USER_NOT_FOUND", "用户不存在"),
    USER_ALREADY_EXISTS("USER_ALREADY_EXISTS", "用户已存在"),
    INSUFFICIENT_PERMISSION("INSUFFICIENT_PERMISSION", "权限不足"),
    RESOURCE_NOT_FOUND("RESOURCE_NOT_FOUND", "资源不存在"),
    
    // 第三方服务异常
    THIRD_PARTY_SERVICE_ERROR("THIRD_PARTY_SERVICE_ERROR", "第三方服务调用失败");
    
    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;
    }
}

2. 异常基类和业务异常类

/**
 * 应用异常基类
 */
@Data
@EqualsAndHashCode(callSuper = true)
public class AppException extends RuntimeException {
    private String code;
    private Object data;
    
    public AppException(ErrorCode errorCode) {
        super(errorCode.getMessage());
        this.code = errorCode.getCode();
    }
    
    public AppException(ErrorCode errorCode, String message) {
        super(message);
        this.code = errorCode.getCode();
    }
    
    public AppException(ErrorCode errorCode, Throwable cause) {
        super(errorCode.getMessage(), cause);
        this.code = errorCode.getCode();
    }
    
    public AppException(ErrorCode errorCode, String message, Object data) {
        super(message);
        this.code = errorCode.getCode();
        this.data = data;
    }
}

/**
 * 业务异常类
 */
public class BusinessException extends AppException {
    public BusinessException(ErrorCode errorCode) {
        super(errorCode);
    }
    
    public BusinessException(ErrorCode errorCode, String message) {
        super(errorCode, message);
    }
    
    public BusinessException(ErrorCode errorCode, Throwable cause) {
        super(errorCode, cause);
    }
}

/**
 * 参数校验异常类
 */
public class ValidationException extends AppException {
    public ValidationException(String message) {
        super(ErrorCode.VALIDATION_ERROR, message);
    }
    
    public ValidationException(String message, Object data) {
        super(ErrorCode.VALIDATION_ERROR, message, data);
    }
}

3. 全局异常处理器实现

@ControllerAdvice
@Slf4j
public class GlobalExceptionHandler {
    
    @ExceptionHandler(AppException.class)
    public ResponseEntity<ErrorResponse> handleAppException(AppException e, HttpServletRequest request) {
        log.warn("应用异常: code={}, message={}", e.getCode(), e.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code(e.getCode())
            .message(e.getMessage())
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .data(e.getData())
            .build();
            
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    @ExceptionHandler(ValidationException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(ValidationException e, 
                                                                  HttpServletRequest request) {
        log.warn("参数校验异常: {}", e.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code(e.getCode())
            .message(e.getMessage())
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .data(e.getData())
            .build();
            
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleMethodArgumentNotValidException(
            MethodArgumentNotValidException e, HttpServletRequest request) {
        
        List<FieldError> fieldErrors = e.getBindingResult().getFieldErrors();
        Map<String, String> errors = new HashMap<>();
        fieldErrors.forEach(error -> errors.put(error.getField(), error.getDefaultMessage()));
        
        log.warn("方法参数校验异常: {}", errors);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code(ErrorCode.VALIDATION_ERROR.getCode())
            .message("参数校验失败")
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .data(errors)
            .build();
            
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    @ExceptionHandler(ConstraintViolationException.class)
    public ResponseEntity<ErrorResponse> handleConstraintViolationException(
            ConstraintViolationException e, HttpServletRequest request) {
        
        Set<ConstraintViolation<?>> violations = e.getConstraintViolations();
        Map<String, String> errors = new HashMap<>();
        violations.forEach(violation -> 
            errors.put(violation.getPropertyPath().toString(), violation.getMessage()));
        
        log.warn("约束校验异常: {}", errors);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code(ErrorCode.VALIDATION_ERROR.getCode())
            .message("参数校验失败")
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .data(errors)
            .build();
            
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    @ExceptionHandler(HttpRequestMethodNotSupportedException.class)
    public ResponseEntity<ErrorResponse> handleHttpRequestMethodNotSupportedException(
            HttpRequestMethodNotSupportedException e, HttpServletRequest request) {
        
        log.warn("HTTP方法不支持: {}", e.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code("METHOD_NOT_ALLOWED")
            .message("HTTP方法不支持: " + e.getMethod())
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .build();
            
        return ResponseEntity.status(HttpStatus.METHOD_NOT_ALLOWED).body(errorResponse);
    }
    
    @ExceptionHandler(HttpMessageNotReadableException.class)
    public ResponseEntity<ErrorResponse> handleHttpMessageNotReadableException(
            HttpMessageNotReadableException e, HttpServletRequest request) {
        
        log.warn("HTTP消息不可读: {}", e.getMessage());
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code("BAD_REQUEST")
            .message("请求体格式错误")
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .build();
            
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception e, 
                                                               HttpServletRequest request) {
        log.error("系统异常: {}", e.getMessage(), e);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code(ErrorCode.SYSTEM_ERROR.getCode())
            .message(ErrorCode.SYSTEM_ERROR.getMessage())
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .build();
            
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

4. 异常工具类

为了方便在业务代码中抛出异常，我们可以提供一些工具类：

public class ExceptionUtils {
    
    public static void throwBusinessException(ErrorCode errorCode) {
        throw new BusinessException(errorCode);
    }
    
    public static void throwBusinessException(ErrorCode errorCode, String message) {
        throw new BusinessException(errorCode, message);
    }
    
    public static void throwValidationException(String message) {
        throw new ValidationException(message);
    }
    
    public static void throwValidationException(String message, Object data) {
        throw new ValidationException(message, data);
    }
    
    public static void throwIfNull(Object obj, ErrorCode errorCode) {
        if (obj == null) {
            throw new BusinessException(errorCode);
        }
    }
    
    public static void throwIfTrue(boolean condition, ErrorCode errorCode) {
        if (condition) {
            throw new BusinessException(errorCode);
        }
    }
    
    public static void throwIfFalse(boolean condition, ErrorCode errorCode) {
        if (!condition) {
            throw new BusinessException(errorCode);
        }
    }
}

微服务场景下的异常处理

在微服务架构中，异常处理变得更加复杂，因为需要考虑服务间的调用和异常传播。

1. Feign客户端异常处理

当使用Feign进行服务间调用时，需要特殊处理远程服务抛出的异常：

@Component
@Slf4j
public class FeignErrorDecoder implements ErrorDecoder {
    
    private final ErrorDecoder defaultErrorDecoder = new Default();
    
    @Override
    public Exception decode(String methodKey, Response response) {
        try {
            if (response.body() != null) {
                String body = Util.toString(response.body().asReader(StandardCharsets.UTF_8));
                ObjectMapper mapper = new ObjectMapper();
                ErrorResponse errorResponse = mapper.readValue(body, ErrorResponse.class);
                
                if (response.status() >= 400 && response.status() < 500) {
                    return new BusinessException(
                        ErrorCode.valueOf(errorResponse.getCode()), 
                        errorResponse.getMessage()
                    );
                }
            }
        } catch (Exception e) {
            log.warn("解析Feign异常响应失败", e);
        }
        
        return defaultErrorDecoder.decode(methodKey, response);
    }
}

2. 统一响应包装器

为了统一处理成功和失败的响应，可以使用响应包装器：

@Data
@Builder
@AllArgsConstructor
@NoArgsConstructor
public class ApiResponse<T> {
    private boolean success;
    private String code;
    private String message;
    private T data;
    private Long timestamp;
    
    public static <T> ApiResponse<T> success(T data) {
        return ApiResponse.<T>builder()
            .success(true)
            .code("SUCCESS")
            .message("操作成功")
            .data(data)
            .timestamp(System.currentTimeMillis())
            .build();
    }
    
    public static <T> ApiResponse<T> error(String code, String message) {
        return ApiResponse.<T>builder()
            .success(false)
            .code(code)
            .message(message)
            .timestamp(System.currentTimeMillis())
            .build();
    }
    
    public static <T> ApiResponse<T> error(ErrorCode errorCode) {
        return ApiResponse.<T>builder()
            .success(false)
            .code(errorCode.getCode())
            .message(errorCode.getMessage())
            .timestamp(System.currentTimeMillis())
            .build();
    }
}

3. 响应拦截器

使用响应拦截器来统一包装返回结果：

@ControllerAdvice
public class ResponseWrapperAdvice implements ResponseBodyAdvice<Object> {
    
    @Override
    public boolean supports(MethodParameter returnType, 
                           Class<? extends HttpMessageConverter<?>> converterType) {
        return true;
    }
    
    @Override
    public Object beforeBodyWrite(Object body, 
                                 MethodParameter returnType,
                                 MediaType selectedContentType,
                                 Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                 ServerHttpRequest request, 
                                 ServerHttpResponse response) {
        
        // 如果已经是ApiResponse格式，直接返回
        if (body instanceof ApiResponse) {
            return body;
        }
        
        // 如果是字符串类型，需要特殊处理
        if (body instanceof String) {
            try {
                ObjectMapper mapper = new ObjectMapper();
                return mapper.writeValueAsString(
                    ApiResponse.success(body)
                );
            } catch (Exception e) {
                return body;
            }
        }
        
        // 其他情况统一包装
        return ApiResponse.success(body);
    }
}

日志记录策略

良好的日志记录策略对于异常排查至关重要：

1. 结构化日志记录

@Slf4j
@ControllerAdvice
public class GlobalExceptionHandler {
    
    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception e, 
                                                               HttpServletRequest request) {
        // 结构化日志记录
        Map<String, Object> logData = new HashMap<>();
        logData.put("exceptionType", e.getClass().getSimpleName());
        logData.put("message", e.getMessage());
        logData.put("requestUri", request.getRequestURI());
        logData.put("requestMethod", request.getMethod());
        logData.put("userAgent", request.getHeader("User-Agent"));
        logData.put("remoteAddr", request.getRemoteAddr());
        
        log.error("系统异常: {}", JsonUtils.toJson(logData), e);
        
        ErrorResponse errorResponse = ErrorResponse.builder()
            .code(ErrorCode.SYSTEM_ERROR.getCode())
            .message(ErrorCode.SYSTEM_ERROR.getMessage())
            .timestamp(System.currentTimeMillis())
            .path(request.getRequestURI())
            .build();
            
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

2. 敏感信息脱敏

在记录日志时，需要注意敏感信息的脱敏处理：

public class LogUtils {
    
    private static final Pattern PHONE_PATTERN = Pattern.compile("(\\d{3})\\d{4}(\\d{4})");
    private static final Pattern EMAIL_PATTERN = Pattern.compile("(\\w?)(\\w+)(\\w)(@\\w+\\.[a-z]+(\\.[a-z]+)?)");
    
    public static String maskPhone(String phone) {
        if (phone == null || phone.isEmpty()) {
            return phone;
        }
        return PHONE_PATTERN.matcher(phone).replaceAll("$1****$2");
    }
    
    public static String maskEmail(String email) {
        if (email == null || email.isEmpty()) {
            return email;
        }
        return EMAIL_PATTERN.matcher(email).replaceAll("$1****$3$4");
    }
    
    public static String maskJson(String json) {
        if (json == null || json.isEmpty()) {
            return json;
        }
        // 对JSON中的敏感字段进行脱敏处理
        return json.replaceAll("(\"phone\"\\s*:\\s*\")([^\"]+)(\")", "$1****$3")
                  .replaceAll("(\"email\"\\s*:\\s*\")([^\"]+)(\")", "$1****$3");
    }
}

最佳实践总结

1. 异常处理原则

  • 分层处理：按照异常类型进行分层处理，业务异常、系统异常、第三方异常分别处理
  • 统一格式：所有异常响应保持统一的格式，便于前端处理
  • 合理分类：将异常分为客户端异常（4xx）和服务端异常（5xx）
  • 安全考虑：不要将敏感信息暴露给客户端

2. 代码示例对比

重构前的代码：

@PostMapping("/users")
public ResponseEntity<User> createUser(@RequestBody User user) {
    try {
        if (user.getName() == null || user.getName().isEmpty()) {
            return ResponseEntity.badRequest().body(null);
        }
        
        User existingUser = userService.findByName(user.getName());
        if (existingUser != null) {
            return ResponseEntity.badRequest().body(null);
        }
        
        User savedUser = userService.save(user);
        return ResponseEntity.ok(savedUser);
    } catch (DataAccessException e) {
        log.error("数据库操作失败", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    } catch (Exception e) {
        log.error("创建用户失败", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(null);
    }
}

重构后的代码：

@PostMapping("/users")
public User createUser(@Valid @RequestBody CreateUserRequest request) {
    ExceptionUtils.throwIfTrue(
        userService.existsByName(request.getName()), 
        ErrorCode.USER_ALREADY_EXISTS
    );
    
    return userService.create(request);
}

3. 配置优化

在application.yml中添加相关配置：

# 异常处理配置
exception:
  # 是否显示详细错误信息
  show-detail-message: false
  # 异常日志级别
  log-level: ERROR
  # 敏感字段脱敏
  sensitive-fields:
    - password
    - phone
    - email
    - idCard

# 日志配置
logging:
  level:
    com.yourpackage.exception: DEBUG
  pattern:
    console: "%d{yyyy-MM-dd HH:mm:ss} [%thread] %-5level %logger{36} - %msg%n"
  file:
    name: logs/app.log

4. 测试用例

编写完善的测试用例来验证异常处理机制：

@SpringBootTest
@AutoConfigureTestDatabase
class GlobalExceptionHandlerTest {
    
    @Autowired
    private TestRestTemplate restTemplate;
    
    @Test
    void testBusinessException() {
        ResponseEntity<ErrorResponse> response = restTemplate.getForEntity(
            "/api/users/nonexistent", ErrorResponse.class);
            
        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
        assertNotNull(response.getBody());
        assertEquals("USER_NOT_FOUND", response.getBody().getCode());
    }
    
    @Test
    void testValidationException() {
        CreateUserRequest request = new CreateUserRequest();
        request.setName(""); // 空名称
        
        ResponseEntity<ErrorResponse> response = restTemplate.postForEntity(
            "/api/users", request, ErrorResponse.class);
            
        assertEquals(HttpStatus.BAD_REQUEST, response.getStatusCode());
        assertEquals("VALIDATION_ERROR", response.getBody().getCode());
    }
}

总结

通过本文的介绍，我们了解了Spring Boot微服务中异常处理的最佳实践方案。统一异常处理框架的设计不仅能够提高代码的可维护性和可读性，还能够为用户提供一致的错误响应体验。

关键要点包括：

  1. 使用@ControllerAdvice实现全局异常处理
  2. 设计合理的自定义异常类型体系
  3. 标准化错误响应格式
  4. 在微服务场景下处理Feign客户端异常
  5. 实施完善的日志记录策略
  6. 遵循异常处理的最佳实践原则

通过实施这些最佳实践，开发者可以构建出更加健壮、可维护的Spring Boot微服务应用，告别凌乱的try-catch代码，提升开发效率和代码质量。

本文来自极简博客，作者：逍遥自在，转载请注明原文链接：Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别凌乱的try-catch代码

打赏

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

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

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

  1. sqlmap源码分析(一)
  2. Swoole实践：4-使用Swoole实现在线聊天
  3. php出现的No input file specified
  4. mysql 配置ssl ，java应用连接
  5. Java中的IO操作与流处理
  6. 使用Spring Boot Actuator实现应用监控
  7. Java 21虚拟线程性能优化实测：对比传统线程模型
  8. Spring Boot快速入门与实践
  9. 使用Spring Boot快速搭建Java应用
  10. 如何构建一个响应式的导航栏
  11. Spring Cloud Alibaba实践-Nacos
  12. 解决PHP中的语法错误Parse error: syntax err
  13. 云原生架构下的微服务性能优化全攻略：从容器资源
  14. Java 12的新特性：Switch表达式
  15. 通过API网关实现微服务的统一入口
  16. 解决办法：git错误 "error: failed to push some

Spring Boot微服务异常处理最佳实践：统一异常处理框架设计与实现，告别凌乱的try-catch代码：等您坐沙发呢！

发表评论


快捷键：Ctrl+Enter