统一处理 Spring Boot 应用中的全局异常与错误

好的，没问题！咱们来好好聊聊如何在 Spring Boot 应用中优雅地处理那些“不期而遇”的全局异常与错误，让你的应用即使面对风雨，也能保持优雅的姿态。

文章标题：Spring Boot 全局异常与错误处理：让你的应用优雅地面对“意料之外”

引言：谁还没个“小情绪”呢？

各位看官，咱们写代码就像养孩子，辛辛苦苦拉扯大，总免不了遇到他们闹脾气、耍性子的时候。程序也一样，你以为它会乖乖地按照你的剧本走？Too naive！总会有那么几个“熊孩子”般的异常和错误，冷不丁地跳出来给你添堵。

想象一下，用户正在开心地浏览你的网站，突然屏幕上蹦出一个“500 Internal Server Error”，用户一脸懵逼，内心OS一定是：“What？我做错了什么？” 这时候，你的应用在用户心中的形象瞬间跌落谷底。

所以，如何优雅地处理这些“小情绪”，让用户即使遇到错误，也能感受到你的关怀，就显得尤为重要。Spring Boot 为我们提供了强大的全局异常与错误处理机制，让我们一起来看看如何玩转它。

第一章：什么是全局异常与错误？为什么要全局处理？

什么是异常 (Exception)？

简单来说，异常就是程序在运行过程中遇到的“非正常”情况。比如：
- 空指针异常 (NullPointerException)：你试图访问一个空对象的属性或方法。
- 数组越界异常 (ArrayIndexOutOfBoundsException)：你访问了数组中不存在的索引。
- 文件未找到异常 (FileNotFoundException)：你试图打开一个不存在的文件。
- 数据库连接失败异常 (SQLException)：连接数据库失败了。
这些异常就像代码里的“小感冒”，虽然不致命，但会影响程序的正常运行。
什么是错误 (Error)？

错误比异常更严重，通常表示系统级的故障，程序无法处理。比如：
- 内存溢出错误 (OutOfMemoryError)：程序占用的内存超过了 JVM 允许的最大值。
- 栈溢出错误 (StackOverflowError)：递归调用太深，导致栈空间耗尽。
错误就像代码里的“癌症”，一旦发生，程序很可能直接崩溃。
为什么要全局处理？
- 用户体验至上： 全局处理能保证用户不会看到丑陋的错误页面，而是看到友好的提示信息。
- 统一管理： 将异常处理逻辑集中在一起，方便维护和修改。
- 代码整洁： 避免在每个方法里都写 try-catch 语句，让代码更简洁易读。
- 安全性： 可以记录异常信息，方便排查问题，防止恶意攻击。

第二章：Spring Boot 异常处理的三板斧

Spring Boot 提供了三种主要的异常处理方式：

@ExceptionHandler：针对特定异常进行处理

@ExceptionHandler 注解可以让你在一个 Controller 中定义专门处理特定异常的方法。

示例：
```
@RestController
public class MyController {

    @GetMapping("/divide")
    public int divide(int a, int b) {
        if (b == 0) {
            throw new ArithmeticException("除数不能为0");
        }
        return a / b;
    }

    @ExceptionHandler(ArithmeticException.class)
    public ResponseEntity<String> handleArithmeticException(ArithmeticException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("算术异常： " + ex.getMessage());
    }
}
```
在这个例子中，handleArithmeticException 方法专门处理 ArithmeticException 异常。当 divide 方法抛出 ArithmeticException 时，handleArithmeticException 方法会被调用，返回一个带有错误信息的 ResponseEntity。

优点： 简单易用，针对性强。
缺点： 只能处理当前 Controller 中的异常，不够全局。
@ControllerAdvice：全局异常处理的利器

@ControllerAdvice 注解可以让你创建一个全局的异常处理类，可以处理所有 Controller 中抛出的异常。

示例：
```
@ControllerAdvice
public class GlobalExceptionHandler {

    @ExceptionHandler(ArithmeticException.class)
    public ResponseEntity<String> handleArithmeticException(ArithmeticException ex) {
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body("算术异常： " + ex.getMessage());
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<String> handleGenericException(Exception ex) {
        //记录日志
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body("服务器内部错误： " + ex.getMessage());
    }
}
```
在这个例子中，GlobalExceptionHandler 类使用了 @ControllerAdvice 注解，表示它是一个全局的异常处理类。handleArithmeticException 方法处理 ArithmeticException 异常，handleGenericException 方法处理所有其他类型的异常（Exception.class）。

优点： 全局处理，代码复用性高。
缺点： 所有异常都集中在一个地方处理，可能会导致代码臃肿。

ErrorController：处理默认错误页面

Spring Boot 提供了一个默认的错误页面，当发生未处理的异常时，会显示这个页面。你可以通过实现 ErrorController 接口来定制这个错误页面。

示例：

@Controller
public class CustomErrorController implements ErrorController {

    @RequestMapping("/error")
    public String handleError(HttpServletRequest request) {
        Object status = request.getAttribute(RequestDispatcher.ERROR_STATUS_CODE);

        if (status != null) {
            Integer statusCode = Integer.valueOf(status.toString());

            if(statusCode == HttpStatus.NOT_FOUND.value()) {
                return "error/404";
            }
            else if(statusCode == HttpStatus.INTERNAL_SERVER_ERROR.value()) {
                return "error/500";
            }
        }
        return "error/error";
    }

    @Override
    public String getErrorPath() {
        return "/error";
    }
}

在这个例子中，CustomErrorController 类实现了 ErrorController 接口，并重写了 handleError 方法。这个方法根据不同的错误状态码返回不同的错误页面。你需要创建相应的 error 页面（例如：error/404.html, error/500.html）。

优点： 可以定制默认错误页面，提供更友好的用户体验。
缺点： 只能处理未被 @ExceptionHandler 或 @ControllerAdvice 处理的异常。

第三章：实战演练：打造一个健壮的全局异常处理方案

现在，让我们结合这三种方式，打造一个健壮的全局异常处理方案。

定义自定义异常：

为了更好地管理异常，我们可以定义一些自定义异常，比如：

public class BusinessException extends RuntimeException {
    private int code;

    public BusinessException(int code, String message) {
        super(message);
        this.code = code;
    }

    public int getCode() {
        return code;
    }
}

BusinessException 继承自 RuntimeException，表示业务逻辑上的异常。它包含一个 code 字段，用于表示具体的错误码。

创建全局异常处理类：

@ControllerAdvice
public class GlobalExceptionHandler {

    private static final Logger logger = LoggerFactory.getLogger(GlobalExceptionHandler.class);

    @ExceptionHandler(BusinessException.class)
    public ResponseEntity<ErrorResponse> handleBusinessException(BusinessException ex) {
        logger.error("业务异常： code={}, message={}", ex.getCode(), ex.getMessage());
        ErrorResponse errorResponse = new ErrorResponse(ex.getCode(), ex.getMessage());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }

    @ExceptionHandler(MethodArgumentNotValidException.class)
    public ResponseEntity<ErrorResponse> handleValidationException(MethodArgumentNotValidException ex) {
        BindingResult result = ex.getBindingResult();
        List<FieldError> fieldErrors = result.getFieldErrors();
        StringBuilder errorMessage = new StringBuilder();
        for (FieldError error : fieldErrors) {
            errorMessage.append(error.getField()).append(": ").append(error.getDefaultMessage()).append("; ");
        }
        logger.warn("参数校验异常： {}", errorMessage.toString());
        ErrorResponse errorResponse = new ErrorResponse(400, errorMessage.toString());
        return ResponseEntity.status(HttpStatus.BAD_REQUEST).body(errorResponse);
    }

    @ExceptionHandler(Exception.class)
    public ResponseEntity<ErrorResponse> handleGenericException(Exception ex) {
        logger.error("服务器内部错误： ", ex);
        ErrorResponse errorResponse = new ErrorResponse(500, "服务器内部错误，请稍后再试");
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR).body(errorResponse);
    }
}

在这个例子中，GlobalExceptionHandler 类处理了三种类型的异常：

BusinessException：自定义的业务异常。
MethodArgumentNotValidException：参数校验异常（通常是使用 @Valid 注解时抛出的）。
Exception：所有其他类型的异常。

每个异常处理方法都会记录异常信息，并返回一个 ErrorResponse 对象。

定义错误响应对象：

public class ErrorResponse {
    private int code;
    private String message;

    public ErrorResponse(int code, String message) {
        this.code = code;
        this.message = message;
    }

    public int getCode() {
        return code;
    }

    public String getMessage() {
        return message;
    }
}

ErrorResponse 对象包含错误码和错误信息，用于返回给客户端。

使用自定义异常：

@RestController
public class MyController {

    @GetMapping("/user/{id}")
    public User getUser(@PathVariable int id) {
        if (id <= 0) {
            throw new BusinessException(1001, "用户ID必须大于0");
        }

        // 假设从数据库中获取用户
        User user = userService.getUserById(id);

        if (user == null) {
            throw new BusinessException(1002, "用户不存在");
        }

        return user;
    }
}

在这个例子中，getUser 方法在参数不合法或用户不存在时，会抛出 BusinessException 异常。

配置日志：

为了方便排查问题，我们需要配置日志，将异常信息记录到日志文件中。可以使用 Spring Boot 默认的 Logback 配置，也可以自定义日志配置。

示例 (application.properties):
```
logging.level.com.example = DEBUG  # 设置包的日志级别
logging.file.name=logs/app.log  # 日志文件路径
```

第四章：异常处理的最佳实践

区分异常类型：
- 可恢复异常： 比如网络超时、数据库连接失败等，可以重试或采取其他措施恢复。
- 不可恢复异常： 比如空指针异常、数组越界异常等，通常表示代码存在 Bug，需要修复。
对于可恢复异常，可以进行重试或降级处理；对于不可恢复异常，应该记录日志并返回友好的错误信息。
记录详细的异常信息：

在日志中记录异常类型、错误信息、堆栈跟踪等信息，方便排查问题。
不要吞掉异常：

不要捕获异常后不做任何处理，这样会隐藏问题，导致程序出现不可预知的错误。
提供友好的错误提示：

不要将原始的异常信息直接暴露给用户，而是提供友好的、易于理解的错误提示。
使用 AOP 进行统一处理：

可以使用 AOP (面向切面编程) 将异常处理逻辑与业务逻辑分离，提高代码的可维护性。

关于@Valid注解的参数校验

Spring Boot 提供了强大的参数校验机制，通过@Valid注解可以很方便地对请求参数进行校验。当校验失败时，会抛出 MethodArgumentNotValidException 异常，我们需要在 GlobalExceptionHandler 中处理这个异常，并返回相应的错误信息。

示例：

首先，定义一个需要校验的 DTO (Data Transfer Object)：

import javax.validation.constraints.NotBlank;
import javax.validation.constraints.Size;

public class UserDTO {

   @NotBlank(message = "用户名不能为空")
   @Size(min = 2, max = 20, message = "用户名长度必须在2到20之间")
   private String username;

   @NotBlank(message = "密码不能为空")
   @Size(min = 6, max = 30, message = "密码长度必须在6到30之间")
   private String password;

   // Getters and setters
   public String getUsername() {
       return username;
   }

   public void setUsername(String username) {
       this.username = username;
   }

   public String getPassword() {
       return password;
   }

   public void setPassword(String password) {
       this.password = password;
   }
}

然后，在 Controller 中使用 @Valid 注解：

@RestController
public class MyController {

   @PostMapping("/register")
   public ResponseEntity<String> register(@Valid @RequestBody UserDTO userDTO) {
       // 处理注册逻辑
       return ResponseEntity.ok("注册成功");
   }
}

最后，在 GlobalExceptionHandler 中处理 MethodArgumentNotValidException 异常（参考之前的示例）。

第五章：总结：让错误成为进步的阶梯

各位看官，全局异常与错误处理是 Spring Boot 应用开发中不可或缺的一部分。通过合理地使用 @ExceptionHandler、@ControllerAdvice 和 ErrorController，我们可以打造一个健壮、友好的应用，让错误不再是绊脚石，而是成为我们进步的阶梯。

记住，优雅地处理异常，不仅能提升用户体验，还能提高代码的可维护性和安全性。所以，下次遇到“熊孩子”般的异常时，不要慌张，拿起你的“三板斧”，优雅地解决它吧！

希望这篇文章能帮助你更好地理解 Spring Boot 的全局异常与错误处理机制。 Happy coding!

发表回复 取消回复

发表回复取消回复