SpringMVC/SpringBoot--全局异常处理/全局响应/全局请求--实例

深碍√TFBOYSˉ_ 2022-09-11 10:17 487阅读 0赞

原文网址：[SpringMVC/SpringBoot--全局异常处理/全局响应/全局请求--实例\_IT利刃出鞘的博客-CSDN博客][SpringMVC_SpringBoot--_--_IT_-CSDN]

# 简介 #

**简介**

**@ControllerAdvice**里边有@Component，用于类，可包含@ExceptionHandler，@InitBinder和@ModelAttribute方法，适用于所有使用@RequestMapping方法。（因此是**全局的处理方法**）。

可以在多个类上使用@ControllerAdvice，可通过@Order来控制顺序。不能通过实现Order接口来控制顺序，因为这部分源码里只支持@Order这种方式。见：[调整多个ControllerAdvice的执行顺序\_felixu的博客-CSDN博客][ControllerAdvice_felixu_-CSDN]。

在Spring4及之后， @ControllerAdvice支持配置控制器的子集，可通过annotations(), basePackageClasses(), basePackages()方法选择控制器子集。Spring4之前，@ControllerAdvice在同一调度的Servlet中协助所有控制器。

**官网网址**

[springmvc 注解总结 - SpringMVC中文官网][springmvc _ - SpringMVC]

**使用场景**

1.  @ControllerAdvice+@ExceptionHandler：全局异常处理
    
    1.  捕获Controller中抛出的指定类型异常，可对不同类型的异常区别处理
2.  @ControllerAdvice+ 实现ResponseBodyAdvice接口：全局响应处理（返回值）
    
    1.  其标注的方法将会在目标Controller方法执行之后执行。
3.  @ControllerAdvice+@ModelAttribute：全局请求处理
    
    1.  其标注的方法将会在目标Controller方法执行之前执行。
    2.  使用场景示例：鉴权/授权、全局处理格式
4.  @ControllerAdvice+@InitBinder：全局请求处理
    
    1.  其标注的方法将会在目标Controller方法执行之前执行。
    2.  request中自定义参数解析方式进行注册
    3.  使用场景示例：全局处理格式  
        [SpringBoot--LocalDateTime--全局格式转换/前后端/前端入参/响应给前端\_IT利刃出鞘的博客-CSDN博客][SpringBoot--LocalDateTime--_IT_-CSDN]

如果在@ControllerAdvice里边同时用了上边的注解，整个执行流程为：

过滤器=> 拦截器=> @ModelAttribute标记的方法=> @InitBinder标记的方法=> Controller=>  
@ExceptionHandler标记的方法（如果出现了异常）=> 实现ResponseBodyAdvice接口的方法

# 公共代码 #

下边这两个类好几处都用到了，单独把它提出来。

**User实体类**

package com.example.business.entity;
     
    import lombok.AllArgsConstructor;
    import lombok.Data;
     
    @Data
    @AllArgsConstructor
    public class User {
        private Long id;
        private String userName;
        private Integer age;
    }

**响应的包装**

package com.example.demo.common.entity;
    
    import lombok.Data;
    
    @Data
    public class Result<T> {
        private boolean success = true;
    
        private int code = 1000;
    
        private String message;
    
        private T data;
    
        public Result() {
        }
    
        public Result(boolean success) {
            this.success = success;
        }
    
        public Result<T> success(boolean success) {
            Result<T> result = new Result<>(success);
            if (success) {
                result.code = 1000;
            } else {
                result.code = 1001;
            }
            return result;
        }
    
        public Result<T> success() {
            return success(true);
        }
    
        public Result<T> failure() {
            return success(false);
        }
    
        /**
         * @param code {@link ResultCode#getCode()}
         */
        public Result<T> code(int code) {
            this.code = code;
            return this;
        }
    
        public Result<T> message(String message) {
            this.message = message;
            return this;
        }
    
        public Result<T> data(T data) {
            this.data = data;
            return this;
        }
    }

# 全局异常(**@ExceptionHandler)** #

## **实例：简单** ##

返回值用任何类型都可以，类似Controller的返回值。

package com.example.config;
    
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.ResponseStatus;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    
    import javax.servlet.http.HttpServletRequest;
    import java.util.HashMap;
    
    @Slf4j
    @ControllerAdvice
    public class GlobalExceptionAdvice {
        @ExceptionHandler({Exception.class})
        @ResponseBody
        public Object handleException(HttpServletRequest request, Exception e) throws Exception {
            log.error(e.getMessage(), e);
            // 如果某个自定义异常有@ResponseStatus注解，就继续抛出
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
            HashMap<String, Object> map = new HashMap<>();
            map.put("message", "全局异常处理" + e.getMessage());
            return map;
        }
    }

**controller**

package com.example.controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class HelloController {
    
        @GetMapping("/advice")
        public String test() {
            int i = 1 / 0;
            return "test success";
        }
    }

**测试**

访问：[http://localhost:8080/advice][http_localhost_8080_advice]

前端结果：

{
        "message": "全局异常处理/ by zero"
    }

后端结果：

2021-08-18 00:39:20.240 ERROR 31064 --- [nio-8080-exec-1] c.example.config.GlobalExceptionAdvice   : / by zero
    
    java.lang.ArithmeticException: / by zero
    	at com.example.controller.HelloController.test(HelloController.java:11) ~[classes/:na]
    	...

## **实例：项目实战** ##

**异常处理类**

package com.example.common.advice;
    
    import com.example.common.entity.Result;
    import com.example.common.exception.BusinessException;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.web.bind.annotation.*;
    
    @Slf4j
    @ControllerAdvice
    @RestControllerAdvice  //Rest风格
    public class GlobalExceptionAdvice {
        // 处理其他所有异常
        @ExceptionHandler(Exception.class)
        @ResponseBody
        public Result<Object> handleException(Exception e) throws Exception {
            log.error(e.getMessage(), e);
    
            // 如果某个自定义异常有@ResponseStatus注解，就继续抛出
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
    
            // 实际项目中应该这样写，防止用户看到详细的异常信息
            // return new Result().failure().message.message("操作失败");
            return new Result<>().failure().message(e.getMessage());
        }
    
        // 处理自定义异常
        @ExceptionHandler(BusinessException.class)
        @ResponseBody
        public Result<Object> handleBusinessException(Exception e) throws Exception {
            log.error(e.getMessage(), e);
    
            // 如果某个自定义异常有@ResponseStatus注解，就继续抛出
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
    
            // 实际项目中应该这样写，防止用户看到详细的异常信息
            // return new Result<>().failure().message("操作失败");
            return new Result<>().failure().message(e.getMessage());
        }
    }

或者这么写

import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.RestControllerAdvice;
    
    @Slf4j
    @ControllerAdvice
    public class GlobalExceptionHandler {
        @ExceptionHandler(Exception.class)
        @ResponseBody
        public Result handleException(Exception e){
            log.error(e.getMessage(), e);
    
            // 如果某个自定义异常有@ResponseStatus注解，就继续抛出
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
            
            // 处理所有业务异常
            if (e instanceOf BusinessException.class){
                return Result.failure().message(e.getMessage());
            }
    
            // 防止用户看到详细的异常信息
            return Result.failure().message("操作失败");
        }
    }

**自定义异常**

package com.example.common.exception;
    
    public class BusinessException extends RuntimeException{
        public BusinessException() {
            super();
        }
    
        public BusinessException(String message) {
            super(message);
        }
    
        public BusinessException(String message, Throwable cause) {
            super(message, cause);
        }
    }

**Controller（无需处理异常了）**

package com.example.business.controller;
    
    import com.example.business.entity.User;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("user")
    public class UserController {
    
        @GetMapping("fault")
        public void fault() {
            int i = 1 / 0;
        }
    
    }

**包装返回值**

**测试**

postman访问：[http://localhost:8080/user/fault][http_localhost_8080_user_fault]

postman结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16][]

后端结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 1][]

# 全局响应(**ResponseBodyAdvice接口)** #

## **实例** ##

**@ControllerAdvice类**

package com.example.common.advice;
    
    import com.example.common.entity.Result;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.core.MethodParameter;
    import org.springframework.http.MediaType;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    
    @ControllerAdvice
    public class GlobalResponseBodyAdvice implements ResponseBodyAdvice<Object> {
    
        @Override
        public boolean supports(MethodParameter returnType,
                                Class<? extends HttpMessageConverter<?>> converterType) {
            // 若接口返回的类型本身就是ResultWrapper，则无需操作，返回false
            // return !returnType.getParameterType().equals(ResultWrapper.class);
            System.out.println("GlobalResponseBodyAdvice#supports");
            return true;
        }
    
        @Override
        @ResponseBody
        public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                      MediaType selectedContentType,
                                      Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                      ServerHttpRequest request, ServerHttpResponse response) {
            System.out.println("GlobalResponseBodyAdvice#beforeBodyWrite");
            if (body instanceof String) {
                // 若返回值为String类型，需要包装为String类型返回。否则会报错
                try {
                    ObjectMapper objectMapper = new ObjectMapper();
                    Result<Object> result = new Result<>().data(body);
                    return objectMapper.writeValueAsString(result);
                } catch (JsonProcessingException e) {
                    throw new RuntimeException("序列化String错误");
                }
            } else if (body instanceof Result) {
                return body;
            } else if (isKnife4jUrl(request.getURI().getPath())) {
                // 如果是接口文档uri，直接跳过
                return body;
            }
            return new Result<>().data(body);
        }
    
        private boolean isKnife4jUrl(String uri) {
            // AntPathMatcher pathMatcher = new AntPathMatcher();
            // for (String s : WhiteList.KNIFE4J) {
            //     if (pathMatcher.match(s, uri)) {
            //         return true;
            //     }
            // }
            return false;
        }
    }

**实体类**

**controller**

package com.example.business.controller;
    
    import com.example.business.entity.User;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("user")
    public class UserController {
    
        @GetMapping("/getUser")
        public User getUser() {
            return new User(1L, "Tony", 23);
        }
    
    }

**返回值包装类**

**测试结果**

postman访问：[http://localhost:8080/user/getUser][http_localhost_8080_user_getUser]

postman结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_18_color_FFFFFF_t_70_g_se_x_16][]

后端结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_18_color_FFFFFF_t_70_g_se_x_16 1][]

# 全局请求(**@ModelAttribute)** #

## **简介** ##

@ControllerAdvice与@ModelAttribute结合可以全局处理请求，在调用Controller之前预先进行处理。

下边三种方式都可以全局处理请求（请求进来时，它们的执行顺序为从上到下）：

1.  过滤器
2.  拦截器
3.  @ControllerAdvice+@ModelAttribute

## 实例 ##

**全局请求处理类**

package com.example.common.advice;
    
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ModelAttribute;
    
    import javax.servlet.http.HttpServletRequest;
    
    @ControllerAdvice
    public class GlobalRequestAdvice {
        @ModelAttribute
        public void authenticationUser(HttpServletRequest request) {
            System.out.println("查询的参数：" + request.getQueryString());
            System.out.println("用户名参数：" + request.getParameter("userName"));
            System.out.println("header1值：" + request.getHeader("header1"));
        }
    }

**Controller**

package com.example.business.controller;
    
    import com.example.business.entity.User;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("user")
    public class UserController {
    
        @GetMapping("save")
        public void save(User user) {
            System.out.println("Controller保存用户：" + user);
        }
    }

**测试**

postman访问：[http://localhost:8080/user/save?userName=Tony&age=22][http_localhost_8080_user_save_userName_Tony_age_22]

//header设置：

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 2][]

后端结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 3][]

postman结果（本处我没返回东西，所以是空的）

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 4][]

# 全局格式处理(@InitBinder) #

**简介**

Spring MVC中提供了一个注解@InitBinder，它的作用是在执行控制器方法前，处理器会先执行@InitBinder标注的方法。这时可以将WebDataBinder对象作为参数传递到方法中，通过这层关系得到WebDataBinder对象。

可以进行的操作：设置时间格式、自定义参数。

在Controller下直接使用@InitBinder只对当前Controller生效。想全局生效，可用@ControllerAdvice或者WebBindingInitializer。

## **实例：全局处理写法** ##

**全局格式处理**

package com.example.common.advice;
    
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.InitBinder;
    
    import java.beans.PropertyEditorSupport;
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.time.LocalTime;
    import java.time.format.DateTimeFormatter;
    
    @ControllerAdvice
    public class GlobalRequestFormatAdvice {
        @InitBinder
        protected void initBinder(WebDataBinder binder) {
            binder.registerCustomEditor(LocalDateTime.class, new PropertyEditorSupport() {
                @Override
                public void setAsText(String text) throws IllegalArgumentException {
                    setValue(LocalDateTime.parse(text, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                }
            });
    
            binder.registerCustomEditor(LocalDate.class, new PropertyEditorSupport() {
                @Override
                public void setAsText(String text) throws IllegalArgumentException {
                    setValue(LocalDate.parse(text, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                }
            });
    
            binder.registerCustomEditor(LocalTime.class, new PropertyEditorSupport() {
                @Override
                public void setAsText(String text) throws IllegalArgumentException {
                    setValue(LocalTime.parse(text, DateTimeFormatter.ofPattern("HH:mm:ss")));
                }
            });
        }
    }

**Controller**

package com.example.business.controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.time.LocalDateTime;
    
    @RestController
    @RequestMapping("user")
    public class UserController {
    
        @GetMapping("/initBinder")
        public Object localDateTimeTest(LocalDateTime localDateTime) {
            System.out.println(localDateTime);
            return localDateTime;
        }
    }

**测试**

postman访问：http://localhost:8080/user/initBinder?localDateTime=2020-08-20 12:12:34

postman结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 5][]

后端结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_14_color_FFFFFF_t_70_g_se_x_16][]

## 实例：单独Controller写法 ##

**设置时间参数**

package com.example.controller;
    
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.InitBinder;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.beans.PropertyEditorSupport;
    import java.time.LocalDate;
    import java.time.LocalDateTime;
    import java.time.LocalTime;
    import java.time.format.DateTimeFormatter;
    
    @RestController
    @RequestMapper("user")
    public class UserController {
        @InitBinder
        protected void initBinder(WebDataBinder binder) {
            binder.registerCustomEditor(LocalDateTime.class, new PropertyEditorSupport() {
                @Override
                public void setAsText(String text) throws IllegalArgumentException {
                    setValue(LocalDateTime.parse(text, DateTimeFormatter.ofPattern("yyyy-MM-dd HH:mm:ss")));
                }
            });
    
            binder.registerCustomEditor(LocalDate.class, new PropertyEditorSupport() {
                @Override
                public void setAsText(String text) throws IllegalArgumentException {
                    setValue(LocalDate.parse(text, DateTimeFormatter.ofPattern("yyyy-MM-dd")));
                }
            });
    
            binder.registerCustomEditor(LocalTime.class, new PropertyEditorSupport() {
                @Override
                public void setAsText(String text) throws IllegalArgumentException {
                    setValue(LocalTime.parse(text, DateTimeFormatter.ofPattern("HH:mm:ss")));
                }
            });
        }
    
        @RequestMapping(value = "/initBinder")
        public Object localDateTimeTest(LocalDateTime localDateTime) {
            System.out.println(localDateTime);
            return localDateTime;
        }
    }

**value属性（全局、单独Controller都适用）**

若指定了value值，那么只有方法参数名（或者模型名）匹配上了此注解方法才会执行（若不指定，都执行）。

package com.example.controller;
    
    import com.example.entity.User;
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.*;
    
    import javax.servlet.http.HttpServletRequest;
    
    @RestController
    public class HelloController {
        @InitBinder({"param", "user"})
        public void initBinder(WebDataBinder binder, HttpServletRequest request) {
            System.out.println("当前key：" + binder.getObjectName());
        }
    
        @ResponseBody
        @RequestMapping("/initbinder")
        public Object testInitBinder(String param, String date,
                                     @ModelAttribute("user") User user) {
            System.out.println(user.getName());
            return param + ":" + date;
        }
    }

浏览器访问：[http://localhost:8080/initbinder?param=abc&date=2019&user.name=demoUser][http_localhost_8080_initbinder_param_abc_date_2019_user.name_demoUser]

后端输出

当前key：param
    当前key：user
    null

前端输出

abc:2019

虽然此处有key是user.name，但是User对象可是不会封装到此值的(因为request.getParameter('user')没这个key。

解决方法：

**法1：加前缀**

package com.example.controller;
    
    import com.example.entity.User;
    import org.springframework.web.bind.WebDataBinder;
    import org.springframework.web.bind.annotation.*;
    
    @RestController
    public class HelloController {
        @InitBinder({"param"})
        public void initBinderParam(WebDataBinder binder) {
            System.out.println("当前key：" + binder.getObjectName());
        }
    
        @InitBinder({"user"})
        public void initBinderUser(WebDataBinder binder) {
            binder.setFieldDefaultPrefix("user.");
            System.out.println("当前key：" + binder.getObjectName());
        }
    
        @ResponseBody
        @RequestMapping("/initbinder")
        public Object testInitBinder(String param, String date,
                                     @ModelAttribute("user") User user) {
            System.out.println(user.getName());
            return param + ":" + date;
        }
    }

后端输出

当前key：param
    当前key：user
    demoUser

前端输出

abc:2019

# 联合使用 #

**简介**

上边的全局处理方式，在实际项目中会同时使用多个，有以下两种方案

1.  写到一个@ControllerAdvice注解的类中。
2.  每个全局处理单独写一个类，用@Order标记执行顺序（下边的实例展示此方法）。
    
    1.  此时设置的优先级由高到低依次是：
        
        1.  @ModelAttribute/@InitBinder注解的方法
        2.  @ExceptionHandler注解的方法
        3.  实现ResponseBodyAdvice的方法

**全局异常处理**

package com.example.common.advice;
    
    import com.example.common.entity.Result;
    import com.example.common.exception.BusinessException;
    import lombok.extern.slf4j.Slf4j;
    import org.springframework.core.Ordered;
    import org.springframework.core.annotation.AnnotationUtils;
    import org.springframework.core.annotation.Order;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ExceptionHandler;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.bind.annotation.ResponseStatus;
    
    @Slf4j
    @ControllerAdvice
    @Order(Ordered.LOWEST_PRECEDENCE - 1)
    // @RestControllerAdvice  //Rest风格
    public class GlobalExceptionAdvice {
        // 处理其他所有异常
        @ExceptionHandler(Exception.class)
        @ResponseBody
        public Result<Object> handleException(Exception e) throws Exception {
            log.error(e.getMessage(), e);
    
            // 如果某个自定义异常有@ResponseStatus注解，就继续抛出
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
    
            // 实际项目中应该这样写，防止用户看到详细的异常信息
            // return new Result().failure().message.message("操作失败");
            return new Result<>().failure().message(e.getMessage());
        }
    
        // 处理自定义异常
        @ExceptionHandler(BusinessException.class)
        @ResponseBody
        public Result<Object> handleBusinessException(Exception e) throws Exception {
            log.error(e.getMessage(), e);
    
            // 如果某个自定义异常有@ResponseStatus注解，就继续抛出
            if (AnnotationUtils.findAnnotation(e.getClass(), ResponseStatus.class) != null) {
                throw e;
            }
    
            // 实际项目中应该这样写，防止用户看到详细的异常信息
            // return new Result<>().failure().message("操作失败");
            return new Result<>().failure().message(e.getMessage());
        }
    }

**全局响应处理**

package com.example.common.advice;
    
    import com.example.common.entity.Result;
    import com.fasterxml.jackson.core.JsonProcessingException;
    import com.fasterxml.jackson.databind.ObjectMapper;
    import org.springframework.core.MethodParameter;
    import org.springframework.core.Ordered;
    import org.springframework.core.annotation.Order;
    import org.springframework.http.MediaType;
    import org.springframework.http.converter.HttpMessageConverter;
    import org.springframework.http.server.ServerHttpRequest;
    import org.springframework.http.server.ServerHttpResponse;
    import org.springframework.web.bind.annotation.ControllerAdvice;
    import org.springframework.web.bind.annotation.ResponseBody;
    import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;
    
    @Order(Ordered.LOWEST_PRECEDENCE)
    @ControllerAdvice
    public class GlobalResponseBodyAdvice implements ResponseBodyAdvice<Object> {
    
        @Override
        public boolean supports(MethodParameter returnType,
                                Class<? extends HttpMessageConverter<?>> converterType) {
            // 若接口返回的类型本身就是ResultWrapper，则无需操作，返回false
            // return !returnType.getParameterType().equals(ResultWrapper.class);
            System.out.println("GlobalResponseBodyAdvice#supports");
            return true;
        }
    
        @Override
        @ResponseBody
        public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                      MediaType selectedContentType,
                                      Class<? extends HttpMessageConverter<?>> selectedConverterType,
                                      ServerHttpRequest request, ServerHttpResponse response) {
            System.out.println("GlobalResponseBodyAdvice#beforeBodyWrite");
            if (body instanceof String) {
                // 若返回值为String类型，需要包装为String类型返回。否则会报错
                try {
                    ObjectMapper objectMapper = new ObjectMapper();
                    Result<Object> result = new Result<>().data(body);
                    return objectMapper.writeValueAsString(result);
                } catch (JsonProcessingException e) {
                    throw new RuntimeException("序列化String错误");
                }
            } else if (body instanceof Result) {
                return body;
            } else if (isKnife4jUrl(request.getURI().getPath())) {
                // 如果是接口文档uri，直接跳过
                return body;
            }
            return new Result<>().data(body);
        }
    
        private boolean isKnife4jUrl(String uri) {
            // AntPathMatcher pathMatcher = new AntPathMatcher();
            // for (String s : WhiteList.KNIFE4J) {
            //     if (pathMatcher.match(s, uri)) {
            //         return true;
            //     }
            // }
            return false;
        }
    }

**Controller**

package com.example.business.controller;
    
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RequestMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    @RequestMapping("user")
    public class UserController {
    
        @GetMapping("fault")
        public void fault() {
            int i = 1 / 0;
        }
    }

**测试**

postman访问：[http://localhost:8080/user/fault][http_localhost_8080_user_fault]

postman结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 6][]

后端结果

![watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 7][]

#  **其他网址** #

[SpringMVC重要注解（二）@ControllerAdvice\_Franco的博客-CSDN博客][SpringMVC_ControllerAdvice_Franco_-CSDN]  
[@ControllerAdvice + @ExceptionHandler 全局处理 Controller 层异常\_kinginblue的专栏-CSDN博客][ControllerAdvice _ _ExceptionHandler _ Controller _kinginblue_-CSDN]

[SpringMVC_SpringBoot--_--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120314868
[ControllerAdvice_felixu_-CSDN]: https://blog.csdn.net/xufei_0320/article/details/105604983
[springmvc _ - SpringMVC]: http://www.springmvc.cn/archives/60.html
[SpringBoot--LocalDateTime--_IT_-CSDN]: https://knife.blog.csdn.net/article/details/120335612
[http_localhost_8080_advice]: http://localhost:8080/advice
[http_localhost_8080_user_fault]: http://localhost:8080/user/fault
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/9f22cb99b11144b3bb0618d2641c7809.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/fc4afb58d8fd4a36b58c41b38af2a75f.png
[http_localhost_8080_user_getUser]: http://localhost:8080/user/getUser
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_18_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/9d2ff0c26a0a4eee9a53b55e4721ca43.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_18_color_FFFFFF_t_70_g_se_x_16 1]: /images/20220828/9c4c5226e6c042a18a85ff3ed06ab4d0.png
[http_localhost_8080_user_save_userName_Tony_age_22]: http://localhost:8080/user/save?userName=Tony&age=22
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 2]: /images/20220828/29f974c7c33440b7b2bb9d92c3b2cce7.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 3]: /images/20220828/49d671c09f2846b1821a8a8323555127.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 4]: /images/20220828/5f0dd8fdc4c143d99c8b3aa07b08b4ac.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 5]: /images/20220828/0927faa2079d4f38848c69b495f9c5c8.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_14_color_FFFFFF_t_70_g_se_x_16]: /images/20220828/29eed64ccf2142b4a59b60ae716fbce2.png
[http_localhost_8080_initbinder_param_abc_date_2019_user.name_demoUser]: http://localhost:8080/initbinder?param=abc&date=2019&user.name=demoUser
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 6]: /images/20220828/9243c54f195a429a8e2ae051b409cbb4.png
[watermark_type_ZHJvaWRzYW5zZmFsbGJhY2s_shadow_50_text_Q1NETiBASVTliKnliIPlh7rpnpg_size_20_color_FFFFFF_t_70_g_se_x_16 7]: /images/20220828/54ab1f63440547ad827c4d10939f31ef.png
[SpringMVC_ControllerAdvice_Franco_-CSDN]: https://blog.csdn.net/w372426096/article/details/78429141
[ControllerAdvice _ _ExceptionHandler _ Controller _kinginblue_-CSDN]: https://blog.csdn.net/kinginblue/article/details/70186586