• 如何优雅的进行Controller全局异常处理？

    【Spring Boot系列】 如何优雅的进行Controller全局异常处理？

    【Spring Boot系列】 如何优雅的进行Controller全局异常处理？

    在进入正题之前，先给大家看一段代码，如下所示。

    1. package com.panda.handle_try_catch_gracefully.controller;
    2.  
    3. import com.panda.handle_try_catch_gracefully.common.Result;
    4. import com.panda.handle_try_catch_gracefully.domain.po.User;
    5. import com.panda.handle_try_catch_gracefully.domain.vo.UserVO;
    6. import com.panda.handle_try_catch_gracefully.enums.ExceptionEnum;
    7. import com.panda.handle_try_catch_gracefully.exceptions.BusinessException;
    8. import com.panda.handle_try_catch_gracefully.service.IUserService;
    9. import org.springframework.web.bind.annotation.*;
    10.  
    11. import javax.annotation.Resource;
    12. import java.util.List;
    13.  
    14. @RestController
    15. @RequestMapping("ori/user")
    16. public class OriginUserController {
    17.     @Resource
    18.     private IUserService userService;
    19.  
    20.     @GetMapping("getUserInfo")
    21.     public Result<UserVO> getUserInfo(String userId) {
    22.         try {
    23.             return userService.getUserInfo(userId);
    24.         } catch (Exception e) {
    25.             throw new BusinessException(ExceptionEnum.INTERNAL_SERVER_ERROR);
    26.         }
    27.     }
    28.  
    29.     @PostMapping("listUserInfo")
    30.     public Result<List<UserVO>> listUserInfo(UserVO query) {
    31.         try {
    32.             return userService.listUserInfo(query);
    33.         } catch (Exception e) {
    34.             throw new BusinessException(ExceptionEnum.INTERNAL_SERVER_ERROR);
    35.         }
    36.     }
    37.  
    38.     @PostMapping("saveUser")
    39.     public Result<String> saveUser(User user) {
    40.         try {
    41.             return userService.saveUser(user);
    42.         } catch (Exception e) {
    43.             throw new BusinessException(ExceptionEnum.INTERNAL_SERVER_ERROR);
    44.         }
    45.     }
    46.  
    47.     @PostMapping("updateUser")
    48.     public Result<Boolean> updateUser(User user) {
    49.         try {
    50.             return userService.updateUser(user);
    51.         } catch (Exception e) {
    52.             throw new BusinessException(ExceptionEnum.INTERNAL_SERVER_ERROR);
    53.         }
    54.     }
    55.  
    56.     @PostMapping("deleteUser")
    57.     public Result<Boolean> deleteUser(@RequestParam("userId") String userId) {
    58.         try {
    59.             return userService.deleteUser(userId);
    60.         } catch (Exception e) {
    61.             throw new BusinessException(ExceptionEnum.INTERNAL_SERVER_ERROR);
    62.         }
    63.     }
    64. }

    不知道大家在项目中是否遇到过上面这种情况——controller里满屏的try-catch代码块，真的是闪瞎了我的钛合金狗眼呀。

    虽然丑陋，但是这些try-catch代码块还是起到了一定的作用的——给前端响应一些通俗易懂的提示信息，如“用户编码不能为空”、“保存用户信息异常”、“更新用户信息失败”等。

    如果没有这些丑陋的try-catch代码块，一旦抛出异常，用户看到的可能就是类似

    1. Exception in thread "main" java.lang.ArithmeticException: / by zero
    2.  
    3. Exception in thread "main" java.lang.NullPointerException
    4.  
    5. Exception in thread "main" java.lang.IndexOutOfBoundsException: Index 2 out of bounds for length 0

    之类的错误信息，对用户来说，无异于天书，极大地降低了用户体验度。

    try-catch：虽然我长得丑，但是我有用呀！

    这当然是我们不能容忍的！

    作为一个有着强迫症的程序员，怎么能容忍这样的代码出现在我的项目中呢！

    外行看热闹，可能看不出上面这段代码有什么丑陋的，但是，内行看门道，一眼就可以看出上面代码的丑陋之处。说一千道一万，上面这段代码究竟丑陋在哪里呢？

    上面也提到了，try-catch代码块满屏飞，且处理逻辑一致，都是捕获异常，然后抛出异常或者返回错误信息，但这并不符合代码的可重用原则。

    上面的代码只是一个controller，一个项目中可能有几十上百，甚至更多个controller呢！因此，对这块代码的主要优化思路，就是找出一种方法代替多次出现的try-catch代码块，并且原有的功能不能缺失。

    这种方法就是本文要讲的内容——全局异常处理！

    全局异常处理

    所谓全局异常处理，也叫统一异常处理，是一种统一处理异常的思路。

    这种方法的好处在于，只需要在一个地方处理异常逻辑，就可以将controller的异常给捕获掉，而不用我们在每个controller类中写重复且丑陋的try-catch代码块，来捕获异常。

    Spring Boot 的全局异常处理有两个很重要的注解，一个是ControllerAdvice注解或者RestControllerAdvice注解，另一个是ExceptionHandler注解。

    ControllerAdvice注解或者RestControllerAdvice注解在类上使用，表示开启全局异常的捕获。

    ExceptionHandler注解在方法上使用，可以通过value属性指定一个或多个异常，并捕获指定的异常，一般在方法体内对捕获到的异常进行解析，然后进行输出或返回等操作。

    ControllerAdvice注解

    简介

    ControllerAdvice注解是Spring 3.2中新增的一个注解，是Controller的增强器，它的作用是给Controller（控制器）添加统一的操作或处理。

    ControllerAdvice注解最常见的使用场景就是，结合ExceptionHandler注解用于全局异常处理。

    ControllerAdvice注解是在类上声明的注解，用法主要有以下三点：

    全局异常处理

    结合ExceptionHandler注解，用于捕获Controller中抛出的指定类型的异常，从而达到不同类型的异常区别处理的目的。

    全局数据预处理

    结合InitBinder注解，用于对请求参数预处理，将表单中的参数绑定到实体上，或者对日期、金额类参数进行格式转换等。

    全局数据绑定

    结合ModelAttribute注解，将方法参数或方法返回值绑定到命名模型属性，该属性向web视图公开。

    属性

    basePackages

    该属性可以指定一个或多个包路径，这些包及其子包下的所有Controller都被ControllerAdvice注解管理。

    1. @RestControllerAdvice(basePackages={"com.panda","com.cat"})
    2. public class GlobalExceptionHandler {    
    3.     @ExceptionHandler(Exception.class)    
    4.     public String handleException(Exception e) {    
    5.         return "error";
    6.     }   
    7. }
    basePackageClasses

    该属性的作用和 basePackages 差不多。

    该属性可以指定一个或多个Controller类，这些类所属的包及其子包下的所有 Controller 都被该ControllerAdvice注解管理。

    1. @RestControllerAdvice(basePackageClasses={UserController.class, OrderController.class})
    2. public class GlobalExceptionHandler {    
    3.     @ExceptionHandler(Exception.class)    
    4.     public String handleException(Exception e) {    
    5.         return "error";
    6.     }   
    7. }
    assignableTypes

    该属性指定一个或多个 Controller 类，这些类被该ControllerAdvice注解管理。

    1. @RestControllerAdvice(assignableTypes={UserController.class, OrderController.class})
    2. public class GlobalExceptionHandler {    
    3.     @ExceptionHandler(Exception.class)    
    4.     public String handleException(Exception e) {    
    5.         return "error";
    6.     }   
    7. }
    annotations

    该属性指定一个或多个注解，被这些注解所标记的Controller会被该ControllerAdvice注解管理。

    1. @RestControllerAdvice(annotations = {UserAnnotation.class, OrderAnnotation.class})
    2. public class GlobalExceptionHandler {    
    3.     @ExceptionHandler(Exception.class)    
    4.     public String handleException(Exception e) {    
    5.         return "error";
    6.     }   
    7. }

    RestControllerAdvice注解

    简介

    RestControllerAdvice注解是一个组合注解，由ControllerAdvice注解和ResponseBody注解组成。可见其作用和ControllerAdvice注解差不多。

    RestControllerAdvice注解是Spring 4.3中新增的一个注解，也是Controller的增强器，它的作用同样是给Controller（控制器）添加统一的操作或处理。

    RestControllerAdvice注解和ControllerAdvice注解的区别

    1、当我们自定义的全局异常处理类加上ControllerAdvice注解时，如果异常处理方法需要返回json数据，则需要给每个异常处理方法添加ResponseBody注解。

    2、当我们自定义的全局异常处理类加上RestControllerAdvice注解时，异常处理方法自动返回JSON格式的数据，我们不需要在该方法上再添加ResponseBody注解。

    属性

    该注解的属性和ControllerAdvice注解的属性相同，不再赘述。

    ExceptionHandler注解

    简介

    ExceptionHandler注解用来统一处理方法抛出的异常。

    被ExceptionHandler注解标注的方法支持以下参数类型

    1. 异常参数，如Exception.class、RuntimeException等。
    2. 请求和/或响应对象（通常来自Servlet API），例如javax.servlet.ServletRequest 或者 javax.servlet.http.HttpServletRequest。
    3. session对象，如javax.servlet.http.HttpSession。
    4. org.springframework.web.context.request.WebRequest 或者 org.springframework.web.context.request.NativeWebRequest。
    5. 表示当前请求区域设置的的java.util.Locale对象，例如org.springframework.web.servlet.LocaleResolver。
    6. java.io.InputStream 或者 java.io.Reader。
    7. java.io.OutputStream 或者 java.io.Writer。
    8. org.springframework.ui.Model。

    被ExceptionHandler注解标注的方法支持以下返回类型

    1. ModelAndView类型。
    2. org.springframework.ui.Model类型。
    3. java.util.Map类型。
    4. org.springframework.web.servlet.View类型。
    5. String类型。
    6. ResponseBody注解方法（仅限Servlet）以设置响应内容。
    7. HttpEntity 或者 ResponseEntity 类型。
    8. void类型。

    属性

    value

    指定需要处理的一个或者多个异常类。

    如果为空，则默认处理异常处理方法参数列表中列出的所有异常。

    1. @ExceptionHandler(value = BusinessException.class)
    2. public <T> Result<T> businessExceptionHandler(BusinessException businessException) {
    3.     log.error(businessException.getErrorMsg(), businessException);
    4.     return Result.fail(businessException.getCode(), businessException.getErrorMsg());
    5. }
    6.  
    7. @ExceptionHandler
    8. public <T> Result<T> exceptionHandler1(Exception exception) {
    9.     log.error(exception.getMessage());
    10.     ExceptionEnum exceptionEnum = ExceptionEnum.UNKNOWN;
    11.     if (exception instanceof BusinessException) {
    12.         exceptionEnum = ExceptionEnum.INTERNAL_SERVER_ERROR;
    13.     }
    14.     if (exception instanceof IndexOutOfBoundsException) {
    15.         exceptionEnum = ExceptionEnum.ILLEGAL_ARGUMENT_ERROR;
    16.     }
    17.     return Result.fail(exceptionEnum);
    18. }

    代码示例

    搭建Spring Boot项目的过程就不在赘述了，项目结构如下所示。

    POM.xml代码

    1. <?xml version="1.0" encoding="UTF-8"?>
    2. <project xmlns="http://maven.apache.org/POM/4.0.0"
    3.          xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
    4.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
    5.     <parent>
    6.         <artifactId>mykits</artifactId>
    7.         <groupId>com.panda</groupId>
    8.         <version>0.0.1-SNAPSHOT</version>
    9.     </parent>
    10.     <modelVersion>4.0.0</modelVersion>
    11.  
    12.     <artifactId>handle-try-catch-gracefully</artifactId>
    13.  
    14.     <properties>
    15.         <maven.compiler.source>11</maven.compiler.source>
    16.         <maven.compiler.target>11</maven.compiler.target>
    17.     </properties>
    18.  
    19.     <dependencies>
    20.         <dependency>
    21.             <groupId>com.google.guava</groupId>
    22.             <artifactId>guava</artifactId>
    23.         </dependency>
    24.  
    25.         <dependency>
    26.             <groupId>org.apache.commons</groupId>
    27.             <artifactId>commons-lang3</artifactId>
    28.         </dependency>
    29.  
    30.         <dependency>
    31.             <groupId>commons-io</groupId>
    32.             <artifactId>commons-io</artifactId>
    33.         </dependency>
    34.  
    35.         <dependency>
    36.             <groupId>commons-collections</groupId>
    37.             <artifactId>commons-collections</artifactId>
    38.         </dependency>
    39.  
    40.         <dependency>
    41.             <groupId>commons-codec</groupId>
    42.             <artifactId>commons-codec</artifactId>
    43.         </dependency>
    44.     </dependencies>
    45. </project>

    UserController.java代码

    controller类，和上面的OriginUserController相比，代码量少了很多——try-catch代码块消失了。

    放眼望去，整体代码清爽不少，核心代码尽收眼底。

    1. package com.panda.handle_try_catch_gracefully.controller;
    2.  
    3. import com.panda.handle_try_catch_gracefully.common.Result;
    4. import com.panda.handle_try_catch_gracefully.domain.po.User;
    5. import com.panda.handle_try_catch_gracefully.domain.vo.UserVO;
    6. import com.panda.handle_try_catch_gracefully.service.IUserService;
    7. import org.springframework.web.bind.annotation.*;
    8.  
    9. import javax.annotation.Resource;
    10. import java.util.List;
    11.  
    12. @RestController
    13. @RequestMapping("user")
    14. public class UserController {
    15.  
    16.     @Resource
    17.     private IUserService userService;
    18.  
    19.     @GetMapping("getUserInfo")
    20.     public Result getUserInfo(String userId) {
    21.         return userService.getUserInfo(userId);
    22.     }
    23.  
    24.     @PostMapping("listUserInfo")
    25.     public Result> listUserInfo(UserVO query) {
    26.         return userService.listUserInfo(query);
    27.     }
    28.  
    29.     @PostMapping("saveUser")
    30.     public Result saveUser(User user) {
    31.         return userService.saveUser(user);
    32.     }
    33.  
    34.     @PostMapping("updateUser")
    35.     public Result<Boolean> updateUser(User user) {
    36.         return userService.updateUser(user);
    37.     }
    38.  
    39.     @PostMapping("deleteUser")
    40.     public Result<Boolean> deleteUser(@RequestParam("userId") String userId) {
    41.         return userService.deleteUser(userId);
    42.     }
    43. }

    Result.java代码

    封装的统一返回结果。

    code：响应结果代码，在本文中，可以是自定义的代码，也可以是ExceptionEnum枚举的code。

    msg：错误信息。主要在方法调用失败时，返回给前端的提示信息。当然在方法调用成功时，也可以返回给前端一个类似“请求成功”之类的信息。

    successFlag：响应成功与否的标志。true表示成功，false表示失败。

    data：返回给前端的数据。一般只有在响应成功时才会向前端返回数据，以查询类方法居多。

    1. package com.panda.handle_try_catch_gracefully.common;
    2.  
    3. import com.panda.handle_try_catch_gracefully.enums.ExceptionEnum;
    4.  
    5. public class Result<T> {
    6.     private String code;
    7.  
    8.     private String msg;
    9.  
    10.     private Boolean successFlag;
    11.  
    12.     private T data;
    13.  
    14.     public static <T> Result<T> success() {
    15.         Result<T> result = new Result<>();
    16.         result.successFlag(true);
    17.         return result;
    18.     }
    19.  
    20.     public static <T> Result<T> success(T data) {
    21.         Result<T> result = new Result<>();
    22.         result.successFlag(true).data(data);
    23.         return result;
    24.     }
    25.  
    26.     public static <T> Result<T> fail(String code, String errorMsg) {
    27.         Result<T> result = new Result<>();
    28.         result.successFlag(false).code(code).msg(errorMsg);
    29.         return result;
    30.     }
    31.  
    32.     public static <T> Result<T> fail(ExceptionEnum exceptionEnum) {
    33.         Result<T> result = new Result<>();
    34.         result.successFlag(false).code(exceptionEnum.getCode()).msg(exceptionEnum.getErrorMsg());
    35.         return result;
    36.     }
    37.  
    38.     public Result<T> code(String code) {
    39.         this.code = code;
    40.         return this;
    41.     }
    42.  
    43.     public Result<T> msg(String msg) {
    44.         this.msg = msg;
    45.         return this;
    46.     }
    47.  
    48.     public Result<T> successFlag(Boolean successFlag) {
    49.         this.successFlag = successFlag;
    50.         return this;
    51.     }
    52.  
    53.     public Result<T> data(T data) {
    54.         this.data = data;
    55.         return this;
    56.     }
    57.  
    58.     public String getCode() {
    59.         return code;
    60.     }
    61.  
    62.     public String getMsg() {
    63.         return msg;
    64.     }
    65.  
    66.     public T getData() {
    67.         return data;
    68.     }
    69.  
    70.     public Boolean getSuccessFlag() {
    71.         return successFlag;
    72.     }
    73. }

    User.java代码

    用户信息实体类。

    在实际项目中，User的各个属性一般对应用户表的各个字段。

    1. package com.panda.handle_try_catch_gracefully.domain.po;
    2.  
    3. import lombok.Data;
    4.  
    5. import java.util.Date;
    6.  
    7. @Data
    8. public class User {
    9.  
    10.     private String id;
    11.  
    12.     private String name;
    13.  
    14.     private String mobilePhone;
    15.  
    16.     private Date createTime;
    17.  
    18.     private String createBy;
    19.  
    20.     private Date updateTime;
    21.  
    22.     private String updateBy;
    23.  
    24.     private Integer validFlag;
    25.  
    26.     private Integer deleteFlag;
    27. }

    UserVO.java代码

    用户信息。

    返回给前端的实体类。

    在本文中，为了省事，也作为查询条件。在实际项目中，应该和查询条件区分开，用类似UserQuery之类的实体表示用户查询条件。

    1. package com.panda.handle_try_catch_gracefully.domain.vo;
    2.  
    3. import com.panda.handle_try_catch_gracefully.domain.po.User;
    4. import lombok.Data;
    5.  
    6. @Data
    7. public class UserVO extends User {
    8.     
    9. }

    ExceptionEnum.java代码

    异常枚举类。

    code：异常代码。

    errorMsg：异常提示信息。

    1. package com.panda.handle_try_catch_gracefully.enums;
    2.  
    3. public enum ExceptionEnum {
    4.     /**
    5.      * 请求错误！
    6.      */
    7.     BAD_REQUEST("400", "请求错误！"),
    8.     /**
    9.      * 未经授权的请求！
    10.      */
    11.     UNAUTHORIZED("401", "未经授权的请求！"),
    12.     /**
    13.      * 没有访问权限！
    14.      */
    15.     FORBIDDEN("403", "没有访问权限！"),
    16.     /**
    17.      * 请求的资源未不到！
    18.      */
    19.     NOT_FOUND("404", "请求的资源未不到！"),
    20.     /**
    21.      * 服务器内部错误！
    22.      */
    23.     INTERNAL_SERVER_ERROR("500", "服务器内部错误！"),
    24.     /**
    25.      * 服务器正忙，请稍后再试！
    26.      */
    27.     BAD_GATEWAY("502", "服务器正忙，请稍后再试！"),
    28.     /**
    29.      * 服务器正忙，请稍后再试！
    30.      */
    31.     SERVICE_UNAVAILABLE("503", "服务器正忙，请稍后再试！"),
    32.     /**
    33.      * 网关超时！
    34.      */
    35.     GATEWAY_TIMEOUT("504", "网关超时！"),
    36.     /**
    37.      * 非法参数异常！
    38.      */
    39.     ILLEGAL_ARGUMENT_ERROR("10000", "非法参数异常！"),
    40.     /**
    41.      * 用户ID不能为空！
    42.      */
    43.     USER_ID_NOT_BLANK("10001", "用户ID不能为空！"),
    44.     /**
    45.      *
    46.      */
    47.     UNKNOWN("9999", "未知异常！");
    48.  
    49.     /**
    50.      * 错误码
    51.      */
    52.     private final String code;
    53.  
    54.     /**
    55.      * 错误描述
    56.      */
    57.     private final String errorMsg;
    58.  
    59.     ExceptionEnum(String code, String errorMsg) {
    60.         this.code = code;
    61.         this.errorMsg = errorMsg;
    62.     }
    63.  
    64.     public String getCode() {
    65.         return code;
    66.     }
    67.  
    68.     public String getErrorMsg() {
    69.         return errorMsg;
    70.     }
    71. }

    BusinessException.java代码

    在实际项目中，推荐使用自定义的业务异常类，而不用RuntimeException。

    如果代码中抛出了RuntimeException，IDEA会提示上图之类的信息（可能要安装插件）。

    1. package com.panda.handle_try_catch_gracefully.exceptions;
    2.  
    3. import com.panda.handle_try_catch_gracefully.enums.ExceptionEnum;
    4.  
    5. public class BusinessException extends RuntimeException {
    6.     /**
    7.      * 异常枚举
    8.      */
    9.     private ExceptionEnum exceptionEnum;
    10.     /**
    11.      * 错误码
    12.      */
    13.     private final String code;
    14.     /**
    15.      * 错误信息
    16.      */
    17.     private final String errorMsg;
    18.  
    19.     public BusinessException(ExceptionEnum exceptionEnum) {
    20.         super(String.format("code = %s, errorMsg = %s", exceptionEnum.getCode(), exceptionEnum.getErrorMsg()));
    21.         this.exceptionEnum = exceptionEnum;
    22.         this.code = exceptionEnum.getCode();
    23.         this.errorMsg = exceptionEnum.getErrorMsg();
    24.     }
    25.  
    26.     public BusinessException(String code, String errorMsg) {
    27.         super(String.format("code = %s, errorMsg = %s", code, errorMsg));
    28.         this.code = code;
    29.         this.errorMsg = errorMsg;
    30.     }
    31.  
    32.     public BusinessException(String code, String errorMsg, Object... args) {
    33.         super("code = " + code + ", errorMsg = " + String.format(errorMsg, args));
    34.         this.code = code;
    35.         this.errorMsg = String.format(errorMsg, args);
    36.     }
    37.  
    38.     public ExceptionEnum getExceptionEnum() {
    39.         return exceptionEnum;
    40.     }
    41.  
    42.     public String getErrorMsg() {
    43.         return errorMsg;
    44.     }
    45.  
    46.     public String getCode() {
    47.         return code;
    48.     }
    49.  
    50. }

    UnifiedExceptionHandler.java代码

    统一异常处理类。

    注意@RestControllerAdvice注解。

    在本类中，我们创建三个方法，分别处理不同场景的异常。

    businessExceptionHandler方法处理抛出BusinessException异常的场景，即一旦抛出BusinessException异常，就会被businessExceptionHandler方法处理。

    illegalArgumentExceptionHandler方法处理抛出IllegalArgumentException异常的场景，即一旦抛出IllegalArgumentException异常，就会被illegalArgumentExceptionHandler方法处理。

    exceptionHandler方法是兜底的，捕获抛出Exception异常的场景，即一旦抛出Exception异常，就会被exceptionHandler方法处理。

    当然，你可以根据实际项目需要，创建更多的异常处理方法，如空指针异常处理方法、数组越界异常处理方法、类找不到异常处理方法等。

    1. package com.panda.handle_try_catch_gracefully.handler;
    2.  
    3. import com.panda.handle_try_catch_gracefully.common.Result;
    4. import com.panda.handle_try_catch_gracefully.enums.ExceptionEnum;
    5. import com.panda.handle_try_catch_gracefully.exceptions.BusinessException;
    6. import lombok.extern.slf4j.Slf4j;
    7. import org.springframework.web.bind.annotation.ExceptionHandler;
    8. import org.springframework.web.bind.annotation.ResponseBody;
    9. import org.springframework.web.bind.annotation.RestControllerAdvice;
    10.  
    11. @Slf4j
    12. @RestControllerAdvice
    13. public class UnifiedExceptionHandler {
    14.     /**
    15.      * 业务异常处理
    16.      *
    17.      * @param businessException 业务异常信息
    18.      */
    19.     @ExceptionHandler(value = BusinessException.class)
    20.     public <T> Result<T> businessExceptionHandler(BusinessException businessException) {
    21.         log.error(businessException.getErrorMsg(), businessException);
    22.         return Result.fail(businessException.getCode(), businessException.getErrorMsg());
    23.     }
    24.  
    25.     /**
    26.      * 未知异常处理
    27.      *
    28.      * @param exception 异常信息
    29.      */
    30.     @ExceptionHandler(value = Exception.class)
    31.     public <T> Result<T> exceptionHandler(Exception exception) {
    32.         log.error(exception.getMessage(), exception);
    33.         return Result.fail(ExceptionEnum.UNKNOWN.getCode(), ExceptionEnum.UNKNOWN.getErrorMsg());
    34.     }
    35.  
    36.     /**
    37.      * 参数异常处理
    38.      *
    39.      * @param exception 异常信息
    40.      */
    41.     @ExceptionHandler(value = IllegalArgumentException.class)
    42.     public <T> Result<T> illegalArgumentExceptionHandler(IllegalArgumentException exception) {
    43.         log.error(exception.getMessage(), exception);
    44.         return Result.fail(ExceptionEnum.ILLEGAL_ARGUMENT_ERROR.getCode(), ExceptionEnum.ILLEGAL_ARGUMENT_ERROR.getErrorMsg());
    45.     }
    46. }

    IUserService.java代码

    用户接口类。

    在本例中定义了5个方法：

    getUserInfo：根据用户ID查询用户信息。

    listUserInfo：根据查询条件查询符合条件用户列表。

    saveUser：保存用户信息。

    updateUser：更新用户信息。

    deleteUser：删除用户信息。

    1. package com.panda.handle_try_catch_gracefully.service;
    2.  
    3. import com.panda.handle_try_catch_gracefully.common.Result;
    4. import com.panda.handle_try_catch_gracefully.domain.po.User;
    5. import com.panda.handle_try_catch_gracefully.domain.vo.UserVO;
    6.  
    7. import java.util.List;
    8.  
    9. public interface IUserService {
    10.  
    11.     Result<UserVO> getUserInfo(String userId);
    12.  
    13.     Result<List<UserVO>> listUserInfo(UserVO query);
    15.     Result<String> saveUser(User user);
    16.  
    17.     Result<Boolean> updateUser(User user);
    18.  
    19.     Result<Boolean> deleteUser(String userId);
    20. }

    UserServiceImpl.java代码

    用户接口实现类。

    由于本文的重点不是实现业务逻辑，因此各个实现方法并没有详细的业务逻辑，而是抛出不同的异常，验证我们上面给出统一异常处理类是否可以真的处理各种异常。

    1. package com.panda.handle_try_catch_gracefully.service.impl;
    2.  
    3. import com.panda.handle_try_catch_gracefully.common.Result;
    4. import com.panda.handle_try_catch_gracefully.domain.po.User;
    5. import com.panda.handle_try_catch_gracefully.domain.vo.UserVO;
    6. import com.panda.handle_try_catch_gracefully.service.IUserService;
    7. import org.springframework.stereotype.Service;
    8.  
    9. import java.util.List;
    10.  
    11. @Service
    12. public class UserServiceImpl implements IUserService {
    13.  
    14.     @Override
    15.     public Result<UserVO> getUserInfo(String userId) {
    16.         // 默认抛出异常
    17.         throw new BusinessException(ExceptionEnum.INTERNAL_SERVER_ERROR);
    18.     }
    19.  
    20.     @Override
    21.     public Result<List<UserVO>> listUserInfo(UserVO query) {
    22.         // 默认抛出异常
    23.         throw new IllegalArgumentException();
    24.     }
    25.  
    26.     @Override
    27.     public Result<String> saveUser(User user) {
    28.         // 默认抛出异常
    29.         throw new IndexOutOfBoundsException();
    30.     }
    31.  
    32.     @Override
    33.     public Result<Boolean> updateUser(User user) {
    34.         // 默认抛出异常
    35.         throw new RuntimeException();
    36.     }
    37.  
    38.     @Override
    39.     public Result<Boolean> deleteUser(String userId) {
    40.         // 默认抛出异常
    41.         throw new ClassCastException();
    42.     }
    43. }

    测试

    1、service方法抛出BusinessException异常

    测试方法

    http://localhost:8080/user/getUserInfo

    测试结果 
    1. {
    2.   "code": "500",
    3.   "msg": "服务器内部错误！",
    4.   "successFlag": false,
    5.   "data": null
    6. }

    从上面的代码可知，getUserInfo方法抛出的异常如下：

    throw new BusinessException(ExceptionEnum.INTERNAL_SERVER_ERROR);

    恰好可以被UnifiedExceptionHandler的businessExceptionHandler方法监听。

    测试结论

    测试成功。

    统一异常处理类可以正常捕获BusinessException异常。

    2、service方法抛出IllegalArgumentException异常

    测试方法

    http://localhost:8080/user/listUserInfo

    测试结果 
    1. {
    2.   "code": "10000",
    3.   "msg": "非法参数异常！",
    4.   "successFlag": false,
    5.   "data": null
    6. }

    从上面的代码可知，listUserInfo方法抛出的异常如下：

    throw new IllegalArgumentException();

    恰好可以被UnifiedExceptionHandler的illegalArgumentExceptionHandler方法监听。

    测试结论

    测试成功。

    统一异常处理类可以正常捕获IllegalArgumentException异常。

    3、service方法抛出IndexOutOfBoundsException异常

    测试方法

    http://localhost:8080/user/saveUser

    测试结果 
    1. {
    2.   "code": "500",
    3.   "msg": "服务器内部错误！",
    4.   "successFlag": false,
    5.   "data": null
    6. }

    从上面的代码可知，saveUser方法抛出的异常如下：

    throw new IndexOutOfBoundsException();

    虽然UnifiedExceptionHandler没有专门处理IndexOutOfBoundsException异常的方法，但是有一个兜底的exceptionHandler方法，该方法可以监听Exception及其子类的异常类型。

    而IndexOutOfBoundsException异常恰好是Exception的子类，因此可以被正常监听到。

    测试结论

    测试成功。

    统一异常处理类可以正常捕获IndexOutOfBoundsException异常。

    4、service方法抛出RuntimeException异常

    测试方法

    http://localhost:8080/user/updateUser

    测试结果 
    1. {
    2.   "code": "9999",
    3.   "msg": "未知异常！",
    4.   "successFlag": false,
    5.   "data": null
    6. }

    从上面的代码可知，updateUser方法抛出的异常如下：

    throw new RuntimeException();

    同上。

    虽然UnifiedExceptionHandler没有专门处理RuntimeException异常的方法，但是有一个兜底的exceptionHandler方法，该方法可以监听Exception及其子类的异常类型。

    而RuntimeException异常恰好是Exception的子类，因此可以被正常监听到。

    测试结论

    测试成功。

    统一异常处理类可以正常捕获RuntimeException异常。

    5、service方法抛出ClassCastException异常

    测试方法

    http://localhost:8080/user/deleteUser

    测试结果 
    1. {
    2.   "code": "9999",
    3.   "msg": "未知异常！",
    4.   "successFlag": false,
    5.   "data": null
    6. }

    从上面的代码可知，deleteUser方法抛出的异常如下：

    throw new ClassCastException();

    同上。

    虽然UnifiedExceptionHandler没有专门处理ClassCastException异常的方法，但是有一个兜底的exceptionHandler方法，该方法可以监听Exception及其子类的异常类型。

    而ClassCastException异常恰好是Exception的子类，因此可以被正常监听到。

    测试结论

    测试成功。

    统一异常处理类可以正常捕获ClassCastException异常。

  • 相关阅读:
    【Linux】Linux任务管理与守护进程
    C++内存管理
    认识哈希表
    【负荷预测】基于蚂蚁优化算法的BP神经网络在负荷预测中的应用研究（Matlab完整代码实现）
    德人合科技——@天锐绿盾 | -文档透明加密系统
    【OpenHarmony】系统编译环境搭建笔记
    JSD-2204-(业务逻辑开发)-续消息队列-Kafka-RabbitMQ-Day15
    【基础篇】七、Flink核心概念
    有趣的特性：CHECK约束
    聊一聊开发语言的基础控制结构
  • 原文地址：https://blog.csdn.net/LINgZone2/article/details/133942210