Spring统一异常处理

艺帆风顺 发布于 2025-04-03 31 次阅读

Spring 统一异常处理

非统一异常处理

在传统的非统一异常处理方式中，每个代码块都需要单独编写 try...catch... 语句来捕获异常，例如：

  1. A代码: try...catch...
  2. B代码: try...catch...
  3. C代码: try...catch...
  4. D代码: try...catch...

这种方式会导致代码冗余，并且难以维护。

统一异常处理

在 Spring 中，我们可以使用 AOP（面向切面编程）的思想来实现异常的统一处理。核心是利用 Spring 提供的两个注解 @RestControllerAdvice 和 @ExceptionHandler。

任务步骤

整个统一异常处理的任务主要分为以下几个步骤：

  1. 自定义统一异常类 BizException：规范异常类型，方便 ExceptionHandler 进行处理。
  2. 前置异常捕获：对 controller 进行切面编程，实现对 BindingResult（即调用者请求参数）的统一异常/校验处理。
  3. 业务异常捕获：对 service 进行切面编程，捕获所有的 service 异常，统一封装为 BizException，再返回给 controller，便于 RestControllerAdvice 和 ExceptionHandler 处理异常类型。
  4. 全局异常处理器：在全局异常处理器中，也就是 RestControllerAdvice 和 ExceptionHandler 的处理方法中，封装响应结果并返回给调用者。

关键代码

依赖包

在 pom.xml 中添加以下依赖：

  3.     javax.validation
  4.     validation-api
  5.     2.0.1.Final
  9.     org.springframework.boot
  10.     spring-boot-starter-validation
  14.     org.springframework.boot
  15.     spring-boot-starter-aop
  18.     org.springframework.boot
  19.     spring-boot-starter-web
  22.     org.projectlombok
  23.     lombok
  24.     true

统一异常定义

自定义 BizException 类，继承自 RuntimeException：

  1. public class BizException extends RuntimeException {
  2.     private String code;
  3.     private String msg;
  5.     public BizException(String code, String msg) {
  6.         this.code = code;
  7.         this.msg = msg;
  8.     }
  10.     public String getCode() {
  11.         return code;
  12.     }
  14.     public String getMsg() {
  15.         return msg;
  16.     }
  17. }

前置异常捕获

创建 ControllerAspect 类，对 controller 进行切面编程：

  1. /**
  2.  * 前置异常切面
  3.  */
  4. @Aspect
  5. @Component
  6. public class ControllerAspect {
  7.     private static final Logger log = LoggerFactory.getLogger(ControllerAspect.class);
  9.     @Pointcut("@annotation(org.springframework.web.bind.annotation.RequestMapping)" +
  10.             "&&args(..,org.springframework.validation.BindingResult)")
  11.     public void controllerAspect() {
  12.     }
  14.     @Around("controllerAspect()")
  15.     public Object doBefore(ProceedingJoinPoint joinPoint) throws Throwable {
  16.         Object[] args = joinPoint.getArgs();
  17.         for (Object arg : args) {
  18.             if (arg instanceof BindingResult) {
  19.                 BindingResult result = (BindingResult) arg;
  20.                 if (result.hasErrors()) {
  21.                     log.error("请求参数校验错误");
  22.                     FieldError fieldError = result.getFieldError();
  23.                     if (fieldError != null) {
  24.                         throw new BizException("111111", fieldError.getDefaultMessage());
  25.                     }
  26.                     throw new BizException("222222", "未知参数错误┭┮﹏┭┮");
  27.                 }
  28.             }
  29.         }
  30.         return joinPoint.proceed();
  31.     }
  32. }

业务异常捕获

创建 ServiceAspect 类，对 service 进行切面编程：

  1. /**
  2.  * Service异常捕获，将Service中的所有异常，转换为统一的BizException，方便ExceptionHandler统一处理
  3.  */
  4. @Aspect
  5. public class ServiceAspect {
  6.     @Pointcut("execution(public * com.example.exception.service.*.*(..))")
  7.     public void serviceAspect() {
  8.     }
  10.     @Around("serviceAspect()")
  11.     public Object doAround(ProceedingJoinPoint joinPoint) throws Throwable {
  12.         try {
  13.             return joinPoint.proceed();
  14.         } catch (Exception e) {
  15.             if (e instanceof BizException) {
  16.                 throw e;
  17.             } else {
  18.                 throw new BizException("999999", "系统错误^_^");
  19.             }
  20.         }
  21.     }
  22. }

全局异常处理器

创建 GlobalExceptionHandler 类，处理全局异常：

  1. @RestControllerAdvice
  2. public class GlobalExceptionHandler {
  3.     private static final Logger log = LoggerFactory.getLogger(GlobalExceptionHandler.class);
  5.     /**
  6.      * 业务异常处理
  7.      */
  8.     @ExceptionHandler(BizException.class)
  9.     public ResponseEntity bizExceptionHandler(BizException e) {
  10.         return ResponseUtil.fail(e);
  11.     }
  13.     /**
  14.      * 通用异常处理
  15.      */
  16.     @ExceptionHandler(Exception.class)
  17.     public ResponseEntity exceptionHandler(Exception e) {
  18.         log.error(e.getMessage(), e);
  19.         return ResponseUtil.fail("999999", "系统错误(#^.^#)");
  20.     }
  21. }

通过以上步骤和代码，我们可以实现 Spring 中的统一异常处理，提高代码的可维护性和可读性。