JDK1.8，SpringBoot2.6.0

1、依赖

  1. <?xml version="1.0" encoding="UTF-8"?>
  2. <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
  3.          xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 https://maven.apache.org/xsd/maven-4.0.0.xsd">
  4.     <modelVersion>4.0.0</modelVersion>
  5.     <parent>
  6.         <groupId>org.springframework.boot</groupId>
  7.         <artifactId>spring-boot-starter-parent</artifactId>
  8.         <version>2.6.0</version>
  9.         <relativePath/> <!-- lookup parent from repository -->
  10.     </parent>
  11.     <groupId>com.example</groupId>
  12.     <artifactId>demo</artifactId>
  13.     <version>0.0.1-SNAPSHOT</version>
  14.     <name>demo</name>
  15.     <description>Demo project for Spring Boot</description>
  16.     <properties>
  17.         <java.version>1.8</java.version>
  18.     </properties>
  19.     <dependencies>
  20.         <dependency>
  21.             <groupId>org.springframework.boot</groupId>
  22.             <artifactId>spring-boot-starter-web</artifactId>
  23.         </dependency>
  25.         <dependency>
  26.             <groupId>org.projectlombok</groupId>
  27.             <artifactId>lombok</artifactId>
  28.             <optional>true</optional>
  29.         </dependency>
  30.         <dependency>
  31.             <groupId>org.springframework.boot</groupId>
  32.             <artifactId>spring-boot-starter-test</artifactId>
  33.             <scope>test</scope>
  34.         </dependency>
  35.     </dependencies>
  37.     <build>
  38.         <plugins>
  39.             <plugin>
  40.                 <groupId>org.springframework.boot</groupId>
  41.                 <artifactId>spring-boot-maven-plugin</artifactId>
  42.                 <configuration>
  43.                     <excludes>
  44.                         <exclude>
  45.                             <groupId>org.projectlombok</groupId>
  46.                             <artifactId>lombok</artifactId>
  47.                         </exclude>
  48.                     </excludes>
  49.                 </configuration>
  50.             </plugin>
  51.         </plugins>
  52.     </build>
  54. </project>

2、统一返回体类

  1. package com.example.demo.entity.vo;
  3. import lombok.AllArgsConstructor;
  4. import lombok.Builder;
  5. import lombok.Data;
  7. import javax.servlet.http.HttpServletResponse;
  9. /**
  10.  * @author: HanXu
  11.  * on 2021/11/25
  12.  * Class description: controller对外统一返回体
  13.  */
  14. @Data
  15. @AllArgsConstructor
  16. @Builder
  17. public class BaseResponse<T>  {
  18.     private int code;
  19.     private String msg;
  20.     private T data;
  22.     public BaseResponse(T data) {
  23.         code = HttpServletResponse.SC_OK;
  24.         msg = "success";
  25.         this.data = data;
  26.     }
  28.     public BaseResponse(int code, String msg) {
  29.         this.code = code;
  30.         this.msg = msg;
  31.     }
  33. }

工具类：

  1. package com.example.demo.utils;
  3. import com.fasterxml.jackson.annotation.JsonInclude;
  4. import com.fasterxml.jackson.core.JsonParser;
  5. import com.fasterxml.jackson.core.JsonProcessingException;
  6. import com.fasterxml.jackson.databind.DeserializationFeature;
  7. import com.fasterxml.jackson.databind.MapperFeature;
  8. import com.fasterxml.jackson.databind.ObjectMapper;
  9. import com.fasterxml.jackson.databind.SerializationFeature;
  10. import com.fasterxml.jackson.databind.module.SimpleModule;
  11. import com.fasterxml.jackson.datatype.jsr310.JavaTimeModule;
  12. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateSerializer;
  13. import com.fasterxml.jackson.datatype.jsr310.ser.LocalDateTimeSerializer;
  14. import com.fasterxml.jackson.datatype.jsr310.ser.LocalTimeSerializer;
  15. import lombok.AccessLevel;
  16. import lombok.NoArgsConstructor;
  18. import java.time.LocalDate;
  19. import java.time.LocalDateTime;
  20. import java.time.LocalTime;
  21. import java.time.format.DateTimeFormatter;
  22. import java.util.Objects;
  24. /**
  25.  * @author: HanXu
  26.  * on 2021/11/25
  27.  * Class description:
  28.  */
  29. @NoArgsConstructor(access = AccessLevel.PRIVATE)
  30. public abstract class JacksonUtil {
  32.     private final static ObjectMapper objectMapper;
  34.     static {
  35.         objectMapper = initWrapperObjectMapper(new ObjectMapper());
  36.     }
  38.     /**
  39.      * 转换Json
  40.      *
  41.      * @param object
  42.      * @return
  43.      */
  44.     public static String toJson(Object object) {
  45.         if (isCharSequence(object)) {
  46.             return (String) object;
  47.         }
  48.         try {
  49.             return getObjectMapper().writeValueAsString(object);
  50.         } catch (JsonProcessingException e) {
  51.             throw new RuntimeException(e);
  52.         }
  53.     }
  55.     /**
  56.      * 获取ObjectMapper
  57.      *
  58.      * @return
  59.      */
  60.     public static ObjectMapper getObjectMapper() {
  61.         return objectMapper;
  62.     }
  64.     /**
  65.      * 初始化 Wrapper ObjectMapper
  66.      *
  67.      * @param objectMapper
  68.      * @return
  69.      */
  70.     public static ObjectMapper initWrapperObjectMapper(ObjectMapper objectMapper) {
  71.         if (Objects.isNull(objectMapper)) {
  72.             objectMapper = new ObjectMapper();
  73.         }
  74.         objectMapper.registerModule(new JavaTimeModule());
  75.         objectMapper.disable(SerializationFeature.WRITE_DATES_AS_TIMESTAMPS);
  76.         //不显示为null的字段
  77.         objectMapper.disable(SerializationFeature.FAIL_ON_EMPTY_BEANS);
  78.         objectMapper.disable(DeserializationFeature.FAIL_ON_UNKNOWN_PROPERTIES);
  79.         // 忽略不能转移的字符
  80.         objectMapper.configure(JsonParser.Feature.ALLOW_BACKSLASH_ESCAPING_ANY_CHARACTER, true);
  81.         // 过滤对象的null属性.
  82.         objectMapper.setSerializationInclusion(JsonInclude.Include.NON_NULL);
  83.         //忽略transient
  84.         objectMapper.configure(MapperFeature.PROPAGATE_TRANSIENT_MARKER, true);
  85.         SimpleModule simpleModule = new SimpleModule();
  86.         simpleModule.addSerializer(LocalDateTime.class, new LocalDateTimeSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
  87.         simpleModule.addSerializer(LocalDate.class, new LocalDateSerializer(DateTimeFormatter.ofPattern("yyyy-MM-dd")));
  88.         simpleModule.addSerializer(LocalTime.class, new LocalTimeSerializer(DateTimeFormatter.ofPattern("HH:mm:ss")));
  89. //        simpleModule.addSerializer(Long.class, ToStringSerializer.instance);
  90.         objectMapper.registerModule(simpleModule);
  91.         return objectMapper;
  92.     }
  94.     /**
  95.      * <p>
  96.      * 是否为CharSequence类型
  97.      * </p>
  98.      *
  99.      * @param object
  100.      * @return
  101.      */
  102.     public static Boolean isCharSequence(Object object) {
  103.         return !Objects.isNull(object) && isCharSequence(object.getClass());
  104.     }
  106.     /**
  107.      * <p>
  108.      * 是否为CharSequence类型
  109.      * </p>
  110.      *
  111.      * @param clazz class
  112.      * @return true 为是 CharSequence 类型
  113.      */
  114.     public static boolean isCharSequence(Class<?> clazz) {
  115.         return clazz != null && CharSequence.class.isAssignableFrom(clazz);
  116.     }
  118.     /**
  119.      * Json转换为对象 转换失败返回null
  120.      *
  121.      * @param json
  122.      * @return
  123.      */
  124.     public static Object parse(String json) {
  125.         Object object = null;
  126.         try {
  127.             object = getObjectMapper().readValue(json, Object.class);
  128.         } catch (Exception ignored) {
  129.         }
  130.         return object;
  131.     }
  133.     /**
  134.      * Json转换为对象 转换失败返回null
  135.      *
  136.      * @param json
  137.      * @param clazz
  138.      * @param <T>
  139.      * @return
  140.      */
  141.     public static <T> T parseObject(String json, Class<T> clazz) {
  142.         T t = null;
  143.         try {
  144.             t = getObjectMapper().readValue(json, clazz);
  145.         } catch (Exception ignored) {
  146.         }
  147.         return t;
  148.     }
  150. }

3、自定义注解

自定义注解@ResultUnite，该注解标注的类或方法，都能被包装成统一的返回。

wrapper包/annotation包下新建此类

  1. package com.example.demo.wrapper.annotation;
  3. import java.lang.annotation.Documented;
  4. import java.lang.annotation.ElementType;
  5. import java.lang.annotation.Inherited;
  6. import java.lang.annotation.Retention;
  7. import java.lang.annotation.RetentionPolicy;
  8. import java.lang.annotation.Target;
  10. /**
  11.  * @author: HanXu
  12.  * on 2021/11/25
  13.  * Class description: 统一返回结果注解
  14.  */
  15. @Target({ ElementType.TYPE, ElementType.METHOD }) //作用范围
  16. @Retention(RetentionPolicy.RUNTIME)
  17. @Documented
  18. @Inherited
  19. public @interface ResultUnite {
  20. }

然后使用@ControllerAdvice注解，来拦截所有 @RequestMapping 等注解标注的方法。这些方法返回时，不立刻返回，而是先经过 supports方法判断是否需要处理，返回true时，则执行beforeBodyWrite方法。

wrapper包/advice包下新建此类

  1. package com.example.demo.wrapper.advice;
  3. import com.example.demo.entity.vo.BaseResponse;
  4. import com.example.demo.utils.JacksonUtil;
  5. import com.example.demo.wrapper.annotation.ResultUnite;
  6. import org.springframework.core.MethodParameter;
  7. import org.springframework.http.MediaType;
  8. import org.springframework.http.converter.HttpMessageConverter;
  9. import org.springframework.http.server.ServerHttpRequest;
  10. import org.springframework.http.server.ServerHttpResponse;
  11. import org.springframework.web.bind.annotation.ControllerAdvice;
  12. import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
  14. import java.lang.reflect.Method;
  16. /**
  17.  * @author: HanXu
  18.  * on 2021/11/25
  19.  * Class description: 统一返回结果
  20.  */
  21. @ControllerAdvice
  22. public class BaseResponseBodyAdvice implements ResponseBodyAdvice<Object> {
  24.     private static final String CONVERT_NAME = "org.springframework.http.converter.StringHttpMessageConverter";
  27.     private boolean isResultUnite(MethodParameter methodParameter, Class aClass) {
  28.         Method method = methodParameter.getMethod();
  29.         return aClass.isAnnotationPresent(ResultUnite.class) ||method.isAnnotationPresent(ResultUnite.class);
  30.     }
  32.     @Override
  33.     public boolean supports(MethodParameter methodParameter, Class aClass) {
  34.         return isResultUnite(methodParameter, aClass);
  35.     }
  37.     @Override
  38.     public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class<? extends HttpMessageConverter<?>> selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
  39.         //处理String类型的返回值
  40.         if (CONVERT_NAME.equalsIgnoreCase(selectedConverterType.getName())) {
  41.             return JacksonUtil.toJson(new BaseResponse(body));
  42.         }
  43.         return new BaseResponse(body);
  44.     }
  45. }

在supports方法中，我们的处理是：通过反射获取到执行方法/类上是否有@ResultUnite注解，有就返回true；无则返回false。

在beforeBodyWrite方法中，我们将方法的返回作为data传入BaseResponse构造方法中，重新new了一个BaseResponse对象，所以就达到了将返回数据包装成BaseResponse的目的。

以上两个类就给我们提供了一个具有能够包装返回数据的注解@ResultUnite。

3.1、阶段测试

新建controller类测试一下

  1. package com.example.demo.controller;
  3. import com.example.demo.wrapper.annotation.ResultUnite;
  4. import lombok.extern.slf4j.Slf4j;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  8. /**
  9.  * @author: HanXu
  10.  * on 2021/11/25
  11.  * Class description:
  12.  */
  13. @Slf4j
  14. @RestController
  15. public class TestController {
  17.     @ResultUnite
  18.     @RequestMapping("/test1")
  19.     public String test1() {
  20.         log.info("---------------test1---------------");
  21.         return "111";
  22.     }
  23. }

上述test1方法被本应该返回“111”的，但是被@ResultUnite注解了，所以执行观察，返回包装后的结果：

  1. {
  2.     "code": 200,
  3.     "msg": "success",
  4.     "data": "111"
  5. }

再试一下：

  1. @ResultUnite
  2. @RequestMapping("/test2")
  3. public List<String> test2() {
  4.     log.info("---------------test2---------------");
  5.     List<String> list = new ArrayList<String>(){
  6.         {
  7.             add("123");
  8.             add("456");
  9.         }
  10.     };
  11.     return list;
  12. }

执行返回：

  1. {
  2.     "code": 200,
  3.     "msg": "success",
  4.     "data": [
  5.         "123",
  6.         "456"
  7.     ]
  8. }

这样我们就在任何成功的情况下，统一了对外部的返回（code,msg,data）。且实现非常清爽，在业务代码中只需要一个注解即可。

可是异常情况呢？异常情况因为不会再从controller中的return出去，所以就不受控制了。接下来处理异常情况。

4、统一异常处理

4.1、自定义异常类

这个类看起来和BaseResponse结构一样，那为什么不能使用BaseResponse代替呢？

因为此类需要继承RuntimeException，将来在代码中可以catch住此异常信息，然后做处理。况且两个类分别是不同功能的，即使属性一样，也不能复用。

  1. package com.example.demo.entity.vo;
  3. import com.example.demo.entity.enums.ExceptionCodeEnum;
  4. import lombok.Data;
  6. /**
  7.  * @author: HanXu
  8.  * on 2021/11/25
  9.  * Class description: 自定义异常：方便进行异常信息扩展，且与RuntimeException区分开
  10.  */
  11. @Data
  12. public class CustomerExceptionVO extends RuntimeException {
  14.     private int code;
  15.     private String msg;
  16.     private Object data;
  18.     public CustomerExceptionVO(ExceptionCodeEnum exceptionCodeEnum) {
  19.         code = exceptionCodeEnum.getCode();
  20.         msg = exceptionCodeEnum.getMsg();
  21.     }
  24.     public CustomerExceptionVO(int code, String msg) {
  25.         super(msg);
  26.         this.code = code;
  27.         this.msg = msg;
  28.     }
  30.     public CustomerExceptionVO(int code, String msg, Object data) {
  31.         super(msg);
  32.         this.code = code;
  33.         this.msg = msg;
  34.         this.data = data;
  35.     }
  36. }

枚举异常：

  1. package com.example.demo.entity.enums;
  3. import javax.servlet.http.HttpServletResponse;
  5. /**
  6.  * @author: HanXu
  7.  * on 2021/11/25
  8.  * Class description: 通用异常枚举，供 CustomerException 使用
  9.  */
  10. public enum ExceptionCodeEnum {
  12.     //通用异常
  13.     /**
  14.      * 400
  15.      */
  16.     Bad_Request(HttpServletResponse.SC_BAD_REQUEST, "请求信息错误,请检查参数"),
  17.     /**
  18.      * 401
  19.      */
  20.     UnAuth(HttpServletResponse.SC_UNAUTHORIZED, "请先登陆"),
  21.     /**
  22.      * 403
  23.      */
  24.     Forbidden(HttpServletResponse.SC_FORBIDDEN, "无权查看"),
  25.     /**
  26.      * 404
  27.      */
  28.     Not_Found(HttpServletResponse.SC_NOT_FOUND, "未找到该路径或资源"),
  29.     /**
  30.      * 405
  31.      */
  32.     Method_Not_Allowed(HttpServletResponse.SC_METHOD_NOT_ALLOWED, "请求方式不支持"),
  34.     /**
  35.      * 500
  36.      */
  37.     Internal_Server_Error(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务器异常"),
  38.     /**
  39.      * 503
  40.      */
  41.     Service_Unavailable(HttpServletResponse.SC_SERVICE_UNAVAILABLE, "请求超时"),
  43.     //自定义扩展其他业务异常
  44.     /**
  45.      * 400
  46.      */
  47.     Username_Or_PassWord_Error(HttpServletResponse.SC_BAD_REQUEST, "用户名密码错误"),
  48.     /**
  49.      * 400
  50.      */
  51.     Username_Exist(HttpServletResponse.SC_BAD_REQUEST, "用户名已存在"),
  52.     /**
  53.      * 400
  54.      */
  55.     ValidCode_Error(HttpServletResponse.SC_BAD_REQUEST, "验证码不正确"),
  58.     ;
  59.     private int code;
  60.     private String msg;
  62.     ExceptionCodeEnum(int code, String msg) {
  63.         this.code = code;
  64.         this.msg = msg;
  65.     }
  67.     public int getCode() {
  68.         return code;
  69.     }
  71.     public String getMsg() {
  72.         return msg;
  73.     }
  76.     public static ExceptionCodeEnum getByCode(int code) {
  77.         ExceptionCodeEnum[] enums = ExceptionCodeEnum.values();
  78.         for (ExceptionCodeEnum exceptionCodeEnum : enums) {
  79.             if (exceptionCodeEnum.code == code) {
  80.                 return exceptionCodeEnum;
  81.             }
  82.         }
  83.         return null;
  84.     }
  85. }

工具类：

  1. package com.example.demo.utils;
  3. import java.text.SimpleDateFormat;
  4. import java.util.Date;
  6. /**
  7.  * @author: HanXu
  8.  * on 2021/11/25
  9.  * Class description: 通用工具类
  10.  */
  11. public class CommonUtil {
  13.     public static Object getNotNull(Object original, Object backup) {
  14.         if (backup == null) {
  15.             throw new RuntimeException("备用参数不能为空");
  16.         }
  17.         return original != null ? original : backup;
  18.     }
  21.     public static Object getOrDefault(Object original, Object defaultValue) {
  22.         return original != null ? original : defaultValue;
  23.     }
  26.     public static String getNonce() {
  27.         return getNonce(8);
  28.     }
  31.     /**
  32.      * 获取随机数 eg:0E35E147
  33.      * @param n
  34.      * @return
  35.      */
  36.     public static String getNonce(int n) {
  37.         String nonce = "";
  38.         //一个十六进制的值的数组
  39.         String[] array = {"0","1","2","3","4","5","6","7","8","9","A","B","C","D","E","F"};
  40.         //得到6个随机数
  41.         for (int i = 0; i < n; i++) {
  42.             int num = (int) (Math.random() * 16);
  43.             nonce += array[num];
  44.         }
  45.         return nonce;
  46.     }
  49.     /**
  50.      * 格式化获取当前时间
  51.      * @return
  52.      */
  53.     public static String getNowDateFomart(){
  54.         SimpleDateFormat format = new SimpleDateFormat("yyyyMMddHHmmss");
  55.         Date date = new Date();
  56.         return format.format(date);
  57.     }
  58. }

4.2、统一异常处理

使用@ControllerAdvice加@ExceptionHandler注解，拦截代码中抛出的异常。拦截到属于CustomerExceptionVO的异常就优先handleCustomerException方法处理；否则就放行，看是否属于Exception异常（显然剩下的都是），然后由handleLeftException处理。

  1. package com.example.demo.exception;
  3. import com.example.demo.entity.vo.BaseResponse;
  4. import com.example.demo.entity.vo.CustomerExceptionVO;
  5. import com.example.demo.utils.CommonUtil;
  6. import lombok.extern.slf4j.Slf4j;
  7. import org.springframework.web.bind.annotation.ControllerAdvice;
  8. import org.springframework.web.bind.annotation.ExceptionHandler;
  9. import org.springframework.web.bind.annotation.ResponseBody;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  14. /**
  15.  * @author: HanXu
  16.  * on 2021/11/25
  17.  * Class description: 统一异常处理
  18.  */
  19. @Slf4j
  20. @ControllerAdvice
  21. @ResponseBody
  22. public class GlobalExceptionHandle {
  25.     /**
  26.      * 跟方法的上下顺序无关，系统优先给到捕获最小异常的方法，然后是大异常的方法
  27.      * 只能捕获代码中手动抛出的 CustomerException 或 RuntimeException
  28.      * @param e
  29.      * @return
  30.      */
  31.     @ExceptionHandler(CustomerExceptionVO.class)
  32.     public BaseResponse handleCustomerException(CustomerExceptionVO e, HttpServletRequest request) {
  33.         log.error("异常request uri: {}", request.getRequestURI());
  34.         log.error(e.getMessage(), e);
  35.         return new BaseResponse((Integer) CommonUtil.getNotNull(e.getCode(), HttpServletResponse.SC_INTERNAL_SERVER_ERROR), (String) CommonUtil.getOrDefault(e.getMsg(), e.getMessage()), e.getData());
  36.     }
  39.     /**
  40.      * 捕获剩余所有异常
  41.      * @param e
  42.      * @param request
  43.      * @return
  44.      */
  45.     @ExceptionHandler(Exception.class)
  46.     public BaseResponse handleLeftException(Exception e, HttpServletRequest request) {
  47.         log.error("异常request uri: {}", request.getRequestURI());
  48.         log.error(e.getMessage(), e);
  49.         return new BaseResponse(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "服务器异常");
  50.     }
  51. }

4.3、意料之外错误的处理

当不是我们的代码抛出的异常时，GlobalExceptionHandle拦截不到，需要使用@RequestMapping(“error”)加ErrorController处理。

  1. package com.example.demo.exception;
  3. import com.example.demo.entity.enums.ExceptionCodeEnum;
  4. import com.example.demo.entity.vo.BaseResponse;
  5. import lombok.extern.slf4j.Slf4j;
  6. import org.springframework.boot.web.servlet.error.ErrorController;
  7. import org.springframework.stereotype.Controller;
  8. import org.springframework.web.bind.annotation.RequestMapping;
  9. import org.springframework.web.bind.annotation.ResponseBody;
  11. import javax.servlet.http.HttpServletResponse;
  13. /**
  14.  * @author: HanXu
  15.  * on 2021/11/25
  16.  * Class description: 拦截错误：GlobalExceptionHandle拦不到的异常（非代码中手动抛出的异常，上层SpringBoot中抛出的异常），当出错的时候，这里处理
  17.  */
  18. @Slf4j
  19. @Controller
  20. @RequestMapping("error")
  21. public class GlobalErrorController implements ErrorController {
  23.     @RequestMapping
  24.     @ResponseBody
  25.     public BaseResponse error(HttpServletResponse response) {
  26.         int statusCode = response.getStatus();
  27.         ExceptionCodeEnum exceptionCodeEnum = ExceptionCodeEnum.getByCode(statusCode);
  28.         if (exceptionCodeEnum == null) {
  29.             exceptionCodeEnum = ExceptionCodeEnum.Internal_Server_Error;
  30.         }
  31.         log.error("error: {}", exceptionCodeEnum.getMsg());
  32.         BaseResponse baseResult = new BaseResponse(exceptionCodeEnum.getCode(), exceptionCodeEnum.getMsg());;
  33.         return baseResult;
  34.     }
  35. }

4.4、阶段测试

①、我们故意抛出一个异常：

  1.     @ResultUnite
  2.     @RequestMapping("/test3")
  3.     public String test3() {
  4.         log.info("---------------test3---------------");
  5.         try {
  6.             int i = 5 / 0;
  7.         } catch (Exception e) {
  8.             throw e;
  9.         }
  10.         return "111";
  11.     }

执行测试：

  1. {
  2.     "code": 500,
  3.     "msg": "服务器异常",
  4.     "data": null
  5. }

这个throw e;就是被GlobalExceptionHandle中的handleLeftException拦截到了。

②、让程序内部（非代码）抛出一个异常

  1.     @ResultUnite
  2.     @RequestMapping("/test4")
  3.     public String test4() {
  4.         log.info("---------------test4---------------");
  5.         int i = 5 / 0;
  6.         return "111";
  7.     }

执行测试：

  1. {
  2.     "code": 500,
  3.     "msg": "服务器异常",
  4.     "data": null
  5. }

也能被GlobalExceptionHandle中的handleLeftException拦截到。

③、某些情况需要抛出自定义异常

  1.     @ResultUnite
  2.     @RequestMapping("/test5")
  3.     public String test5() {
  4.         log.info("---------------test5---------------");
  5.         //假装i是入参
  6.         int i = 1;
  7.         if (1 == i) {
  8.             throw new CustomerExceptionVO(ExceptionCodeEnum.Forbidden);
  9.         }
  10.         return "111";
  11.     }

执行测试：

  1. {
  2.     "code": 403,
  3.     "msg": "无权查看",
  4.     "data": null
  5. }

被GlobalExceptionHandle中的handleCustomerException拦截到。

5、异常结束工具

在4.4的③中，这种情况应该是经常有的，我们需要对业务情况判断，然后众多不符合规则的case都异常返回了，这样每次都throw new CustomerExceptionVO是很麻烦的事情，所以可以搞一个工具来使用。

  1. package com.example.demo.exception;
  3. import com.example.demo.entity.enums.ExceptionCodeEnum;
  4. import com.example.demo.entity.vo.CustomerExceptionVO;
  5. import org.springframework.stereotype.Component;
  7. import javax.servlet.http.HttpServletResponse;
  9. /**
  10.  * @author: HanXu
  11.  * on 2021/11/25
  12.  * Class description: 代码工具类：判断代码逻辑，不符合则抛出异常
  13.  */
  14. @Component
  15. public class ApiAssert {
  17.     public static void notNull(Object a) {
  18.         if (a == null) {
  19.             failure(ExceptionCodeEnum.Bad_Request);
  20.         }
  21.         if (a instanceof String) {
  22.             if (((String) a).length() == 0) {
  23.                 failure(ExceptionCodeEnum.Bad_Request);
  24.             }
  25.         }
  26.     }
  28.     public static void notNull(Object a, String msg) {
  29.         if (a == null) {
  30.             badRequest(msg);
  31.         }
  32.         if (a instanceof String) {
  33.             if (((String) a).length() == 0) {
  34.                 badRequest(msg);
  35.             }
  36.         }
  37.     }
  39.     //-------------------------400-----------------------
  41.     public static void badRequest(String msg) {
  42.         throw new CustomerExceptionVO(HttpServletResponse.SC_BAD_REQUEST, msg);
  43.     }
  45.     //--------------------------500-----------------------
  46.     public static void failure(ExceptionCodeEnum exceptionCodeEnum) {
  47.         throw new CustomerExceptionVO(exceptionCodeEnum);
  48.     }
  50.     public static void failure(String msg, Object data) {
  51.         throw new CustomerExceptionVO(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, msg, data);
  52.     }
  54.     public static void failure(int code, String msg, Object data) {
  55.         throw new CustomerExceptionVO(code, msg, data);
  56.     }
  58.     public static void failure(Object data) {
  59.         throw new CustomerExceptionVO(HttpServletResponse.SC_INTERNAL_SERVER_ERROR, "error", data);
  60.     }
  62.     //--------------------------业务工具----------------------
  64.     public static void forbidden() {
  65.         throw new CustomerExceptionVO(ExceptionCodeEnum.Forbidden);
  66.     }
  68.     public static void internal() {
  69.         throw new CustomerExceptionVO(ExceptionCodeEnum.Internal_Server_Error);
  70.     }
  72. }

然后就可以在业务代码中使用：

  1.     @ResultUnite
  2.     @RequestMapping("/test6")
  3.     public String test6() {
  4.         log.info("---------------test6---------------");
  5.         //假装i是入参
  6.         int i = 1;
  7.         if (1 == i) {
  8.             ApiAssert.badRequest("请求不合法");
  9.         }
  10.         return "111";
  11.     }

执行测试：

  1. {
  2.     "code": 400,
  3.     "msg": "请求不合法",
  4.     "data": null
  5. }

这样就可以在任何需要的地方使用ApiAssert来结束并返回。

6、总结

上述统一返回体的处理只是一种处理方式，包含了正常结束，异常返回，业务代码自定义中断返回的处理。也许并不适合所有。但能包容大多数情况。

其实仍有许多改进的地方，比如抛出的异常错误码，完全可以自定义一个自己系统统一的错误码表，然后使用这个码表，就不用每次都使用HttpServletResponse的了。