devbox
菜鸟追梦旅行
这个屌丝很懒，什么也没留下！
关注作者
热门标签
热门文章
当前位置:   article > 正文

springboot全局异常拦截+统一接口返回格式（包括过滤器、拦截器中的异常）_springboot 拦截器返回结果

作者：菜鸟追梦旅行 | 2024-04-21 01:36:45

赞

踩

springboot 拦截器返回结果

环境

  • Java17
  • spring boot v-3.1.3

描述

为了不让后端莫名其妙的错误返回给用户，为了提高可维护性和可扩展性...为了少写两行代码，懒得打字直接搞代码

统一接口出参格式，统一异常处理

直接先展示成品

  1.  
  2. import io.swagger.v3.oas.annotations.Operation;
  3. import io.swagger.v3.oas.annotations.tags.Tag;
  4. import org.springframework.web.bind.annotation.GetMapping;
  5. import org.springframework.web.bind.annotation.RequestMapping;
  6. import org.springframework.web.bind.annotation.RestController;
  7.  
  8. import java.util.Arrays;
  9. import java.util.List;
  10.  
  11.  
  12. /**
  13.  * @author: dzg
  14.  */
  15. @RestController
  16. @RequestMapping("test")
  17. @Tag(name = "test控制器")
  18. public class Test2Controller {
  19.  
  20.     @GetMapping("test1")
  21.     @Operation(summary = "无特殊返回")
  22.     public Result<Object> test1(){
  23.         //模拟调用方法，成功了默认返回成功，有问题直接方法直接被全局异常拦截
  24.         test1s();
  25.         return Result.success();
  26.     }
  27.  
  28.  
  29.     @GetMapping("test2")
  30.     @Operation(summary = "要返回一些数据")
  31.     public Result<List<String>> test2(){
  32.         //模拟调用方法，成功了直接返回，有问题直接方法直接被全局异常拦截
  33.         return Result.success(test2s());
  34.     }
  35.  
  36.     @GetMapping("test3")
  37.     @Operation(summary = "测试异常拦截")
  38.     public Result<Object> test3(){
  39.         //模拟调用方法，成功了直接返回，有问题直接方法直接被全局异常拦截
  40.         return Result.success();
  41.     }
  42.  
  43.     @GetMapping("test4")
  44.     @Operation(summary = "测试异常拦截")
  45.     public Result<Object> test4(){
  46.         if(true){
  47.             throw new CustomException(ResultCode.CODE_MISSING_PARAMETER);
  48.         }
  49.         //模拟调用方法，成功了直接返回，有问题直接方法直接被全局异常拦截
  50.         return Result.success();
  51.     }
  52.     public static void test1s(){
  53.         System.out.println(5/0);
  54.     }
  55.  
  56.     public static List<String> test2s(){
  57.         return Arrays.asList("H", "e", "l", "l", "o");
  58.     }
  59. }

test1结果：

  1. {
  2.     "code": 500,
  3.     "msg": "操作失败",
  4.     "data": null
  5. }

test2结果：

  1. {
  2.     "code": 200,
  3.     "msg": "操作成功",
  4.     "data": [
  5.         "H",
  6.         "e",
  7.         "l",
  8.         "l",
  9.         "o"
  10.     ]
  11. }

这种只有一两行代码的Controller看着不清爽吗？报错也不会抛出来奇奇怪怪的东西

统一出参Code码

  1. public enum ResultCode {
  2.  
  3.     /**
  4.      * 成功状态码
  5.      */
  6.     CODE_SUCCESS(200, "操作成功"),
  7.  
  8.     /**
  9.      * 违规请求
  10.      */
  11.     CODE_METHOD_NOT_ALLOWED(405, "违规请求"),
  12.  
  13.     /**
  14.      * 无效请求状态码
  15.      */
  16.     CODE_INVALID_REQUEST(400, "无效请求"),
  17.  
  18.     /**
  19.      * 操作失败
  20.      */
  21.     CODE_ERROR(500, "操作失败"),
  22.  
  23.     /**
  24.      * 未登录，请登录后再次访问
  25.      */
  26.     CODE_NOT_LOGIN(401, "未登录，请登录后再次访问");
  27.     /**
  28.      * 等等等...
  29.      */
  30.     /**
  31.      * 状态码
  32.      */
  33.     private final Integer code;
  34.  
  35.     /**
  36.      * msg消息
  37.      */
  38.     private String msg;
  39.  
  40.  
  41.     ResultCode(Integer code, String msg) {
  42.         this.code = code;
  43.         this.msg = msg;
  44.     }
  45.  
  46.     public Integer getCode() {
  47.         return this.code;
  48.     }
  49.     public String getCodeStr(){
  50.         return getCode().toString();
  51.     }
  52.     public String getMsg() {
  53.         return this.msg;
  54.     }
  55.  
  56.  
  57. }

统一出参类Reslut

  1.  
  2. import com.dzg.demo.common.menu.ResultCode;
  3. import io.swagger.v3.oas.annotations.media.Schema;
  4.  
  5. /**
  6.  * @Author: dzg
  7.  * @Date: 2023/9/18 17:14
  8.  * @Describe:
  9.  */
  10. @Schema(description = "统一出参类Result")
  11. public class Result<T> {
  12.  
  13.  
  14.     /**
  15.      * 状态码
  16.      */
  17.     @Schema(description = "状态码", defaultValue = "200")
  18.     private int code;
  19.     /**
  20.      * 描述信息
  21.      */
  22.     @Schema(description = "描述信息", defaultValue = "操作成功")
  23.     private String msg;
  24.  
  25.     /**
  26.      * 携带出参
  27.      */
  28.     @Schema(description = "携带出参")
  29.     private T data;
  30.  
  31.     /**
  32.      * 返回code
  33.      *
  34.      * @return str
  35.      */
  36.     public int getCode() {
  37.         return this.code;
  38.     }
  39.     public Result<T> setCode(int code) {
  40.         this.code = code;
  41.         return this;
  42.     }
  43.  
  44.     /**
  45.      * 给msg赋值，连缀风格
  46.      */
  47.     public Result<T> setMsg(String msg) {
  48.         this.msg = msg;
  49.         return this;
  50.     }
  51.  
  52.     public String getMsg() {
  53.         return this.msg;
  54.     }
  55.  
  56.     /**
  57.      * 给data赋值，连缀风格
  58.      */
  59.     public Result<T> setData(T data) {
  60.         this.data = data;
  61.         return this;
  62.     }
  63.  
  64.     /**
  65.      * 将data还原为指定类型并返回
  66.      */
  67.     public T getData() {
  68.         return data;
  69.     }
  70.  
  71.     public Result(){}
  72.     public Result(ResultCode resultCode) {
  73.         setCode(resultCode.getCode());
  74.         setMsg(resultCode.getMsg());
  75.     }
  76.  
  77.     public Result(int code, String msg, T data) {
  78.         setCode(code);
  79.         setMsg(msg);
  80.         setData(data);
  81.     }
  82.  
  83.     /**
  84.      * 返回成功
  85.      *
  86.      * @return
  87.      */
  88.     public static <T> Result<T> success() {
  89.         return new Result<>(ResultCode.CODE_SUCCESS);
  90.     }
  91.  
  92.     /**
  93.      * 返回成功
  94.      *
  95.      * @return
  96.      */
  97.     public static <T> Result<T> success(T data) {
  98.         return new Result<>(ResultCode.CODE_SUCCESS.getCode(), ResultCode.CODE_SUCCESS.getMsg(), data);
  99.     }
  100.  
  101.  
  102.     /**
  103.      * 返回失败
  104.      *
  105.      * @return
  106.      */
  107.     public static <T> Result<T> error() {
  108.         return new Result<>(ResultCode.CODE_ERROR);
  109.     }
  110.     public static <T> Result<T> error(ResultCode resultCode){
  111.         return error(resultCode.getCode(), resultCode.getMsg());
  112.     }
  113.  
  114.     public static <T> Result<T> error(int code, String msg) {
  115.         return new Result<>(code, msg, null);
  116.     }
  117. }

自定义异常类

  1.  
  2. import cn.hutool.core.text.CharSequenceUtil;
  3. import com.dzg.demo.common.menu.ResultCode;
  4.  
  5. import java.io.Serial;
  6.  
  7. /**
  8.  * @author: dzg
  9.  * @date: 2023/9/18 17:12
  10.  * @describe: 自定义异常类
  11.  */
  12. public class CustomException extends RuntimeException {
  13.  
  14.     @Serial
  15.     private static final long serialVersionUID = 6552388948084405686L;
  16.     /**
  17.      * 异常错误码
  18.      */
  19.     private int code;
  20.  
  21.     /**
  22.      * 给一个空构造器
  23.      */
  24.     public CustomException() {
  25.         super(ResultCode.CODE_ERROR.getMsg());
  26.         this.code = ResultCode.CODE_ERROR.getCode();
  27.     }
  28.  
  29.     public CustomException(ResultCode resultCode) {
  30.         super(resultCode != null ? resultCode.getMsg() : ResultCode.CODE_ERROR.getMsg());
  31.         this.code = resultCode != null ? resultCode.getCode() : ResultCode.CODE_ERROR.getCode();
  32.     }
  33.  
  34.     /**
  35.      * 自定义提示，但是通用code码为500
  36.      * @param msg 提示
  37.      */
  38.     public CustomException(String msg) {
  39.         super(msg);
  40.         this.code = ResultCode.CODE_ERROR.getCode();
  41.     }
  42.     public CustomException(ResultCode resultCode, String msg) {
  43.         super(CharSequenceUtil.format(resultCode.getMsg(), msg));
  44.         this.code = resultCode.getCode();
  45.     }
  46.     /**
  47.      * httpclient5文章中拦截responseCode使用
  48.      */
  49.     public CustomException(HttpStatus httpStatus) {
  50.         super(httpStatus != null ? "远程请求失败: "+httpStatus.getReasonPhrase() : "远程请求失败: "+ResultCode.CODE_ERROR.getMsg());
  51.         this.code = httpStatus != null ? httpStatus.value() : ResultCode.CODE_ERROR.getCode();
  52.     }
  53.  
  54.     public int getCode() {
  55.         return code;
  56.     }
  57.  
  58.     public void setCode(int code) {
  59.         this.code = code;
  60.     }
  61.  
  62. }

全局异常拦截

  1.  
  2. import jakarta.servlet.http.HttpServletRequest;
  3. import jakarta.servlet.http.HttpServletResponse;
  4. import jakarta.validation.ConstraintViolationException;
  5. import org.slf4j.Logger;
  6. import org.slf4j.LoggerFactory;
  7. import org.springframework.validation.FieldError;
  8. import org.springframework.web.HttpRequestMethodNotSupportedException;
  9. import org.springframework.web.bind.MethodArgumentNotValidException;
  10. import org.springframework.web.bind.MissingServletRequestParameterException;
  11. import org.springframework.web.bind.annotation.ExceptionHandler;
  12. import org.springframework.web.bind.annotation.ModelAttribute;
  13. import org.springframework.web.bind.annotation.ResponseBody;
  14. import org.springframework.web.bind.annotation.RestControllerAdvice;
  15.  
  16. import java.util.Objects;
  17.  
  18. /**
  19.  * @author: dzg
  20.  * @date: 2023/9/18 17:12
  21.  * @describe: 全局异常拦截
  22.  */
  23. @RestControllerAdvice
  24. public class GlobalExceptionConfig {
  25.     private static final Logger log = LoggerFactory.getLogger(GlobalExceptionConfig.class);
  26.  
  27.     /**
  28.      * 在当前类每个方法进入之前触发的操作
  29.      *
  30.      * @param request
  31.      */
  32.     @ModelAttribute
  33.     public void get(HttpServletRequest request) {
  34.     }
  35.  
  36.     /**
  37.      * 参数校验的异常(post)
  38.      *
  39.      * @param ex
  40.      * @return
  41.      */
  42.     @ResponseBody
  43.     @ExceptionHandler(MethodArgumentNotValidException.class)
  44.     public Result<Object> methodArgumentNotValidException(HttpServletRequest request, MethodArgumentNotValidException ex) {
  45.         FieldError fieldError = ex.getBindingResult().getFieldError();
  46.         log.error("参数校验失败(POST):{}", Objects.requireNonNull(fieldError).getDefaultMessage());
  47.         return Result.error(ResultCode.CODE_INVALID_REQUEST.getCode(), fieldError.getDefaultMessage());
  48.     }
  49.  
  50.     /**
  51.      * 参数校验的异常(get)
  52.      *
  53.      * @param ex
  54.      * @return
  55.      */
  56.     @ResponseBody
  57.     @ExceptionHandler(ConstraintViolationException.class)
  58.     public Result<Object> constraintViolationException(HttpServletRequest request, ConstraintViolationException ex) {
  59.         log.error("参数校验失败(GET):{}", ex.getMessage());
  60.         return Result.error(ResultCode.CODE_INVALID_REQUEST.getCode(), ex.getMessage());
  61.     }
  62.  
  63.     /**
  64.      * 全局异常拦截（拦截项目中的所有异常）
  65.      *
  66.      * @param e
  67.      * @param request
  68.      * @param response
  69.      * @return
  70.      * @throws Exception
  71.      */
  72.     @ResponseBody
  73.     @ExceptionHandler(Exception.class)
  74.     public Result<Object> handlerException(Exception e, HttpServletRequest request, HttpServletResponse response){
  75.         return errorHandle(request, e);
  76.     }
  77.  
  78.     /**
  79.      * 异常处理 -这里拦截后就不会继续向上抛了
  80.      *
  81.      * @param e
  82.      * @return
  83.      */
  84.     public static Result<Object> errorHandle(HttpServletRequest request, Exception e) {
  85.         // 输出异常防止不展示调试时困难
  86.         e.printStackTrace();
  87.         Result<Object> result;
  88.         // 不同异常返回不同状态码
  89.         if (e instanceof CustomException cx) {
  90.             result = customExceptionHandle(cx);
  91.         } else if (e instanceof HttpRequestMethodNotSupportedException) {
  92.             result = Result.error(ResultCode.CODE_METHOD_NOT_ALLOWED);
  93.         } else if (e instanceof MissingServletRequestParameterException) {
  94.             result = Result.error(ResultCode.CODE_MISSING_PARAMETER);
  95.         } else {
  96.             // 返回给前端 // 普通(未知)异常 , 输出：500 + 异常信息
  97.             result = Result.error(e.getMessage());
  98.         }
  99.         return result;
  100.     }
  101.  
  102.     /**
  103.      * 自定义异常处理
  104.      *
  105.      * @param exception
  106.      * @return
  107.      */
  108.     private static Result<Object> customExceptionHandle(CustomException exception) {
  109.         //可以处理特殊的业务
  110.         return Result.error(exception.getCode(), exception.getMessage());
  111.     }
  112.  
  113. }

此时到这里就可以拦截任意controller异常了，但是有个问题，那就是不能拦掉过滤器中的自定义异常或者其他异常..大致思路就是创建一个过滤器优先级最高，然后捕获异常并处理。

过滤器捕获异常

  1.  
  2. import com.alibaba.fastjson2.JSONObject;
  3. import jakarta.servlet.*;
  4. import jakarta.servlet.http.HttpServletRequest;
  5. import jakarta.servlet.http.HttpServletResponse;
  6. import org.springframework.http.HttpStatus;
  7. import org.springframework.web.context.support.SpringBeanAutowiringSupport;
  8.  
  9. import java.io.IOException;
  10. import java.io.OutputStream;
  11. import java.nio.charset.StandardCharsets;
  12.  
  13.  
  14. /**
  15.  * @author: dzg
  16.  * @date: 2023/9/18 23:26
  17.  * @describe:
  18.  */
  19. public class CommonFilter implements Filter {
  20.  
  21.     @Override
  22.     public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws IOException, ServletException {
  23.         // 请求进入时间
  24.         HttpServletResponse httpServletResponse = (HttpServletResponse) response;
  25.         HttpServletRequest httpServletRequest = (HttpServletRequest) request;
  26.         try {
  27.             chain.doFilter(request, httpServletResponse);
  28.             //请求耗时
  29.             if (HttpStatus.OK.value() != httpServletResponse.getStatus()) {
  30.                 responseError(httpServletRequest, httpServletResponse, HttpStatus.resolve(httpServletResponse.getStatus()));
  31.             }
  32.         } catch (Exception e) {
  33.             //请求耗时
  34.             Throwable error = (e.getCause() != null ? e.getCause() : e);
  35.             error.printStackTrace();
  36.             responseError(httpServletRequest, httpServletResponse, error);
  37.         }
  38.     }
  39.  
  40.     /**
  41.      * 主要用来处理 @{@link GlobalExceptionConfig} 拦截不到的异常
  42.      *
  43.      * @param httpServletResponse
  44.      * @param error
  45.      * @throws IOException
  46.      */
  47.     public static void responseError(HttpServletRequest request, HttpServletResponse httpServletResponse, Throwable error) throws IOException {
  48.         String errorMsg = JSONObject.toJSONString(GlobalExceptionConfig.errorHandle(request, (Exception) error));
  49.         responseError(request, httpServletResponse, errorMsg);
  50.     }
  51.  
  52.     public static void responseError(HttpServletRequest request, HttpServletResponse httpServletResponse, ResultCode resultCode) throws IOException {
  53.         String errorMsg = JSONObject.toJSONString(Result.error(resultCode));
  54.         responseError(request, httpServletResponse, errorMsg);
  55.     }
  56.  
  57.     public static void responseError(HttpServletRequest request, HttpServletResponse httpServletResponse, HttpStatus httpStatus) throws IOException {
  58.         String errorMsg = JSONObject.toJSONString(Result.error(httpStatus));
  59.         responseError(request, httpServletResponse, errorMsg);
  60.     }
  61.  
  62.     public static void responseError(HttpServletRequest request, HttpServletResponse httpServletResponse, String msg) throws IOException {
  63.         httpServletResponse.setContentType("application/json; charset=utf-8");
  64.         httpServletResponse.setCharacterEncoding(StandardCharsets.UTF_8.toString());
  65.         OutputStream out = httpServletResponse.getOutputStream();
  66.         out.write(msg.getBytes(StandardCharsets.UTF_8));
  67.         out.flush();
  68.     }
  69.  
  70.     @Override
  71.     public void init(FilterConfig filterConfig) throws ServletException {
  72.         SpringBeanAutowiringSupport.processInjectionBasedOnServletContext(this, filterConfig.getServletContext());
  73.     }
  74.  
  75.     @Override
  76.     public void destroy() {
  77.     }
  78.  
  79. }

过滤器测试类

  1.  
  2. import jakarta.servlet.*;
  3. import jakarta.servlet.http.HttpServletRequest;
  4.  
  5. import java.io.IOException;
  6.  
  7. /**
  8.  * @Author: dzg
  9.  * @Date: 2023/9/18 23:04
  10.  * @Describe:
  11.  */
  12. public class TestFilter implements Filter {
  13.  
  14.  
  15.     @Override
  16.     public void doFilter(ServletRequest servletRequest, ServletResponse servletResponse, FilterChain filterChain) throws IOException, ServletException {
  17.  
  18.         HttpServletRequest request = (HttpServletRequest) servletRequest;
  19.         if (request.getRequestURI().contains("/test3")){
  20.             // 测试异常
  21.             throw new CustomException(ResultCode.CODE_CUSTOM_EXCEPTION);
  22.         }
  23.         filterChain.doFilter(servletRequest, servletResponse);
  24.     }
  25. }

注册过滤器

  1.  
  2. import org.springframework.boot.web.servlet.FilterRegistrationBean;
  3. import org.springframework.context.annotation.Bean;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.core.Ordered;
  6.  
  7. /**
  8.  * @author: dzg
  9.  * @date: 2023/9/18 23:26
  10.  * @describe: 注册过滤器类
  11.  */
  12. @Configuration
  13. public class FilterRegister {
  14.  
  15.  
  16.     @Bean
  17.     public CommonFilter commonFilter(){
  18.         return new CommonFilter();
  19.     }
  20.  
  21.     /**
  22.      * 通用过滤器---设定优先级最高
  23.      * @return
  24.      */
  25.     @Bean
  26.     public FilterRegistrationBean<CommonFilter> commonFilterRegistration() {
  27.         FilterRegistrationBean<CommonFilter> registration = new FilterRegistrationBean<>();
  28.         registration.setFilter(commonFilter());
  29.         registration.setName("commonFilter");
  30.         //此处尽量小，要比其他Filter靠前
  31.         registration.setOrder(Ordered.HIGHEST_PRECEDENCE);
  32.         return registration;
  33.     }
  34.  
  35.     @Bean
  36.     public TestFilter testFilter(){
  37.         return new TestFilter();
  38.     }
  39.     @Bean
  40.     public FilterRegistrationBean<TestFilter> testFilterRegistration() {
  41.         FilterRegistrationBean<TestFilter> registration = new FilterRegistrationBean<>();
  42.         registration.setFilter(testFilter());
  43.         registration.setName("testFilter");
  44.         registration.setOrder(-1);
  45.         return registration;
  46.     }
  47. }

到此就结束了，过滤器拦截异常的方法其实是可以代替全局异常类且比全局异常类可拦截异常范围更广，自己选就行了。

声明：本文内容由网友自发贡献，不代表【wpsshop博客】立场，版权归原作者所有，本站不承担相应法律责任。如您发现有侵权的内容，请联系我们。转载请注明出处：https://www.wpsshop.cn/w/菜鸟追梦旅行/article/detail/460433
推荐阅读
相关标签

Copyright © 2003-2013 www.wpsshop.cn 版权所有，并保留所有权利。

  

闽ICP备14008679号