SpringBoot之HandlerInterceptor拦截器的使用详解
前言
平常项目开发过程中，会遇到登录拦截，权限校验，参数处理，防重复提交等问题，那拦截器就能帮我们统一处理这些问题。
一、实现方式
1.1 自定义拦截器
自定义拦截器，即拦截器的实现类，一般有两种自定义方式：
定义一个类，实现org.springframework.web.servlet.HandlerInterceptor接口。
定义一个类，继承已实现了HandlerInterceptor接口的类，例如org.springframework.web.servlet.handler.HandlerInterceptorAdapter抽象类。
1.2 添加Interceptor拦截器到WebMvcConfigurer配置器中
自定义配置器，然后实现WebMvcConfigurer配置器。
以前一般继承org.springframework.web.servlet.config.annotation.WebMvcConfigurerAdapter类，不过SrpingBoot 2.0以上WebMvcConfigurerAdapter类就过时了。有以下2中替代方法：
直接实现org.springframework.web.servlet.config.annotation.WebMvcConfigurer接口。（推荐）
继承org.springframework.web.servlet.config.annotation.WebMvcConfigurationSupport类。但是继承WebMvcConfigurationSupport会让SpringBoot对mvc的自动配置失效。不过目前大多数项目是前后端分离，并没有对静态资源有自动配置的需求，所以继承WebMvcConfigurationSupport也未尝不可。
二、HandlerInterceptor 方法介绍
preHandle：预处理，在业务处理器处理请求之前被调用，可以进行登录拦截，编码处理、安全控制、权限校验等处理；
default boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
return true;
}
postHandle：后处理，在业务处理器处理请求执行完成后，生成视图之前被调用。即调用了Service并返回ModelAndView，但未进行页面渲染，可以修改ModelAndView，这个比较少用。
default void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
@Nullable ModelAndView modelAndView) throws Exception {
}
afterCompletion：返回处理，在DispatcherServlet完全处理完请求后被调用，可用于清理资源等。已经渲染了页面。
default void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler,
@Nullable Exception ex) throws Exception {
}
三、拦截器（Interceptor）实现
3.1 实现HandlerInterceptor
此拦截器演示了通过注解形式，对用户权限进行拦截校验。
package com.nobody.interceptor;
import com.nobody.annotation.UserAuthenticate;
import com.nobody.context.UserContext;
import com.nobody.context.UserContextManager;
import com.nobody.exception.RestAPIError;
import com.nobody.exception.RestException;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
/**
* @Description
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Slf4j
@Component
public class UserPermissionInterceptor implements HandlerInterceptor {
private UserContextManager userContextManager;
@Autowired
public void setContextManager(UserContextManager userContextManager) {
this.userContextManager = userContextManager;
}
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) {
log.info(">>> UserPermissionInterceptor preHandle -- ");
if (handler instanceof HandlerMethod) {
HandlerMethod handlerMethod = (HandlerMethod) handler;
// 获取用户权限校验注解(优先获取方法，无则再从类获取)
UserAuthenticate userAuthenticate =
handlerMethod.getMethod().getAnnotation(UserAuthenticate.class);
if (null == userAuthenticate) {
userAuthenticate = handlerMethod.getMethod().getDeclaringClass()
.getAnnotation(UserAuthenticate.class);
}
if (userAuthenticate != null && userAuthenticate.permission()) {
// 获取用户信息
UserContext userContext = userContextManager.getUserContext(request);
// 权限校验
if (userAuthenticate.type() != userContext.getType()) {
// 如若不抛出异常，也可返回false
throw new RestException(RestAPIError.AUTH_ERROR);
}
}
}
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) {
log.info(">>> UserPermissionInterceptor postHandle -- ");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
log.info(">>> UserPermissionInterceptor afterCompletion -- ");
}
}
3.2 继承HandlerInterceptorAdapter
package com.nobody.interceptor;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import org.springframework.stereotype.Component;
import lombok.extern.slf4j.Slf4j;
import org.springframework.web.servlet.ModelAndView;
import org.springframework.web.servlet.handler.HandlerInterceptorAdapter;
/**
* @Description
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Slf4j
@Component
public class UserPermissionInterceptorAdapter extends HandlerInterceptorAdapter {
@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response,
Object handler) {
log.info(">>> UserPermissionInterceptorAdapter preHandle -- ");
return true;
}
@Override
public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler,
ModelAndView modelAndView) {
log.info(">>> UserPermissionInterceptorAdapter postHandle -- ");
}
@Override
public void afterCompletion(HttpServletRequest request, HttpServletResponse response,
Object handler, Exception ex) {
log.info(">>> UserPermissionInterceptorAdapter afterCompletion -- ");
}
}
四、配置器（WebMvcConfigurer）实现
4.1 实现WebMvcConfigurer（推荐）
package com.nobody.config;
import com.nobody.context.UserContextResolver;
import com.nobody.interceptor.UserPermissionInterceptor;
import com.nobody.interceptor.UserPermissionInterceptorAdapter;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
import java.util.List;
/**
* @Description
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Configuration
public class WebAppConfigurer implements WebMvcConfigurer {
private UserPermissionInterceptor userPermissionInterceptor;
private UserPermissionInterceptorAdapter userPermissionInterceptorAdapter;
private UserContextResolver userContextResolver;
@Autowired
public void setUserPermissionInterceptor(UserPermissionInterceptor userPermissionInterceptor) {
this.userPermissionInterceptor = userPermissionInterceptor;
}
@Autowired
public void setUserPermissionInterceptorAdapter(
UserPermissionInterceptorAdapter userPermissionInterceptorAdapter) {
this.userPermissionInterceptorAdapter = userPermissionInterceptorAdapter;
}
@Autowired
public void setUserContextResolver(UserContextResolver userContextResolver) {
this.userContextResolver = userContextResolver;
}
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 可以添加多个拦截器，一般只添加一个
// addPathPatterns("/**") 表示对所有请求都拦截
// .excludePathPatterns("/base/index") 表示排除对/base/index请求的拦截
// 多个拦截器可以设置order顺序，值越小，preHandle越先执行，postHandle和afterCompletion越后执行
// order默认的值是0，如果只添加一个拦截器，可以不显示设置order的值
registry.addInterceptor(userPermissionInterceptor).addPathPatterns("/**")
.excludePathPatterns("/base/index").order(0);
// registry.addInterceptor(userPermissionInterceptorAdapter).addPathPatterns("/**")
// .excludePathPatterns("/base/index").order(1);
}
@Override
public void addArgumentResolvers(List<HandlerMethodArgumentResolver> resolvers) {
resolvers.add(userContextResolver);
}
}
4.2 继承WebMvcConfigurationSupport
package com.nobody.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.WebMvcConfigurationSupport;
import com.nobody.interceptor.UserPermissionInterceptor;
import com.nobody.interceptor.UserPermissionInterceptorAdapter;
/**
* @Description
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Configuration
public class WebAppConfigurerSupport extends WebMvcConfigurationSupport {
@Autowired
private UserPermissionInterceptor userPermissionInterceptor;
// @Autowired
// private UserPermissionInterceptorAdapter userPermissionInterceptorAdapter;
@Override
public void addInterceptors(InterceptorRegistry registry) {
// 可以添加多个拦截器，一般只添加一个
// addPathPatterns("/**") 表示对所有请求都拦截
// .excludePathPatterns("/base/index") 表示排除对/base/index请求的拦截
registry.addInterceptor(userPermissionInterceptor).addPathPatterns("/**")
.excludePathPatterns("/base/index");
// registry.addInterceptor(userPermissionInterceptorAdapter).addPathPatterns("/**")
// .excludePathPatterns("/base/index");
}
}
五、其他主要辅助类
5.1 用户上下文类
package com.nobody.context;
import com.nobody.enums.AuthenticationTypeEnum;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
/**
* @Description 用户上下文
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Getter
@Setter
@ToString
public class UserContext {
// 用户名称
private String name;
// 用户ID
private String userId;
// 用户类型
private AuthenticationTypeEnum type;
}
5.2 校验访问权限注解
package com.nobody.context;
import com.nobody.enums.AuthenticationTypeEnum;
import lombok.Getter;
import lombok.Setter;
import lombok.ToString;
/**
* @Description 用户上下文
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Getter
@Setter
@ToString
public class UserContext {
// 用户名称
private String name;
// 用户ID
private String userId;
// 用户类型
private AuthenticationTypeEnum type;
}
5.3 用户上下文操作类
package com.nobody.context;
import com.nobody.enums.AuthenticationTypeEnum;
import com.nobody.exception.RestAPIError;
import com.nobody.exception.RestException;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Component;
import org.springframework.util.StringUtils;
import javax.servlet.http.Cookie;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Objects;
import java.util.UUID;
/**
* @Description 用户上下文操作类
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Component
public class UserContextManager {
private static final String COOKIE_KEY = "__userToken";
// @Autowired
// private RedisService redisService;
/**
* 获取用户上下文信息
*
* @param request
* @return
*/
public UserContext getUserContext(HttpServletRequest request) {
String userToken = getUserToken(request, COOKIE_KEY);
if (!StringUtils.isEmpty(userToken)) {
// 从缓存或者第三方获取用户信息
// String userContextStr = redisService.getString(userToken);
// if (!StringUtils.isEmpty(userContextStr)) {
// return JSON.parseObject(userContextStr, UserContext.class);
// }
// 因为演示，没集成Redis，故简单new对象
UserContext userContext = new UserContext();
userContext.setName("Mr.nobody");
userContext.setUserId("0000001");
userContext.setType(AuthenticationTypeEnum.ADMIN);
return userContext;
}
throw new RestException(RestAPIError.AUTH_ERROR);
}
public String getUserToken(HttpServletRequest request, String cookieKey) {
Cookie[] cookies = request.getCookies();
if (null != cookies) {
for (Cookie cookie : cookies) {
if (Objects.equals(cookie.getName(), cookieKey)) {
return cookie.getValue();
}
}
}
return null;
}
/**
* 保存用户上下文信息
*
* @param response
* @param userContextStr
*/
public void saveUserContext(HttpServletResponse response, String userContextStr) {
// 用户token实际根据自己业务进行生成，此处简单用UUID
String userToken = UUID.randomUUID().toString();
// 设置cookie
Cookie cookie = new Cookie(COOKIE_KEY, userToken);
cookie.setPath("/");
response.addCookie(cookie);
// redis缓存
// redisService.setString(userToken, userContextStr, 3600);
}
}
5.4 方法参数解析器类
package com.nobody.context;
import lombok.extern.slf4j.Slf4j;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.core.MethodParameter;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.support.WebDataBinderFactory;
import org.springframework.web.context.request.NativeWebRequest;
import org.springframework.web.method.support.HandlerMethodArgumentResolver;
import org.springframework.web.method.support.ModelAndViewContainer;
import javax.servlet.http.HttpServletRequest;
/**
* @Description 对有UserContext参数的接口，进行拦截注入用户信息
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@Component
@Slf4j
public class UserContextResolver implements HandlerMethodArgumentResolver {
@Autowired
private UserContextManager userContextManager;
@Override
public Object resolveArgument(MethodParameter parameter, ModelAndViewContainer mavContainer,
NativeWebRequest webRequest, WebDataBinderFactory binderFactory) {
log.info(">>> resolveArgument -- begin...");
HttpServletRequest request = webRequest.getNativeRequest(HttpServletRequest.class);
// 从缓存获取用户信息赋值到接口参数中
return userContextManager.getUserContext(request);
}
/**
* 只对UserContext参数进行拦截赋值
*
* @param methodParameter
* @return
*/
@Override
public boolean supportsParameter(MethodParameter methodParameter) {
if (methodParameter.getParameterType().equals(UserContext.class)) {
return true;
}
return false;
}
}
六、测试验证
package com.nobody.controller;
import com.alibaba.fastjson.JSON;
import com.nobody.annotation.UserAuthenticate;
import com.nobody.context.UserContext;
import com.nobody.context.UserContextManager;
import com.nobody.enums.AuthenticationTypeEnum;
import com.nobody.pojo.model.GeneralResult;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.RestController;
import javax.servlet.http.HttpServletResponse;
/**
* @Description
* @Author Mr.nobody
* @Date 2020/10/25
* @Version 1.0
*/
@RestController
@RequestMapping("user")
public class UserController {
@Autowired
private UserContextManager userContextManager;
@GetMapping("login")
public GeneralResult<UserContext> doLogin(HttpServletResponse response) {
UserContext userContext = new UserContext();
userContext.setUserId("0000001");
userContext.setName("Mr.nobody");
userContext.setType(AuthenticationTypeEnum.ADMIN);
userContextManager.saveUserContext(response, JSON.toJSONString(userContext));
return GeneralResult.genSuccessResult(userContext);
}
@GetMapping("personal")
@UserAuthenticate(permission = true, type = AuthenticationTypeEnum.ADMIN)
public GeneralResult<UserContext> getPersonInfo(UserContext userContext) {
return GeneralResult.genSuccessResult(userContext);
}
}
启动服务后，在浏览器先调用personal接口，因为没有登录，所以会报错没有权限：
控制台输出：
启动服务后，在浏览器先访问login接口进行登录，再访问personal接口，验证通过，正确返回用户信息：
七、Github项目
项目工程可从Github获取，https://github.com/LucioChn/springboot-common.git
到此这篇关于SpringBoot之HandlerInterceptor拦截器的使用详解的文章就介绍到这了,更多相关SpringBoot HandlerInterceptor拦截器内容请搜索我们以前的文章或继续浏览下面的相关文章希望大家以后多多支持我们！
相关推荐
-
详解SpringBoot AOP 拦截器（Aspect注解方式）
常用用于实现拦截的有:Filter.HandlerInterceptor.MethodInterceptor 第一种Filter属于Servlet提供的,后两者是spring提供的,HandlerInterceptor属于Spring MVC项目提供的,用来拦截请求,在MethodInterceptor之前执行. 实现一个HandlerInterceptor可以实现接口HandlerInterceptor,也可以继承HandlerInterceptorAdapter类,两种方法一样.这个不在本文
-
详谈springboot过滤器和拦截器的实现及区别
前言 springmvc中有两种很普遍的AOP实现: 1.过滤器(Filter) 2.拦截器(Interceptor) 本篇面对的是一些刚接触springboot的人群 所以主要讲解filter和interceptor的简单实现和它们之间到底有什么区别 (一些复杂的功能我会之后发出文章,请记得关注) Filter的简单实现 字面意思:过滤器就是过滤的作用,在web开发中过滤一些我们指定的url 那么它能帮我们过滤什么呢? 那功能可就多了: 比如过拦截掉我们不需要的接口请求 修改请求(reques
-
spring boot实现过滤器和拦截器demo
整理文档,搜刮出一个spring boot实现过滤器和拦截器demo ,稍微整理精简一下做下分享. 拦截器定义: @WebServlet public class ActionInterceptor implements HandlerInterceptor { @Override public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Ex
-
Spring Boot项目实战之拦截器与过滤器
一.拦截器与过滤器 在讲Spring boot之前,我们先了解一下过滤器和拦截器.这两者在功能方面很类似,但是在具体技术实现方面,差距还是比较大的.在分析两者的区别之前,我们先理解一下AOP的概念,AOP不是一种具体的技术,而是一种编程思想.在面向对象编程的过程中,我们很容易通过继承.多态来解决纵向扩展. 但是对于横向的功能,比如,在所有的service方法中开启事务,或者统一记录日志等功能,面向对象的是无法解决的.所以AOP--面向切面编程其实是面向对象编程思想的一个补充.而我们今天讲的过滤器
-
SpringBoot快速设置拦截器并实现权限验证的方法
一.概述 拦截器的使用场景越来越多,尤其是面向切片编程流行之后.那通常拦截器可以做什么呢? 之前我们在Agent介绍中,提到过统计函数的调用耗时.这个思路其实和AOP的环绕增强如出一辙. 那一般来说,场景如下: 函数增强:比如对一个函数进行参数检查,或者结果过滤等.甚至可以对函数就行权限认证. 性能监控:统计函数性能. 日志打点:比如在用户登录函数之前,打点统计PV等信息. 以及其他等等. 二.Spring的拦截器 无论是SpringMVC或者SpringBoot中,关于拦截器不得不提: org
-
spring boot如何添加拦截器
构建一个spring boot项目. 添加拦截器需要添加一个configuration @Configuration @ComponentScan(basePackageClasses = Application.class, useDefaultFilters = true) public class ServletContextConfig extends WebMvcConfigurationSupport { 为了方便扫描位置,我们可以写一个接口或者入口类Application放置于最外
-
springboot实现拦截器之验证登录示例
整理文档,搜刮出一个springboot实现拦截器之验证登录示例,稍微整理精简一下做下分享. 添加jar包,这个jar包不是必须的,只是在拦截器里用到了,如果不用的话,完全可以不引入 <dependency> <groupId>org.apache.commons</groupId> <artifactId>commons-lang3</artifactId> <version>3.5</version> </dep
-
SpringBoot之HandlerInterceptor拦截器的使用详解
前言 平常项目开发过程中,会遇到登录拦截,权限校验,参数处理,防重复提交等问题,那拦截器就能帮我们统一处理这些问题. 一.实现方式 1.1 自定义拦截器 自定义拦截器,即拦截器的实现类,一般有两种自定义方式: 定义一个类,实现org.springframework.web.servlet.HandlerInterceptor接口. 定义一个类,继承已实现了HandlerInterceptor接口的类,例如org.springframework.web.servlet.handler.Handle
-
SpringBoot实现登录拦截器的方法详解
在项目目录下建立两个包:inter 与contsfig 在inter新建层中实现HandlerInterceptor的继承类 package com.example.gameboxadminserver.inter; import com.example.gameboxadminserver.entity.User; import org.springframework.web.servlet.HandlerInterceptor; import org.springframework.web.
-
SpringBoot配置自定义拦截器实现过程详解
目录 1. HttpServletRequest包装类 2. 使用Filter将request传递下去 3. 添加拦截器 4. 全局异常处理器 5. 配置拦截器 1. HttpServletRequest包装类 因为HttpServletRequest只能读取一次,所以需要对request进行包装,变成可重复读的request. package net.lesscoding.interceptor; import javax.servlet.ReadListener; import javax.
-
在springboot中使用拦截器的步骤详解
目录 在springboot中使用拦截器 1. 定义拦截器 2. 使用JavaConfig注册拦截器 3. 定义控制器,测试拦截器 4. 总结 在springboot中使用拦截器 拦截器Interceptor,是SpringMVC中的核心内容,利用spring的AOP(Aspect Oriented Programming, 面向切面编程)特性,可以很方便的对用户的业务代码进行横向抽取,根据具体业务需求对应用功能进行增强.在SpringBoot中使用Interceptor,同时采用全注解开发,涉
-
SpringBoot配置拦截器实现过程详解
目录 如何配置拦截器 拦截器设置容易出现的问题 如何取消拦截操作 实例-登录验证 如何配置拦截器 step1: 自定义拦截器 /** * 自定义拦截器 */ public class MyInterceptor implements HandlerInterceptor { private static final Logger logger = LoggerFactory.getLogger(MyInterceptor.class); /** * 在请求匹配controller之前执行,返回t
-
Spring Boot项目中定制拦截器的方法详解
这篇文章主要介绍了Spring Boot项目中定制拦截器的方法详解,文中通过示例代码介绍的非常详细,对大家的学习或者工作具有一定的参考学习价值,需要的朋友可以参考下 Servlet 过滤器属于Servlet API,和Spring关系不大.除了使用过滤器包装web请求,Spring MVC还提供HandlerInterceptor(拦截器)工具.根据文档,HandlerInterceptor的功能跟过滤器类似,但拦截器提供更精细的控制能力:在request被响应之前.request被响应之后.视
-
Spring MVC 拦截器 interceptor 用法详解
Spring MVC-拦截器 今天就是把有关拦截器的知识做一个总结. 1.拦截器概述 1.1 什么是拦截器? Spring MVC中的拦截器(Interceptor)类似于Servlet中的过滤器(Filter),它主要用于拦截用户请求并作相应的处理.例如通过拦截器可以进行权限验证.记录请求信息的日志.判断用户是否登录等. 要使用Spring MVC中的拦截器,就需要对拦截器类进行定义和配置.通常拦截器类可以通过两种方式来定义. 1.通过实现HandlerInterceptor接口,或继承Han
-
vue-resource 拦截器interceptors使用详解
前言 拦截器-interceptor 在现代的一些前端框架上,拦截器基本上是很基础但很重要的一环,比如Angular原生就支持拦截器配置,VUE的Axios模块也给我们提供了拦截器配置,那么拦截器到底是什么,它有什么用? 拦截器能帮助我们解决的 添加统一的request的参数 比如header中加入X-Requested-With,比如客户端需要实现sign和token的验证机制,比如你可以写$http.get('/files', params),拦截器帮你拼接成 http://www.xxxx
-
SpringMVC自定义拦截器实现过程详解
SpringMVC的处理器拦截器类似于Servlet开发中的过滤器Filter,用于对处理器进行预处理和后处理.开发者可以自定义一些拦截器来实现特点的功能. 过滤器与拦截器的区别:拦截器是AOP思想的具体应用. 过滤器 servlet规范中的一部分,任何java web工程都可以使用 在url-pattern中配置了/*之后,可以对所有要访问的资源进行拦截 拦截器 拦截是SpringMVC框架自己的,只要使用SpringMVC框架的工程才能使用 拦截器只会拦截访问的控制方法,如果访问的是jsp/
-
Mybatis自定义拦截器和插件开发详解
前言 在Spring中我们经常会使用到拦截器,在登录验证.日志记录.性能监控等场景中,通过使用拦截器允许我们在不改动业务代码的情况下,执行拦截器的方法来增强现有的逻辑.在mybatis中,同样也有这样的业务场景,有时候需要我们在不侵入原有业务代码的情况下拦截sql,执行特定的某些逻辑.那么这个过程应该怎么实现呢,同样,在mybatis中也为开发者预留了拦截器接口,通过实现自定义拦截器这一功能,可以实现我们自己的插件,允许用户在不改动mybatis的原有逻辑的条件下,实现自己的逻辑扩展. 本文将按