详解SpringBoot中的统一功能处理的实现

作者:yyhgo_ 时间:2022-07-06 12:14:49 

前言

接下来是 Spring Boot 统⼀功能处理模块了,也是 AOP 的实战环节,要实现的课程⽬标有以下 3 个:

  • 统⼀⽤户登录权限验证

  • 统⼀数据格式返回

  • 统⼀异常处理

接下我们⼀个⼀个来看。

一、用户登录权限效验

⽤户登录权限的发展从之前每个⽅法中⾃⼰验证⽤户登录权限,到现在统⼀的⽤户登录验证处理,它是⼀个逐渐完善和逐渐优化的过程。

1.1 最初的用户登录验证

我们先来回顾⼀下最初⽤户登录验证的实现⽅法:

@RestController
@RequestMapping("/user")
public class UserController {
   /**
    * 某⽅法 1
    */
   @RequestMapping("/m1")
   public Object method(HttpServletRequest request) {
       // 有 session 就获取,没有不会创建
       HttpSession session = request.getSession(false);
       if (session != null && session.getAttribute("userinfo") != null) {
           // 说明已经登录,业务处理
           return true;
       } else {
           // 未登录
           return false;
       }
   }
   /**
    * 某⽅法 2
    */
   @RequestMapping("/m2")
   public Object method2(HttpServletRequest request) {
       // 有 session 就获取,没有不会创建
       HttpSession session = request.getSession(false);
       if (session != null && session.getAttribute("userinfo") != null) {
           // 说明已经登录,业务处理
           return true;
       } else {
           // 未登录
           return false;
       }
   }
   // 其他⽅法...
}

从上述代码可以看出,每个⽅法中都有相同的⽤户登录验证权限,它的缺点是:

  • 每个⽅法中都要单独写⽤户登录验证的⽅法,即使封装成公共⽅法,也⼀样要传参调⽤和在⽅法中进⾏判断。

  • 添加控制器越多,调⽤⽤户登录验证的⽅法也越多,这样就增加了后期的修改成本和维护成本。

  • 这些⽤户登录验证的⽅法和接下来要实现的业务⼏何没有任何关联,但每个⽅法中都要写⼀遍。

所以提供⼀个公共的 AOP ⽅法来进⾏统⼀的⽤户登录权限验证迫在眉睫。

1.2 Spring AOP 用户统一登录验证的问题

说到统⼀的⽤户登录验证,我们想到的第⼀个实现⽅案是 Spring AOP 前置通知或环绕通知来实现,具体实现代码如下:

import org.aspectj.lang.ProceedingJoinPoint;
import org.aspectj.lang.annotation.*;
import org.springframework.stereotype.Component;
@Aspect
@Component
public class UserAspect {
   // 定义切点⽅法 controller 包下、⼦孙包下所有类的所有⽅法
   @Pointcut("execution(* com.example.demo.controller..*.*(..))")
   public void pointcut(){ }
   // 前置⽅法
   @Before("pointcut()")
   public void doBefore(){

}

// 环绕⽅法
   @Around("pointcut()")
   public Object doAround(ProceedingJoinPoint joinPoint){
       Object obj = null;
       System.out.println("Around ⽅法开始执⾏");
       try {
           // 执⾏拦截⽅法
           obj = joinPoint.proceed();
       } catch (Throwable throwable) {
           throwable.printStackTrace();
       }
       System.out.println("Around ⽅法结束执⾏");
       return obj;
   }
}

如果要在以上 Spring AOP 的切⾯中实现⽤户登录权限效验的功能,有以下两个问题:

1.没办法获取到 HttpSession 对象。

2.我们要对⼀部分⽅法进⾏拦截,⽽另⼀部分⽅法不拦截,如注册⽅法和登录⽅法是不拦截的,这样的话排除⽅法的规则很难定义,甚⾄没办法定义。

那这样如何解决呢?

1.3 Spring *

对于以上问题 Spring 中提供了具体的实现 * :HandlerInterceptor, * 的实现分为以下两个步骤:

1.创建⾃定义 * ,实现 HandlerInterceptor 接⼝的 preHandle(执⾏具体⽅法之前的预处理)⽅法。

2.将⾃定义 * 加⼊ WebMvcConfigurer 的 addInterceptors ⽅法中。

具体实现如下。

补充 过滤器:

过滤器是Web容器提供的。触发的时机比 * 更靠前,Spring 初始化前就执行了,所以并不能处理用户登录权限效验等问题。

1.3.1 准备工作

package com.example.demo.controller;

import lombok.extern.slf4j.Slf4j;
import org.springframework.util.StringUtils;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;

@RestController
@RequestMapping("/user")
@Slf4j
public class UserController {

@RequestMapping("/login")
   public boolean login(HttpServletRequest request,
                        String username, String password) {
//        // 1.非空判断
//        if (username != null && username != "" &&
//                password != null && username != "") {
//            // 2.验证用户名和密码是否正确
//        }

// 1.非空判断
       if (StringUtils.hasLength(username) && StringUtils.hasLength(password)) {
           // 2.验证用户名和密码是否正确
           if ("admin".equals(username) && "admin".equals(password)) {
               // 登录成功
               HttpSession session = request.getSession();
               session.setAttribute("userinfo", "admin");
               return true;
           } else {
               // 用户名或密码输入错误
               return false;
           }
       }
       return false;
   }

@RequestMapping("/getinfo")
   public String getInfo() {
       log.debug("执行了 getinfo 方法");
       return "执行了 getinfo 方法";
   }

@RequestMapping("/reg")
   public String reg() {
       log.debug("执行了 reg 方法");
       return "执行了 reg 方法";
   }

}

1.3.2 自定义 *

接下来使⽤代码来实现⼀个⽤户登录的权限效验,⾃定义 * 是⼀个普通类,具体实现代码如下:

package com.example.demo.config;

import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Component;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
* 登录 *
*/
@Component
@Slf4j
public class LoginInterceptor implements HandlerInterceptor {

@Override
   public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       // 登录判断业务
       HttpSession session = request.getSession(false);
       if (session != null && session.getAttribute("userinfo") != null) {
           return true;
       }
       log.error("当前用户没有访问权限");
       response.setStatus(401);
       return false;
   }
}

返回 boolean 类型。

相当于一层安保:

为 false 则不能继续往下执行;为 true 则可以。

详解SpringBoot中的统一功能处理的实现

1.3.3 将自定义 * 加入到系统配置

将上⼀步中的⾃定义 * 加⼊到系统配置信息中,具体实现代码如下:

package com.example.demo.config;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.ResourceHandlerRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

@Configuration // 一定不要忘记
public class MyConfig implements WebMvcConfigurer {

@Autowired
   private LoginInterceptor loginInterceptor;

@Override
   public void addInterceptors(InterceptorRegistry registry) {
       registry.addInterceptor(loginInterceptor)
               .addPathPatterns("/**") // 拦截所有请求
               .excludePathPatterns("/user/login") // 排除不拦截的 url
//                .excludePathPatterns("/**/*.html")
//                .excludePathPatterns("/**/*.js")
//                .excludePathPatterns("/**/*.css")
               .excludePathPatterns("/user/reg"); // 排除不拦截的 url
   }
}

或者:

package com.example.demo.common;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import java.util.ArrayList;
import java.util.List;

@Configuration
public class AppConfig implements WebMvcConfigurer {

// 不拦截的 url 集合
   List<String> excludes = new ArrayList<String>() {{
       add("/**/*.html");
       add("/js/**");
       add("/editor.md/**");
       add("/css/**");
       add("/img/**"); // 放行 static/img 下的所有文件
       add("/user/login"); // 放行登录接口
       add("/user/reg"); // 放行注册接口
       add("/art/detail"); // 放行文章详情接口
       add("/art/list"); // 放行文章分页列表接口
       add("/art/totalpage"); // 放行文章分页总页数接口
   }};

@Autowired
   private LoginInterceptor loginInterceptor;

@Override
   public void addInterceptors(InterceptorRegistry registry) {
       // 配置 *
       InterceptorRegistration registration =
               registry.addInterceptor(loginInterceptor);
       registration.addPathPatterns("/**");
       registration.excludePathPatterns(excludes);
   }
}

如果不注入对象的话,addInterceptor() 的参数也可以直接 new 一个对象:

@Configuration // 一定不要忘记
public class MyConfig implements WebMvcConfigurer {

@Override
   public void addInterceptors(InterceptorRegistry registry) {
       registry.addInterceptor(new LoginInterceptor())
               .addPathPatterns("/**") // 拦截所有请求
               .excludePathPatterns("/user/login") // 排除不拦截的 url
//                .excludePathPatterns("/**/*.html")
//                .excludePathPatterns("/**/*.js")
//                .excludePathPatterns("/**/*.css")
//                .excludePathPatterns("/**/*.jpg")
//                .excludePathPatterns("/**/login")
               .excludePathPatterns("/user/reg"); // 排除不拦截的 url
   }
}

其中:

addPathPatterns:表示需要拦截的 URL,&ldquo;**&rdquo;表示拦截任意⽅法(也就是所有⽅法)。

excludePathPatterns:表示需要排除的 URL。

说明:以上拦截规则可以拦截此项⽬中的使⽤ URL,包括静态⽂件 (图⽚⽂件、JS 和 CSS 等⽂件)。

1.4 * 实现原理

正常情况下的调⽤顺序:

详解SpringBoot中的统一功能处理的实现

然⽽有了 * 之后,会在调⽤ Controller 之前进⾏相应的业务处理,执⾏的流程如下图所示:

详解SpringBoot中的统一功能处理的实现

1.4.1 实现原理源码分析

所有的 Controller 执⾏都会通过⼀个调度器 DispatcherServlet 来实现,这⼀点可以从 Spring Boot 控制台的打印信息看出,如下图所示:

详解SpringBoot中的统一功能处理的实现

⽽所有⽅法都会执⾏ DispatcherServlet 中的 doDispatch 调度⽅法,doDispatch 源码如下:

protected void doDispatch(HttpServletRequest request, HttpServletResponse
           response) throws Exception {
       HttpServletRequest processedRequest = request;
       HandlerExecutionChain mappedHandler = null;
       boolean multipartRequestParsed = false;
       WebAsyncManager asyncManager = WebAsyncUtils.getAsyncManager(request);
       try {
           try {
               ModelAndView mv = null;
               Object dispatchException = null;
               try {
                   processedRequest = this.checkMultipart(request);
                   multipartRequestParsed = processedRequest != request;
                   mappedHandler = this.getHandler(processedRequest);
                   if (mappedHandler == null) {
                       this.noHandlerFound(processedRequest, response);
                       return;
                   }
                   HandlerAdapter ha = this.getHandlerAdapter(mappedHandler.g
                           etHandler());
                   String method = request.getMethod();
                   boolean isGet = HttpMethod.GET.matches(method);
                   if (isGet || HttpMethod.HEAD.matches(method)) {
                       long lastModified = ha.getLastModified(request, mapped
                               Handler.getHandler());
                       if ((new ServletWebRequest(request, response)).checkNo
                       tModified(lastModified) && isGet) {
                           return;
                       }
                   }
                   // 调⽤预处理【重点】
                   if (!mappedHandler.applyPreHandle(processedRequest, respon
                           se)) {
                       return;
                   }
                   // 执⾏ Controller 中的业务
                   mv = ha.handle(processedRequest, response, mappedHandler.g
                           etHandler());
                   if (asyncManager.isConcurrentHandlingStarted()) {
                       return;
                   }
                   this.applyDefaultViewName(processedRequest, mv);
                   mappedHandler.applyPostHandle(processedRequest, response,
                           mv);
               } catch (Exception var20) {
                   dispatchException = var20;
               } catch (Throwable var21) {
                   dispatchException = new NestedServletException("Handler di
                           spatch failed", var21);
               }
               this.processDispatchResult(processedRequest, response, mappedH
                       andler, mv, (Exception)dispatchException);
           } catch (Exception var22) {
               this.triggerAfterCompletion(processedRequest, response, mapped
                       Handler, var22);
           } catch (Throwable var23) {
               this.triggerAfterCompletion(processedRequest, response, mapped
                       Handler, new NestedServletException("Handler processing failed", var23));
           }
       } finally {
           if (asyncManager.isConcurrentHandlingStarted()) {
               if (mappedHandler != null) {
                   mappedHandler.applyAfterConcurrentHandlingStarted(processe
                           dRequest, response);
               }
           } else if (multipartRequestParsed) {
               this.cleanupMultipart(processedRequest);
           }
       }
   }

从上述源码可以看出在开始执⾏ Controller 之前,会先调⽤ 预处理⽅法 applyPreHandle,⽽applyPreHandle ⽅法的实现源码如下:

boolean applyPreHandle(HttpServletRequest request, HttpServletResponse response) throws Exception {
       for(int i = 0; i < this.interceptorList.size(); this.interceptorIndex
               = i++) {
           // 获取项⽬中使⽤的 * HandlerInterceptor
           HandlerInterceptor interceptor = (HandlerInterceptor)this.intercep
           torList.get(i);
           if (!interceptor.preHandle(request, response, this.handler)) {
               this.triggerAfterCompletion(request, response, (Exception)null
               );
               return false;
           }
       }
       return true;
   }

从上述源码可以看出,在 applyPreHandle 中会获取所有的 * HandlerInterceptor 并执⾏ * 中的 preHandle ⽅法,这样就会咱们前⾯定义的 * 对应上了,如下图所示:

详解SpringBoot中的统一功能处理的实现

此时⽤户登录权限的验证⽅法就会执⾏,这就是 * 的实现原理。

1.4.2 * 小结

通过上⾯的源码分析,我们可以看出,Spring 中的 * 也是通过 * 和环绕通知的思想实现的,⼤体的调⽤流程如下:

详解SpringBoot中的统一功能处理的实现

1.5 扩展:统一访问前缀添加

所有请求地址添加 api 前缀:

@Configuration
   public class AppConfig implements WebMvcConfigurer {
       // 所有的接⼝添加 api 前缀
       @Override
       public void configurePathMatch(PathMatchConfigurer configurer) {
           configurer.addPathPrefix("api", c -> true);
       }
   }

其中第⼆个参数是⼀个表达式,设置为 true 表示启动前缀。

二、统一异常处理

统⼀异常处理使⽤的是 @ControllerAdvice + @ExceptionHandler 来实现的,@ControllerAdvice 表示控制器通知类,@ExceptionHandler 是异常处理器,两个结合表示当出现异常的时候执⾏某个通知,也就是执⾏某个⽅法事件,具体实现代码如下:

package com.example.demo.config;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

import java.util.HashMap;

/**
* 统一处理异常
*/
@ControllerAdvice
public class ErrorAdive {

@ExceptionHandler(Exception.class)
   @ResponseBody
   public HashMap<String, Object> exceptionAdvie(Exception e) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("code", "-1");
       result.put("msg", e.getMessage());
       return result;
   }

@ExceptionHandler(ArithmeticException.class)
   @ResponseBody
   public HashMap<String, Object> arithmeticAdvie(ArithmeticException e) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("code", "-2");
       result.put("msg", e.getMessage());
       return result;
   }

}

方法名和返回值可以⾃定义,重要的是 @ControllerAdvice 和 @ExceptionHandler 注解。

以上⽅法表示,如果出现了异常就返回给前端⼀个 HashMap 的对象,其中包含的字段如代码中定义的那样。

我们可以针对不同的异常,返回不同的结果,⽐以下代码所示:

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;
import java.util.HashMap;
@ControllerAdvice
@ResponseBody
public class ExceptionAdvice {
   @ExceptionHandler(Exception.class)
   public Object exceptionAdvice(Exception e) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("success", -1);
       result.put("message", "总的异常信息:" + e.getMessage());
       result.put("data", null);
       return result;
   }
   @ExceptionHandler(NullPointerException.class)
   public Object nullPointerexceptionAdvice(NullPointerException e) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("success", -1);
       result.put("message", "空指针异常:" + e.getMessage());
       result.put("data", null);
       return result;
   }
}

当有多个异常通知时,匹配顺序为当前类及其子类向上依次匹配,案例演示:

在 UserController 中设置⼀个空指针异常,实现代码如下:

@RestController
   @RequestMapping("/u")
   public class UserController {
       @RequestMapping("/index")
       public String index() {
           Object obj = null;
           int i = obj.hashCode();
           return "Hello,User Index.";
       }
   }

以上程序的执⾏结果如下:

详解SpringBoot中的统一功能处理的实现

此时若出现异常就不会报错了,代码会继续执行,但是会把自定义的异常信息返回给前端!

统一完数据返回格式后:

package com.example.demo.common;

import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.bind.annotation.ResponseBody;

/**
* 异常类的统一处理
*/
@ControllerAdvice
@ResponseBody
public class ExceptionAdvice {

@ExceptionHandler(Exception.class)
   public Object exceptionAdvice(Exception e) {
       return AjaxResult.fail(-1, e.getMessage());
   }

}

统一异常处理不用配置路径,是拦截整个项目中的所有异常。

三、统一数据返回格式

3.1 为什么需要统一数据返回格式

统⼀数据返回格式的优点有很多,比如以下几个:

  • ⽅便前端程序员更好的接收和解析后端数据接⼝返回的数据。

  • 降低前端程序员和后端程序员的沟通成本,按照某个格式实现就⾏了,因为所有接⼝都是这样返回的。

  • 有利于项⽬统⼀数据的维护和修改。

  • 有利于后端技术部⻔的统⼀规范的标准制定,不会出现稀奇古怪的返回内容。

3.2 统一数据返回格式的实现

统⼀的数据返回格式可以使用 @ControllerAdvice + ResponseBodyAdvice接口 的方式实现,具体实现代码如下:

import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyA
dvice;

import java.util.HashMap;

/**
* 统一返回数据的处理
*/
@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
   /**
    * 内容是否需要重写(通过此⽅法可以选择性部分控制器和⽅法进⾏重写)
    * 返回 true 表示重写
    */
   @Override
   public boolean supports(MethodParameter returnType, Class converterTyp
e) {
       return true;
   }
   /**
    * ⽅法返回之前调⽤此⽅法
    */
   @Override
   public Object beforeBodyWrite(Object body, MethodParameter returnType,
                                 MediaType selectedContentType,
                                 Class selectedConverterType, ServerHttpR
                                         equest request,
                                 ServerHttpResponse response) {
       // 构造统⼀返回对象
       HashMap<String, Object> result = new HashMap<>();
       result.put("state", 1);
       result.put("msg", "");
       result.put("data", body);
       return result;
   }
}

统一处理后,此时所有返回的都是 json 格式的数据了。

若方法的返回类型为 String,统一数据返回格式封装后,返回会报错!?

转换器的问题,解决方案:

详解SpringBoot中的统一功能处理的实现

实际开发中这种统一数据返回格式的方式并不常用。因为它会将所有返回都再次进行封装,过于霸道了 ~

而通常我们会写一个统一封装的类,让程序猿在返回时统一返回这个类 (软性约束),例如:

package com.example.demo.common;

import java.util.HashMap;

/**
* 自定义的统一返回对象
*/
public class AjaxResult {
   /**
    * 业务执行成功时进行返回的方法
    *
    * @param data
    * @return
    */
   public static HashMap<String, Object> success(Object data) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("code", 200);
       result.put("msg", "");
       result.put("data", data);
       return result;
   }

/**
    * 业务执行成功时进行返回的方法
    *
    * @param data
    * @return
    */
   public static HashMap<String, Object> success(String msg, Object data) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("code", 200);
       result.put("msg", msg);
       result.put("data", data);
       return result;
   }

/**
    * 业务执行失败返回的数据格式
    *
    * @param code
    * @param msg
    * @return
    */
   public static HashMap<String, Object> fail(int code, String msg) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("code", code);
       result.put("msg", msg);
       result.put("data", "");
       return result;
   }

/**
    * 业务执行失败返回的数据格式
    *
    * @param code
    * @param msg
    * @return
    */
   public static HashMap<String, Object> fail(int code, String msg, Object data) {
       HashMap<String, Object> result = new HashMap<>();
       result.put("code", code);
       result.put("msg", msg);
       result.put("data", data);
       return result;
   }
}

同时搭配统一数据返回格式:

package com.example.demo.common;

import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.SneakyThrows;
import org.springframework.core.MethodParameter;
import org.springframework.http.MediaType;
import org.springframework.http.server.ServerHttpRequest;
import org.springframework.http.server.ServerHttpResponse;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.servlet.mvc.method.annotation.ResponseBodyAdvice;

import java.util.HashMap;

/**
* 统一数据返回封装
*/
@ControllerAdvice
public class ResponseAdvice implements ResponseBodyAdvice {
   @Override
   public boolean supports(MethodParameter returnType, Class converterType) {
       return true;
   }

@SneakyThrows
   @Override
   public Object beforeBodyWrite(Object body, MethodParameter returnType, MediaType selectedContentType, Class selectedConverterType, ServerHttpRequest request, ServerHttpResponse response) {
       if (body instanceof HashMap) { // 本身已经是封装好的对象
           return body;
       }
       if (body instanceof String) { // 返回类型是 String(特殊)
           ObjectMapper objectMapper = new ObjectMapper();
           return objectMapper.writeValueAsString(AjaxResult.success(body));
       }
       return AjaxResult.success(body);
   }
}

3.3 @ControllerAdvice 源码分析(了解)

通过对 @ControllerAdvice 源码的分析我们可以知道上⾯统⼀异常和统⼀数据返回的执⾏流程,我们先从 @ControllerAdvice 的源码看起,点击 @ControllerAdvice 实现源码如下:

详解SpringBoot中的统一功能处理的实现

从上述源码可以看出 @ControllerAdvice 派⽣于 @Component 组件,⽽所有组件初始化都会调用 InitializingBean 接⼝。

所以接下来我们来看 InitializingBean 有哪些实现类?在查询的过程中我们发现了,其中 Spring MVC中的实现⼦类是 RequestMappingHandlerAdapter,它⾥⾯有⼀个⽅法 afterPropertiesSet() ⽅法,表示所有的参数设置完成之后执⾏的⽅法,如下图所示:

详解SpringBoot中的统一功能处理的实现

⽽这个⽅法中有⼀个 initControllerAdviceCache ⽅法,查询此⽅法的源码如下:

详解SpringBoot中的统一功能处理的实现

我们发现这个⽅法在执⾏是会查找使⽤所有的 @ControllerAdvice 类,这些类会被容器中,但发⽣某个事件时,调⽤相应的 Advice ⽅法,⽐如返回数据前调⽤统⼀数据封装,⽐如发⽣异常是调⽤异常的 Advice ⽅法实现。

来源:https://blog.csdn.net/yyhgo_/article/details/128755308

标签:SpringBoot,统一,功能,处理
0
投稿

猜你喜欢

  • SpringBoot定制三种错误页面及错误数据方法示例

    2022-03-10 01:15:55
  • java Comparator.comparing排序使用示例

    2021-07-23 16:01:59
  • Android实现从网络获取图片显示并保存到SD卡的方法

    2023-10-09 22:08:56
  • 详解使用Docker搭建Java Web运行环境

    2023-10-24 15:32:58
  • Java编程中的一些常见问题汇总

    2022-01-08 18:05:46
  • Java实现FIFO任务调度队列策略

    2021-09-19 09:05:37
  • 浅谈Unity中的Shader

    2022-03-25 05:15:07
  • Android 10 启动分析之init语法详解

    2022-03-12 05:07:16
  • C#实现的xml操作类完整实例

    2023-02-12 03:52:16
  • Netty分布式NioEventLoop任务队列执行源码分析

    2022-10-08 04:07:19
  • Android中的SpannableString与SpannableStringBuilder详解

    2022-03-02 22:04:55
  • spring boot项目没有mainClass如何实现打包运行

    2021-10-24 11:29:20
  • 一小时迅速入门Mybatis之初识篇

    2023-07-20 10:27:23
  • java遍历读取xml文件内容

    2023-11-12 09:59:09
  • 关于Intellij IDEA中的Version Control问题

    2021-12-27 08:42:01
  • Java实现红黑树(平衡二叉树)的详细过程

    2021-08-08 15:03:12
  • C++初阶教程之类和对象

    2021-07-24 18:53:46
  • C#反射内存的处理分析

    2022-04-30 00:56:22
  • Java事务的个人理解小结

    2023-11-29 12:10:37
  • C# 6.0 的知识梳理

    2021-07-21 22:08:17
  • asp之家 软件编程 m.aspxhome.com