Mybatis之Interceptor拦截器

最新推荐文章于 2024-09-18 22:12:47 发布
最新推荐文章于 2024-09-18 22:12:47 发布
阅读量3.6k 收藏 11
点赞数 2
分类专栏： MYBATIS 文章标签： mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qh870754310/article/details/113738127
版权

MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。那么拦截器拦截MyBatis中的哪些内容呢？
我们进入官网看一看：

MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

  • Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
  • ParameterHandler (getParameterObject, setParameters)
  • ResultSetHandler (handleResultSets, handleOutputParameters)
  • StatementHandler (prepare, parameterize, batch, update, query)
    这些类中方法的细节可以通过查看每个方法的签名来发现，或者直接查看 MyBatis 发行包中的源代码。 如果你想做的不仅仅是监控方法的调用，那么你最好相当了解要重写的方法的行为。 因为在试图修改或重写已有方法的行为时，很可能会破坏 MyBatis 的核心模块。 这些都是更底层的类和方法，所以使用插件的时候要特别当心。

我们看到了可以拦截Executor接口的部分方法，比如update，query，commit，rollback等方法，还有其他接口的一些方法等。

总体概括为：

  1. 拦截执行器的方法
  2. 拦截参数的处理
  3. 拦截结果集的处理
  4. 拦截Sql语法构建的处理

拦截器的使用

拦截器介绍及配置
首先我们看下MyBatis拦截器的接口定义：

public interface Interceptor {

  Object intercept(Invocation invocation) throws Throwable;

  Object plugin(Object target);

  void setProperties(Properties properties);

}

比较简单，只有3个方法。 MyBatis默认没有一个拦截器接口的实现类，开发者们可以实现符合自己需求的拦截器。

下面的MyBatis官网的一个拦截器实例：

// ExamplePlugin.java
@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})
public class ExamplePlugin implements Interceptor {
  private Properties properties = new Properties();
  public Object intercept(Invocation invocation) throws Throwable {
    // implement pre processing if need
    Object returnObject = invocation.proceed();
    // implement post processing if need
    return returnObject;
  }
  public void setProperties(Properties properties) {
    this.properties = properties;
  }
}

全局xml配置：

<plugins>
    <plugin interceptor="org.format.mybatis.cache.interceptor.ExamplePlugin"></plugin>
</plugins>

上面的插件将会拦截在 Executor 实例中所有的 “update” 方法调用， 这里的 Executor 是负责执行底层映射语句的内部对象。
这个拦截器拦截Executor接口的update方法（其实也就是SqlSession的新增，删除，修改操作），所有执行executor的update方法都会被该拦截器拦截到。

源码分析
下面我们分析一下这段代码背后的源码。

首先从源头->配置文件开始分析：

XMLConfigBuilder解析MyBatis全局配置文件的pluginElement私有方法：

private void pluginElement(XNode parent) throws Exception {
   if (parent != null) {
       Iterator var2 = parent.getChildren().iterator();

       while(var2.hasNext()) {
           XNode child = (XNode)var2.next();
           String interceptor = child.getStringAttribute("interceptor");
           Properties properties = child.getChildrenAsProperties();
           Interceptor interceptorInstance = (Interceptor)this.resolveClass(interceptor).newInstance();
           interceptorInstance.setProperties(properties);
           this.configuration.addInterceptor(interceptorInstance);
       }
   }

}

具体的解析代码其实比较简单，就不贴了，主要就是通过反射实例化plugin节点中的interceptor属性表示的类。然后调用全局配置类Configuration的addInterceptor方法。

public void addInterceptor(Interceptor interceptor) {
	 interceptorChain.addInterceptor(interceptor);
}

这个interceptorChain是Configuration的内部属性，类型为InterceptorChain，也就是一个拦截器链，我们来看下它的定义：

public class InterceptorChain {
    private final List<Interceptor> interceptors = new ArrayList();

    public InterceptorChain() {
    }

    public Object pluginAll(Object target) {
        Interceptor interceptor;
        for(Iterator var2 = this.interceptors.iterator(); var2.hasNext(); target = interceptor.plugin(target)) {
            interceptor = (Interceptor)var2.next();
        }

        return target;
    }

    public void addInterceptor(Interceptor interceptor) {
        this.interceptors.add(interceptor);
    }

    public List<Interceptor> getInterceptors() {
        return Collections.unmodifiableList(this.interceptors);
    }
}

现在我们理解了拦截器配置的解析以及拦截器的归属，现在我们回过头看下为何拦截器会拦截这些方法（Executor，ParameterHandler，ResultSetHandler，StatementHandler的部分方法）：

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
}

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
  ResultHandler resultHandler, BoundSql boundSql) {
    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
    return resultSetHandler;
}

public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
    return statementHandler;
}

public Executor newExecutor(Transaction transaction, ExecutorType executorType, boolean autoCommit) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor, autoCommit);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
}

以上4个方法都是Configuration的方法。这些方法在MyBatis的一个操作(新增，删除，修改，查询)中都会被执行到，执行的先后顺序是Executor，ParameterHandler，ResultSetHandler，StatementHandler(其中ParameterHandler和ResultSetHandler的创建是在创建StatementHandler[3个可用的实现类CallableStatementHandler,PreparedStatementHandler,SimpleStatementHandler]的时候，其构造函数调用的[这3个实现类的构造函数其实都调用了父类BaseStatementHandler的构造函数])。

这4个方法实例化了对应的对象之后，都会调用interceptorChain的pluginAll方法，InterceptorChain的pluginAll刚才已经介绍过了，就是遍历所有的拦截器，然后调用各个拦截器的plugin方法。注意：拦截器的plugin方法的返回值会直接被赋值给原先的对象

由于可以拦截StatementHandler，这个接口主要处理sql语法的构建，因此比如分页的功能，可以用拦截器实现，只需要在拦截器的plugin方法中处理StatementHandler接口实现类中的sql即可，可使用反射实现。

MyBatis还提供了 @Intercepts和 @Signature关于拦截器的注解。官网的例子就是使用了这2个注解，还包括了Plugin类的使用：

@Override
public Object plugin(Object target) {
    return Plugin.wrap(target, this);
}

下面我们就分析这3个 “新组合” 的源码，首先先看Plugin类的wrap方法：

public static Object wrap(Object target, Interceptor interceptor) {
    Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
    Class<?> type = target.getClass();
    Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
    if (interfaces.length > 0) {
      return Proxy.newProxyInstance(
          type.getClassLoader(),
          interfaces,
          new Plugin(target, interceptor, signatureMap));
    }
    return target;
}

Plugin类实现了InvocationHandler接口，很明显，我们看到这里返回了一个JDK自身提供的动态代理类。我们解剖一下这个方法调用的其他方法：

getSignatureMap方法：

private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
    Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
    if (interceptsAnnotation == null) { // issue #251
      throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());      
    }
    Signature[] sigs = interceptsAnnotation.value();
    Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();
    for (Signature sig : sigs) {
      Set<Method> methods = signatureMap.get(sig.type());
      if (methods == null) {
        methods = new HashSet<Method>();
        signatureMap.put(sig.type(), methods);
      }
      try {
        Method method = sig.type().getMethod(sig.method(), sig.args());
        methods.add(method);
      } catch (NoSuchMethodException e) {
        throw new PluginException("Could not find method on " + sig.type() + " named " + sig.method() + ". Cause: " + e, e);
      }
    }
    return signatureMap;
}

getSignatureMap方法解释：首先会拿到拦截器这个类的 @Interceptors注解，然后拿到这个注解的属性 @Signature注解集合，然后遍历这个集合，遍历的时候拿出 @Signature注解的type属性(Class类型)，然后根据这个type得到带有method属性和args属性的Method。由于 @Interceptors注解的 @Signature属性是一个属性，所以最终会返回一个以type为key，value为Set的Map。

@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})

比如这个 @Interceptors注解会返回一个key为Executor，value为集合(这个集合只有一个元素，也就是Method实例，这个Method实例就是Executor接口的update方法，且这个方法带有MappedStatement和Object类型的参数)。这个Method实例是根据 @Signature的method和args属性得到的。如果args参数跟type类型的method方法对应不上，那么将会抛出异常。

getAllInterfaces方法：

private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
    Set<Class<?>> interfaces = new HashSet<Class<?>>();
    while (type != null) {
      for (Class<?> c : type.getInterfaces()) {
        if (signatureMap.containsKey(c)) {
          interfaces.add(c);
        }
      }
      type = type.getSuperclass();
    }
    return interfaces.toArray(new Class<?>[interfaces.size()]);
}

getAllInterfaces方法解释：根据目标实例target(这个target就是之前所说的MyBatis拦截器可以拦截的类，Executor,ParameterHandler,ResultSetHandler,StatementHandler)和它的父类们，返回signatureMap中含有target实现的接口数组。

所以Plugin这个类的作用就是根据 @Interceptors注解，得到这个注解的属性 @Signature数组，然后根据每个 @Signature注解的type，method，args属性使用反射找到对应的Method。最终根据调用的target对象实现的接口决定是否返回一个代理对象替代原先的target对象。

比如MyBatis官网的例子，当Configuration调用newExecutor方法的时候，由于Executor接口的update(MappedStatement ms, Object parameter)方法被拦截器被截获。因此最终返回的是一个代理类Plugin，而不是Executor。这样调用方法的时候，如果是个代理类，那么会执行：

public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      Set<Method> methods = signatureMap.get(method.getDeclaringClass());
      if (methods != null && methods.contains(method)) {
        return interceptor.intercept(new Invocation(target, method, args));
      }
      return method.invoke(target, args);
    } catch (Exception e) {
      throw ExceptionUtil.unwrapThrowable(e);
    }
}

没错，如果找到对应的方法被代理之后，那么会执行Interceptor接口的interceptor方法。

这个Invocation类如下：

public class Invocation {

  private Object target;
  private Method method;
  private Object[] args;

  public Invocation(Object target, Method method, Object[] args) {
    this.target = target;
    this.method = method;
    this.args = args;
  }

  public Object getTarget() {
    return target;
  }

  public Method getMethod() {
    return method;
  }

  public Object[] getArgs() {
    return args;
  }

  public Object proceed() throws InvocationTargetException, IllegalAccessException {
    return method.invoke(target, args);
  }

}

它的proceed方法也就是调用原先方法(不走代理)。
MyBatis拦截器接口提供的3个方法中，plugin方法用于某些处理器(Handler)的构建过程。interceptor方法用于处理代理类的执行。setProperties方法用于拦截器属性的设置。

其实MyBatis官网提供的使用 @Interceptors和 @Signature注解以及Plugin类这样处理拦截器的方法，我们不一定要直接这样使用。我们也可以抛弃这3个类，直接在plugin方法内部根据target实例的类型做相应的操作。

qh870754310
关注
专栏目录
Mybatis——拦截器Interceptor
娜娜米的博客
05-08 3万+
本篇介绍Mybatis拦截器/插件相关知识，包括相关的类及作用、拦截器有哪几种、拦截器可以在Mybatis的执行过程中的哪些节点起作用、拦截器如何使用、相关的API，最后附上代码示例。
mybatis 拦截器
虚幻私塾
07-15 1630
拦截器可在mybatis进行sql底层处理的时候执行额外的逻辑，最常见的就是分页逻辑、对结果集进行处理过滤敏感信息等。}}}}}else{}}}从上面的代码可以看到mybatis支持的拦截类型只有四种（按拦截顺序）1.Executor执行器接口2.StatementHandlersql构建处理器3.ParameterHandler参数处理器4.ResultSetHandler结果集处理器。...
Mybatis拦截器Interceptor
wind_chasing_boy的博客
06-13 6786
最近项目使用Mybatis拦截器对数据进行加解密，以下记录如何将拦截器集成到项目中以及在使用过程中踩过的一些小坑，与君共勉Configuration：初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如插件，映射器，ObjectFactory和typeHandler对象，MyBatis所有的配置信息都维持在Configuration对象之中。SqlSessionFactory：SqlSession工厂。
拦截器Interceptor
最新发布
2302_77758423的博客
09-18 725
在Spring Boot中，拦截器是一种中间件，用于在请求到达控制器之前或之后执行一些通用的功能。比如：我们可以通过拦截器来拦截前端发起的请求，将登录校验的逻辑全部编写在拦截器当中。在校验的过程当中，如发现用户登录了(携带JWT令牌且是合法令牌)，就可以直接放行，去访问spring当中的资源。如果校验时发现并没有登录或是非法令牌，就可以直接给前端响应未登录的错误信息。它基于Spring MVC框架中的接口实现。通过创建一个自定义的拦截器类并实现该接口，可以定义拦截器要执行的逻辑和行为。
Mybatis拦截器
旧路
04-16 5万+
一 Mybatis拦截器介绍        Mybatis拦截器设计的初衷就是为了供用户在某些时候可以实现自己的逻辑而不必去动Mybatis固有的逻辑。通过Mybatis拦截器我们可以拦截某些方法的调用，我们可以选择在这些被拦截的方法执行前后加上某些逻辑，也可以在执行这些被拦截的方法时执行自己的逻辑而不再执行被拦截的方法。所以Mybatis拦截器的使用范围是...
mybatis的Interceptor
smileLs的博客
02-21 1711
mybatis的拦截器
Mybatis Interceptor 拦截器的实现
lemonrel的博客
10-11 3510
Mybatis采用责任链模式，通过动态代理组织多个拦截器（插件），通过这些拦截器可以改变Mybatis的默认行为（诸如SQL重写之类的），由于插件会深入到Mybatis的核心，因此在编写自己的插件前最好了解下它的原理，以便写出安全高效的插件。 拦截器（Interceptor）在 Mybatis 中被当做插件（plugin）对待，官方文档提供了 Executor，ParameterHandler，R...
通过Mybatis拦截器自动定位慢SQL并记录日志
05-30
Mybatis拦截器（Interceptor）是一种插件机制，它允许我们在Mybatis执行SQL语句之前或之后进行自定义操作，比如统计SQL执行时间、添加日志等。拦截器基于Java的动态代理实现，可以拦截Mapper接口方法的调用。 接...
mybatis-plus Interceptor 拦截器实现查询特殊字符以及特殊字符转义
qwertyu1234567g的博客
02-01 1417
\* 等特殊字符数据的模糊查询，现总结依据mybatis拦截器实现步骤如下;1. 实现Interceptor 重写intercept方法。2.对查询语句含有like模糊查询时，对查询参数进行转义处理。3. like 转化为对应的正则匹配函数查询。
Mybatis Interceptor 拦截器
weixin_34081595的博客
12-16 955
拦截器（Interceptor）在 Mybatis 中被当做插件（plugin）对待，官方文档提供了 Executor（拦截执行器的方法），ParameterHandler（拦截参数的处理），ResultSetHandler（拦截结果集的处理），StatementHandler（拦截Sql语法构建的处理） 共4种，并且提示“这些类中方法的...
Mybatis的拦截器Interceptor
Kwoky的博客
06-09 2229
Mybatis的拦截器Interceptor
mybatis拦截器
11-09
MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。
Mybatis 拦截器
qq_30436011的博客
12-02 6163
一.背景 在很多业务场景下我们需要去拦截sql，达到不入侵原有代码业务处理一些东西，比如：分页操作，数据权限过滤操作，SQL执行时间性能监控等等，这里我们就可以用到Mybatis的拦截器Interceptor 二.Mybatis核心对象介绍 从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个： Configuration 初始化基础配置，比如MyBatis的别名等，一些重要的类型对象，如，插件，映射器，ObjectFactory和typeHandl...
Mybatis拦截器介绍及分页插件
Elim的博客
04-21 1865
Mybatis拦截器介绍及分页插件 1.1    目录 1.1 目录 1.2 前言 1.3 Interceptor接口 1.4 注册拦截器 1.5 Mybatis可拦截的方法 1.6 利用拦截器进行分页 1.2     前言        拦截器的一个作用就是我们可以拦截某些方法的调用，我们可以选择在这些被拦截的方法执行前后加上某些逻辑，也可以在执行这些被拦截的方法时执行自...
MyBatis 插件之拦截器（Interceptor）
热门推荐
M义薄云天的博客
06-12 8万+
一.背景 在很多业务场景下我们需要去拦截sql，达到不入侵原有代码业务处理一些东西，比如：分页操作，数据权限过滤操作，SQL执行时间性能监控等等，这里我们就可以用到Mybatis的拦截器Interceptor 二.Mybatis核心对象介绍 从MyBatis代码实现的角度来看，MyBatis的主要的核心部件有以下几个： Configuration 初始化基础配置，比如MyBatis的别...
Mybatis Interceptor
你看我像菜鸟吗？
10-29 255
Mybatis支持对Executor、StatementHandler、PameterHandler和ResultSetHandler进行拦截，也就是说会对这4种对象进行代理。下面以Executor为例。Mybatis在创建Executor对象时会执行下面一行代码： executor =(Executor) interceptorChain.pluginAll(executor);  i...
mybatis：拦截器Interceptor:
QJY1437758743的博客
08-28 2530
定义特定注解，在切入时需要检查字段中是否包含注解来是否加解密。Intercepts注解需要一个Signature(拦截点)参数数组。说明： @Intercepts：标识该类是一个拦截器；@Signature：指明自定义拦截器需要拦截哪一个类型，哪一个方法；Mybatis 插件的使用就是通过实现 Mybatis 中的 Interceptor 接口。这个方法的作用是就是让mybatis判断，是否要进行拦截，然后做出决定是否生成一个代理。3.ParameterHandler：拦截参数的处理。
Mybatis之拦截器Interceptor
choubayan4320的博客
06-15 546
使用mybatis时用PageHelper进行分页，用到了PageInterceptor，借此了解下mybatis的interceptor。Mybatis的版本是3.4.6，MybatisHelper的版本是5.1.3。 1、PageInterceptor 先上一段代码，...
mybatis 拦截器interceptor
07-12
MyBatis拦截器（Interceptor）是MyBatis框架提供的一种高级功能，它允许开发者在数据访问的生命周期中添加自定义逻辑。Interceptor是一种基于AOP（面向切面编程）的概念，可以在执行SQL语句前、执行后、甚至更新结果集等关键点插入代码，进行事务管理、日志记录、权限检查等操作，而无需修改Mapper XML或基础Mapper接口。 MyBatis拦截器通常通过实现`org.apache.ibatis.session.interceptor.Interceptor`接口，并在配置文件中注册，然后在需要的地方注入到`SqlSession`中来启用。常见的拦截器包括： 1. `BeforeCallback`：在查询开始之前调用，可以设置参数、获取数据库连接等。 2. `AfterCallback`：查询执行后调用，可以处理返回的结果。 3. `AroundCallback`：环绕通知，环绕整个查询过程，可以在执行前后执行自定义逻辑。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值