SpringBoot异常处理？用这两个就够啦！

￡神魔★判官ぃ 2024-03-25 10:18 65阅读 0赞

在日常项目中，我们难免会遇到系统错误的情况。如果对系统异常的情况不做处理，Springboot本身会默认将错误异常作为接口的请求返回。

@GetMapping("/testNorError")
     public void testNorError() {
         try {
             throw new MyException(6000, "我的错误");
         }catch (Exception e){
             throw new MyException(5000, "我的包装异常", e);
         }
     }
    复制代码

![format_png][]

从上图可以看到，Springboot没有对异常进行处理的情况下，将错误的堆栈直接当做响应数据返回了。这样对用户既不友好，又可能因为泄漏系统堆栈信息引发潜在的安全风险。因此，搭建一个完善的异常处理机制，对于维护系统健壮性是十分必要的。

### 通用异常处理 ###

要快速的搭建异常处理机制，那么需要考虑如何对异常进行捕获并加以处理？最便捷的方法便是用 **@ExceptionHandler**注解实现。

@ExceptionHandler(MyException.class)
         protected ResponseEntity<Object> handleException(Exception ex) {
             LOGGER.error("Failed to execute,handleException:{}", ex.getMessage(), ex);
             return new ResponseEntity<>(new ResultDTO().fail(ResultCodeEnum.ERROR_SERVER), HttpStatus.OK);
         }
    复制代码

通过在Controller内添加上述的异常处理代码，Springboot就可以将相关的错误信息转义成系统的统一错误处理，进而避免堆栈外露。(这里的ResultDTO是系统内自定义的JSON结构，可以根据自己的业务自行修改。)

![format_png 1][]

然而，@ExceptionHandler本身存在一个弊端，就是他作用的范围必须是Controller，也就意味着有多少个Controller，你的异常处理代码便要重复写多遍，这无疑是低效率的。为了减少重复的代码冗余，@ControllerAdvance就进入了我们的视野。

@ControllerAdvice
     @Slf4j
     public class ExtGlobalExceptionHandler {
         
         @ExceptionHandler(Exception.class)
         protected ResponseEntity<Object> handleException(Exception ex) {
             LOGGER.error("Failed to execute,handleException:{}", ex.getMessage(), ex);
             return new ResponseEntity<>(new ResultDTO().fail(ResultCodeEnum.ERROR_SERVER), HttpStatus.OK);
         }
     }
    复制代码

简单来说，@ControllerAdvance是一个全局处理的注解，其中的代码会对所有的Controller生效，通常会搭配@ExceptionHandler处理异常，由此以来就可以实现只编写一次异常处理方法就可以处理全局异常的情况。

至于@ControllerAdvance和@ExceptionHandler是如何实现这个神奇的功能的，限于篇幅原因，后续会考虑单独出一篇文章详细介绍。（其实根据名字，不难推断ControllerAdvance就是一种针对于Controller对象的动态代理罢了。）

### 个性化异常处理 ###

用了@ControllerAdvance和ExceptionHandler，几乎可以解决80%的项目面临的报错处理问题。然而，思考一下。如果一个项目中出现了多组人同时维护、迭代一个系统的时候（降本增效嘛，懂的都懂），每组人要关注的报错自然会不一样。如A组人只关注报错A，B组人员只关注报错B，那么这种通用的异常解决方案是无法区分开的。

针对于这种情况，就不得不请出另外一位大佬了，他就是：AOP，针对于动态代理有很多的实现方式和框架，这里我们直接默认采用SpringBoot的自带AOP框架：

<dependency>
         <groupId>org.springframework.boot</groupId>
         <artifactId>spring-boot-starter-aop</artifactId>
         <version>2.1.11.RELEASE</version>
     </dependency>
    复制代码

不管选择的AOP实现框架是什么，要采用AOP编码都少不了以下两个步骤：

**1、定义切点和执行时机（哪些地方要做增强）**

**2、定义通知（要怎么增强）**

#### 定义切点和执行时机 ####

对于Springboot自带的AOP框架，其执行时机共有以下五个：

<table> 
 <thead> 
  <tr> 
   <th>增强时机</th> 
   <th>增强类型</th> 
   <th>异同点</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td>@After</td> 
   <td>后置增强</td> 
   <td>目标方法执行之后调用增强方法</td> 
  </tr> 
  <tr> 
   <td>@Before</td> 
   <td>前置增强</td> 
   <td>目标方法执行之前先调用增强方法</td> 
  </tr> 
  <tr> 
   <td>@AfterReturning</td> 
   <td>返回增强</td> 
   <td>目标方法执行return之后返回结果之前调用增强方法，如果出异常则不执行</td> 
  </tr> 
  <tr> 
   <td>@AfterThrowing</td> 
   <td>异常增强</td> 
   <td>目标方法执行产生异常调用增强方法，需注意的是，处理后异常依旧会往上抛出，不会被catch。</td> 
  </tr> 
  <tr> 
   <td>@Around</td> 
   <td>环绕增强</td> 
   <td>环绕增强包含前面四种增强，通过一定的try-catch处理，环绕类型可以替代上述的任意一种增强。</td> 
  </tr> 
 </tbody> 
</table>

了解了SpringBoot的动态代理的执行时机之后，我们还需要知道其定义切点的方式。框架定义切点的方式主要有两个：

*  **切点表达式**
 *  **注解**

注释

我们首先介绍注释的正确打开方式。要通过注解来实现自己的AOP，那么首先需要定义一个新的注解。这里我简单定义了一个注解：

@Target({ElementType.TYPE, ElementType.METHOD, ElementType.PARAMETER})
     @Retention(RetentionPolicy.RUNTIME)
     @Documented
     public @interface MyAnnotation {
         
         String SERVER_NAME() default "";
     
         String action() default "";
     }
    复制代码

在定义了注解以后，将注解定义为方法的入参，并通过@annotation()标注出注解的变量名称，由此就可以实现注解AOP的功能。

//处理注解的地方
     @Around(value = "@annotation(name)")
     public <T> T test(ProceedingJoinPoint point, MyAnnotation name) throws Throwable {
         String serverName = name.SERVER_NAME();
         //处理异常
         return handlerRpcException(point, serverName);
     }
     
     //具体代码执行处
     @MyAnnotation(SERVER_NAME = "下游系统", action = "操作处理")
     public <T> T testFunction() {
         return (T) new ResultDTO<>().success(Boolean.TRUE);
     }
    复制代码

切点表达式

Springboot的AOP中，还提供了一种十分强大的实现动态代理切点标注的方式，即切点表达式，其基本模式如下所示：

execution(modifiers-pattern? ret-type-pattern declaring-type-pattern? name-pattern(param-pattern) throws-pattern?)
    复制代码

注意到modifiers-pattern?、declaring-type-pattern?、throws-pattern?等携带问号的参数都是非必填的。紧接着我们来逐一介绍上述参数的含义：

*  **modifiers-pattern?** ：修饰符匹配，主要表示的是切点是public/private/protected/default的哪一种。
 *  **ret-type-pattern**：顾名思义，指的是返回值的类型，常见如：void/Boolean/String等
 *  **declaring-type-pattern?** ：这个指的是被增强的方法、属性的类路径，如com.example.demo.service.aop.MyAspect等
 *  **name-pattern(param-pattern)** ：这个是相对关键的参数，指的是被增强的方法名称以及其对应的参数类型。
 *  **throws-pattern**：throw-pattern见词知意，可以知道它是指的方法所抛出的异常类型。

除了了解了上述的表达式的基本匹配含义以外，还有几个特殊的符号通配指的提一下：

\*\*\*\*\* ：匹配任何数量字符 **..** ：匹配任何数量字符的重复，如在类型模式中匹配任何数量子包；而在方法参数模式中匹配任何数量参数（0个或者多个参数） **+** ：匹配指定类型及其子类型；仅能作为后缀放在类型模式后边

也许上面的代码和介绍让你一脸懵逼，没关系，可以简单看下下面两个表达式的含义，你就大致明白他们的含义了：

// 1、代表【返回值任意】且前缀为【com.example.demo.rpc】的【任意类下】【任意名称】的【所有参数】方法
     execution(* com.example.demo.rpc.*.*(..))
     
     // 2、代表【返回值为Boolean】且位于【com.example.demo.rpc及其子包下】的【任意名称】的【以String为最后一个入参数】的方法
     execution(Boolean com.example.demo.rpc..*(.., String))
    复制代码

借助于切面表达式，我们可以很自由灵活地定义出我们的切点，从而通过AOP实现我们对于异常的处理

@Pointcut("execution(Boolean com.example.demo.rpc..*(.., String)) || execution(另外一个表达式)")
    	private void PointCutOfAnno() {
    }
    
    @Around(value = "PointCutOfAnno()")
    public <T> T testForAOP(ProceedingJoinPoint point) throws Throwable {
        //处理对应的异常
        return handlerRpcException(point, serverName);
    }
    复制代码

### 总结 ###

本文介绍了两种Springboot下针对于异常处理的编写方法：

一、借助于@ControllerAdvance和@ExceptionHandler实现的通用异常处理方法

二、借助于AOP实现的个性化异常处理机制。

两者其实本质上的实现思路都是一样的，通过对执行代码做动态代理，从而将错误包装起来，达到异常不外漏的效果。在实际业务场景中，方法一几乎可以涵盖80%的异常处理场景。方案二则主要针对一个系统中需要做个性化处理的情况，可以根据具体的业务需要进行选择。

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b94c44f6f5ba4ee6a753d3accec6f0fb.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/06fd4e7f9e3644fcbd13c3f2c07d8c40.png