Mybatis插件机制详解

原创编程识堂编程识堂

小堂最近在整理开源框架原理相关方面技术文档，持续为大家推送干货，欢迎大家关注【编程识堂】，不迷路！

简介

⼀般情况下，开源框架都会提供插件或其他形式的拓展点，供开发者⾃⾏拓展。这样的好处是显⽽易见的，⼀是增加了框架的灵活性。⼆是开发者可以结合实际需求，对框架进⾏拓展，使其能够更好的⼯作。以MyBatis为例，我们可基于MyBatis插件机制实现分页、分表，监控等功能。由于插件和业务⽆关，业务也⽆法感知插件的存在。因此可以⽆感植⼊插件，在⽆形中增强功能。

Mybatis插件介绍

Mybatis作为⼀个应⽤⼴泛的优秀的ORM开源框架，这个框架具有强⼤的灵活性，在四⼤组件 (Executor、StatementHandler、ParameterHandler、ResultSetHandler)处提供了简单易⽤的插件扩展机制。Mybatis对持久层的操作就是借助于四⼤核⼼对象。MyBatis⽀持⽤插件对四⼤核⼼对象进行拦截，对mybatis来说插件就是拦截器，⽤来增强核⼼对象的功能，增强功能本质上是借助于底层的动态代理实现的，换句话说，MyBatis中的四⼤对象都是代理对象。

Mybatis可以对这四个接口中所有的方法进行拦截

执⾏器Executor (update、query、commit、rollback等⽅法)；
SQL语法构建器StatementHandler (prepare、parameterize、batch、updates query等⽅法)；
参数处理器ParameterHandler (getParameterObject、setParameters⽅法)；
结果集处理器ResultSetHandler (handleResultSets、handleOutputParameters等⽅法)；

就是在下面的几个函数里面生成代理对象实现拦截的：

Mybatis插件原理

介绍

在四⼤对象创建的时候

1、每个创建出来的对象不是直接返回的，⽽是interceptorChain.pluginAll(parameterHandler)获取到所有的 Interceptor (拦截器)(插件需要实现的接⼝);

2、调⽤interceptor.plugin(target)，返回target包装后的对象（代理对象）；

3、插件机制，我们可以使⽤插件为⽬标对象创建⼀个代理对象；AOP (⾯向切⾯)我们的插件可以为四⼤对象创建出代理对象，代理对象就可以拦截到四⼤对象的每⼀个方法执行；

拦截

插件具体是如何拦截并附加额外的功能的呢？以ParameterHandler来说

 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 class InterceptorChain {
  private final List<Interceptor> interceptors = new ArrayList<Interceptor>();
  public Object pluginAll(Object target) {    for (Interceptor interceptor : interceptors) {      target = interceptor.plugin(target);    }    return target;  }}

interceptorChain保存了所有的拦截器(interceptors)，是mybatis初始化的时候创建的。调⽤拦截器链中的拦截器依次的对⽬标进⾏拦截或增强。interceptor.plugin(target)中的target就可以理解为mybatis中的四⼤对象。返回的target是被重重代理后的对象。

如果我们想要拦截Executor的query⽅法，那么可以这样定义插件：

@Intercepts({ @Signature( type = Executor.class, method = "query", args={MappedStatement.class,Object.class,RowBounds.class,ResultHandler.class} )})public class ExeunplePlugin implements Interceptor { //省略逻辑}

除此之外，我们还需将插件配置到sqlMapConfig.xm l中。

<plugins> <plugin interceptor="com.bcst.plugin.ExamplePlugin"> </plugin></plugins>

这样MyBatis在启动时可以加载插件，并保存插件实例到相关对象(InterceptorChain，拦截器链) 中。待准备⼯作做完后，MyBatis处于就绪状态。我们在执行SQL时，需要先通过DefaultSqlSessionFactory 创建SqlSession。Executor 实例会在创建 SqlSession 的过程中被创建， Executor实例创建完毕后， MyBatis会通过JDK动态代理为实例⽣成代理类。这样，插件逻辑即可在Executor相关⽅法被调⽤前执行。以上就是MyBatis插件机制的基本原理。

自定义插件

插件接口

Mybatis插件接⼝Interceptor

Intercept⽅法，插件的核心⽅法
plugin⽅法，⽣成target的代理对象
setProperties⽅法，传递插件所需参数

自定义插件

设计实现⼀个⾃定义插件

package com.bcst.plugin;
import org.apache.ibatis.executor.statement.StatementHandler;import org.apache.ibatis.plugin.*;
import java.sql.Connection;import java.util.Properties;
/* *@description 欢迎关注公众号 编程识堂,每日更新技术相关文章，关注我不迷路 *@author 小堂 *@create 2023/7/16 21:54 */@Intercepts ({//注意看这个⼤花括号，也就这说这⾥可以定义多个@Signature对多个地⽅拦截，都⽤这个拦截器@Signature (type = StatementHandler.class, //这是指拦截哪个接⼝        method = "prepare",//这个接⼝内的哪个⽅法名，不要拼错了        args = { Connection.class, Integer.class}),//// 这是拦截的⽅法的⼊参，按顺序写到这，不要多也不要少，如果⽅法重载，可是要通过⽅法名和⼊参来确定唯⼀的        })public class MyPlugin implements Interceptor {
    /**     * 拦截方法：只要被拦截的目标对象的目标方法被执行时，每次都会执行intercept方法     * @param invocation     * @return     * @throws Throwable     */    @Override    public Object intercept(Invocation invocation) throws Throwable {        System.out.println("MyPlugin插件 目标方法被增强。。。。");        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();        MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);        // 将执行权交给下一个拦截器        return invocation.proceed();    }
    /**     * 主要为了把当前的拦截器生成代理保存到拦截链中     * @Description 包装⽬标对象 为⽬标对象创建代理对象     * @Param  target为要拦截的对象     * @Return 代理对象     */    @Override    public Object plugin(Object target) {        System.out.println("MyPlugin插件将要包装的⽬标对象："+target);        Object wrap = Plugin.wrap(target, this);        return wrap;    }
    /**     * 获取配置文件的参数     * @param properties     */    @Override    public void setProperties(Properties properties) {        System.out.println("获取配置文件的参数是："+properties);    }}

sqlMapConfig.xml

 <plugins>        <plugin interceptor="com.bcst.plugin.MyPlugin">            <property name="name" value="小堂"/>        </plugin> </plugins>

测试

源码分析

执行插件逻辑

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

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

private void pluginElement(XNode parent) throws Exception {    if (parent != null) {        for (XNode child : parent.getChildren()) {            String interceptor = child.getStringAttribute("interceptor");            Properties properties = child.getChildrenAsProperties();            Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();            interceptorInstance.setProperties(properties);            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<Interceptor>();
    public Object pluginAll(Object target) {        for (Interceptor interceptor : interceptors) {            target = interceptor.plugin(target);        }        return target;    }
    public void addInterceptor(Interceptor interceptor) {        interceptors.add(interceptor);    }
    public List<Interceptor> getInterceptors() {        return Collections.unmodifiableList(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;}

protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {    this.configuration = mappedStatement.getConfiguration();    this.executor = executor;    this.mappedStatement = mappedStatement;    this.rowBounds = rowBounds;
    this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();    this.objectFactory = configuration.getObjectFactory();
    if (boundSql == null) { // issue #435, get the key before calculating the statement      generateKeys(parameterObject);      boundSql = mappedStatement.getBoundSql(parameterObject);    }
    this.boundSql = boundSql;
    this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);    this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);  }

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

这4个方法实例化了对应的对象之后，都会调用interceptorChain的pluginAll方法，InterceptorChain的pluginAll刚才已经介绍过了，就是遍历所有的拦截器，然后调用各个拦截器的plugin方法。

public class InterceptorChain {
  private final List<Interceptor> interceptors = new ArrayList<>();
  public Object pluginAll(Object target) {    for (Interceptor interceptor : interceptors) {      target = interceptor.plugin(target);    }    return target;  }}}

注意：拦截器的plugin方法的返回值会直接被赋值给原先的对象。

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

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

public interface Interceptor {
  Object intercept(Invocation invocation) throws Throwable;
  default Object plugin(Object target) {    return Plugin.wrap(target, this);  }}

代理链的生成

Mybatis支持对Executor、StatementHandler、ParameterHandler和ResultSetHandler进行拦截，也就是说会对这4种对象进行代理。通过查看Configuration类的源代码我们可以看到，每次都对目标对象进行代理链的生成。

下面以Executor为例。Mybatis在创建Executor对象时会执行下面一行代码：

executor =(Executor) interceptorChain.pluginAll(executor);

InterceptorChain里保存了所有的拦截器，它在mybatis初始化的时候创建。上面这句代码的含义是调用拦截器链里的每个拦截器依次对executor进行plugin（生成代理对象）代码如下：

/**   * 每一个拦截器对目标类都进行一次代理   * @param target   * @return 层层代理后的对象   */   public Object pluginAll(Object target) {       for(Interceptor interceptor : interceptors) {           target= interceptor.plugin(target);       }       return target;   }

下面以一个简单的例子来看看这个plugin方法里到底发生了什么：

@Intercepts({@Signature(type = Executor.class, method ="update", args = {MappedStatement.class, Object.class})})  public class ExamplePlugin implements Interceptor {      @Override      public Object intercept(Invocation invocation) throws Throwable {          return invocation.proceed();      }  
    @Override      public Object plugin(Object target) {          return Plugin.wrap(target, this);      }  
    @Override      public void setProperties(Properties properties) {      }}

每一个拦截器都必须实现上面的三个方法，其中：

Object intercept(Invocation invocation)是实现拦截逻辑的地方，内部要通过invocation.proceed()显式地推进责任链前进，也就是调用下一个拦截器拦截目标方法。
Object plugin(Object target) 就是用当前这个拦截器生成对目标target的代理，实际是通过Plugin.wrap(target,this)来完成的，把目标target和拦截器this传给了包装函数。
setProperties(Properties properties)用于设置额外的参数，参数配置在拦截器的Properties节点里。

注解里描述的是指定拦截方法的签名 [type,method,args] （即对哪种对象的哪种方法进行拦截），它在拦截前用于决断。

定义自己的Interceptor最重要的是要实现plugin方法和intercept方法，在plugin方法中我们可以决定是否要进行拦截进而决定要返回一个什么样的目标对象。而intercept方法就是要进行拦截的时候要执行的方法。

对于plugin方法而言，其实Mybatis已经为我们提供了一个实现。Mybatis中有一个叫做Plugin的类，里面有一个静态方法wrap(Object target,Interceptor interceptor)，通过该方法可以决定要返回的对象是目标对象还是对应的代理。这里我们先来看一下Plugin的源码：

package org.apache.ibatis.plugin;
import java.lang.reflect.InvocationHandler;import java.lang.reflect.Method;import java.lang.reflect.Proxy;import java.util.HashMap;import java.util.HashSet;import java.util.Map;import java.util.Set;
import org.apache.ibatis.reflection.ExceptionUtil;
//这个类是Mybatis拦截器的核心,大家可以看到该类继承了InvocationHandler//又是JDK动态代理机制public class Plugin implements InvocationHandler {
  //目标对象  private Object target;  //拦截器  private Interceptor interceptor;  //记录需要被拦截的类与方法  private Map<Class<?>, Set<Method>> signatureMap;
  private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {    this.target = target;    this.interceptor = interceptor;    this.signatureMap = signatureMap;  }
  //一个静态方法,对一个目标对象进行包装，生成代理类。  public static Object wrap(Object target, Interceptor interceptor) {    //首先根据interceptor上面定义的注解 获取需要拦截的信息    Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);    //目标对象的Class    Class<?> type = target.getClass();    //返回需要拦截的接口信息    Class<?>[] interfaces = getAllInterfaces(type, signatureMap);    //如果长度为>0 则返回代理类 否则不做处理    if (interfaces.length > 0) {      return Proxy.newProxyInstance(          type.getClassLoader(),          interfaces,          new Plugin(target, interceptor, signatureMap));    }    return target;  }
  //代理对象每次调用的方法  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    try {      //通过method参数定义的类 去signatureMap当中查询需要拦截的方法集合      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）实现类上面的注解获取相关信息  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注解信息    Signature[] sigs = interceptsAnnotation.value();    Map<Class<?>, Set<Method>> signatureMap = new HashMap<Class<?>, Set<Method>>();    //循环注解信息    for (Signature sig : sigs) {      //根据Signature注解定义的type信息去signatureMap当中查询需要拦截方法的集合      Set<Method> methods = signatureMap.get(sig.type());      //第一次肯定为null 就创建一个并放入signatureMap      if (methods == null) {        methods = new HashSet<Method>();        signatureMap.put(sig.type(), methods);      }      try {        //找到sig.type当中定义的方法 并加入到集合        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;  }
  //根据对象类型与signatureMap获取接口信息  private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {    Set<Class<?>> interfaces = new HashSet<Class<?>>();    //循环type类型的接口信息 如果该类型存在与signatureMap当中则加入到set当中去    while (type != null) {        //type:Executor接口实现类，比如SimpleExecutor        //type.getInterfaces():例如org.apache.ibatis.executor.Executor      for (Class<?> c : type.getInterfaces()) {        if (signatureMap.containsKey(c)) {          interfaces.add(c);        }      }      type = type.getSuperclass();    }    //转换为数组返回    return interfaces.toArray(new Class<?>[interfaces.size()]);  }
}

下面是俩个注解类的定义源码：

package org.apache.ibatis.plugin;
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Intercepts {  Signature[] value();}

package org.apache.ibatis.plugin;
import java.lang.annotation.ElementType;import java.lang.annotation.Retention;import java.lang.annotation.RetentionPolicy;import java.lang.annotation.Target;
@Retention(RetentionPolicy.RUNTIME)@Target(ElementType.TYPE)public @interface Signature {  Class<?> type();
  String method();
  Class<?>[] args();}

Plugin.wrap方法

从前面可以看出，每个拦截器的plugin方法是通过调用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) {          // 生成代理对象， Plugin对象为该代理对象的InvocationHandler  （InvocationHandler属于java代理的一个重要概念，不熟悉的请参考相关概念）          return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target,interceptor,signatureMap));      }      return target;  }

这个Plugin类有三个属性：

private Object target;// 被代理的目标类
private Interceptor interceptor;// 对应的拦截器
private Map<Class<?>, Set<Method>> signatureMap;// 拦截器拦截的方法缓存

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<Method>的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对象。

我们再次结合(Executor)interceptorChain.pluginAll(executor)这个语句来看，这个语句内部对executor执行了多次plugin,第一次plugin后通过Plugin.wrap方法生成了第一个代理类，姑且就叫executorProxy1，这个代理类的target属性是该executor对象。第二次plugin后通过Plugin.wrap方法生成了第二个代理类，姑且叫executorProxy2，这个代理类的target属性是executorProxy1...这样通过每个代理类的target属性就构成了一个代理链（从最后一个executorProxyN往前查找，通过target属性可以找到最原始的executor类）。

代理链上的拦截

代理链生成后，对原始目标的方法调用都转移到代理者的invoke方法上来了。Plugin作为InvocationHandler的实现类，他的invoke方法是怎么样的呢？

比如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)) {             // 调用代理类所属拦截器的intercept方法，             return interceptor.intercept(new Invocation(target, method, args));          }          return method.invoke(target, args);      } catch(Exception e) {          throw ExceptionUtil.unwrapThrowable(e);      }  }

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

在invoke里，如果方法签名和拦截中的签名一致，就调用拦截器的拦截方法。我们看到传递给拦截器的是一个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 proceed() throws InvocationTargetException, IllegalAccessException {          return method.invoke(target, args);      }  }

可以看到，Invocation类保存了代理对象的目标类，执行的目标类方法以及传递给它的参数。

在每个拦截器的intercept方法内，最后一个语句一定是return invocation.proceed()（不这么做的话拦截器链就断了，你的mybatis基本上就不能正常工作了）。invocation.proceed()只是简单的调用了下target的对应方法，如果target还是个代理，就又回到了上面的Plugin.invoke方法了。这样就形成了拦截器的调用链推进。

public Object intercept(Invocation invocation) throws Throwable {      //完成代理类本身的逻辑      ...    //通过invocation.proceed()方法完成调用链的推进    return invocation.proceed();}

总结

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

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

总体来说MyBatis拦截器还是很简单的，拦截器本身不需要太多的知识点，但是学习拦截器需要对MyBatis中的各个接口很熟悉，因为拦截器涉及到了各个接口的知识点。

我们假设在MyBatis配置了一个插件，在运行时会发生什么？

所有可能被拦截的处理类都会生成一个代理
处理类代理在执行对应方法时，判断要不要执行插件中的拦截方法
执行插接中的拦截方法后，推进目标的执行
如果有N个插件，就有N个代理，每个代理都要执行上面的逻辑。这里面的层层代理要多次生成动态代理，是比较影响性能的。虽然能指定插件拦截的位置，但这个是在执行方法时动态判断，初始化的时候就是简单的把插件包装到了所有可以拦截的地方。

因此，在编写插件时需注意以下几个原则：

不编写不必要的插件；
实现plugin方法时判断一下目标类型，是本插件要拦截的对象才执行Plugin.wrap方法，否者直接返回目标本省，这样可以减少目标被代理的次数。

pageHelper分页插件

MyBatis可以使⽤第三⽅的插件来对功能进⾏扩展，分⻚助⼿PageHelper是将分⻚的复杂操作进⾏封装，使⽤简单的⽅式即可获得分⻚的相关数据。

开发步骤：

① 导⼊通⽤PageHelper的坐标

② 在mybatis核⼼配置⽂件中配置PageHelper插件

③ 测试分⻚数据获取

导入通用PageHelper坐标

<dependency>  <groupId>com.github.pagehelper</groupId>  <artifactId>pagehelper</artifactId>  <version>3.7.5</version></dependency><dependency>  <groupId>com.github.jsqlparser</groupId>  <artifactId>jsqlparser</artifactId>  <version>0.9.1</version></dependency>

在mybatis核心配置⽂件中配置PageHelper插件

<!--注意：分⻚助⼿的插件 配置在通⽤馆mapper之前*--><plugin interceptor="com.github.pagehelper.PageHelper">  <!--指定⽅⾔-->  <property name="dialect" value="mysql"/></plugin>

测试分页代码实现

public void test6() throws IOException {        //加载核⼼配置⽂件        InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");        //获得sqlSession⼯⼚对象        SqlSessionFactory sqlSessionFactory = new                SqlSessionFactoryBuilder().build(resourceAsStream);        //获得sqlSession对象        SqlSession sqlSession = sqlSessionFactory.openSession();        IUsrDao usrDao = sqlSession.getMapper(IUsrDao.class);        PageHelper.startPage(1,20);        List<User> users = usrDao.findAll();        PageInfo<User> pageInfo = new PageInfo<>(users);        System.out.println(pageInfo.toString()); }

自定义PageInterceptor分页插件

介绍

Mybatis的分页功能很弱，它是基于内存的分页（查出所有记录再按偏移量和limit取结果），在大数据量的情况下这样的分页基本上是没有用的。本文基于插件，通过拦截StatementHandler重写sql语句，实现数据库的物理分页。

为什么在StatementHandler拦截

在前面章节介绍了一次sqlsession的完整执行过程，从中可以知道sql的解析是在StatementHandler里完成的，所以为了重写sql需要拦截StatementHandler。

MetaObject简介

在实现里大量使用了MetaObject这个对象，因此有必要先介绍下它。MetaObject是Mybatis提供的一个的工具类，通过它包装一个对象后可以获取或设置该对象的原本不可访问的属性（比如那些私有属性）。它有个三个重要方法经常用到：

MetaObject forObject(Object object,ObjectFactory objectFactory, ObjectWrapperFactory objectWrapperFactory) 用于包装对象；
Object getValue(String name) 用于获取属性的值（支持OGNL的方法）；
void setValue(String name, Object value) 用于设置属性的值（支持OGNL的方法）；

intercept实现

package com.bcst.plugin;
import org.apache.ibatis.executor.parameter.ParameterHandler;import org.apache.ibatis.executor.statement.RoutingStatementHandler;import org.apache.ibatis.executor.statement.StatementHandler;import org.apache.ibatis.mapping.BoundSql;import org.apache.ibatis.mapping.MappedStatement;import org.apache.ibatis.plugin.*;import org.apache.ibatis.reflection.MetaObject;import org.apache.ibatis.reflection.SystemMetaObject;import org.apache.ibatis.scripting.defaults.DefaultParameterHandler;import org.apache.ibatis.session.RowBounds;
import java.lang.reflect.Field;import java.sql.Connection;import java.sql.PreparedStatement;import java.sql.ResultSet;import java.sql.SQLException;import java.util.Map;import java.util.Properties;
/**  分页插件 *@description 欢迎关注公众号 编程识堂,每日更新技术相关文章，关注我不迷路 *@author 小堂 *@create 2023/7/20 20:54 */@Intercepts({@Signature(        method = "prepare",        type = StatementHandler.class,        args = {Connection.class, Integer.class})})public class PageInterceptor implements Interceptor {

    @Override    public Object intercept(Invocation invocation) throws Throwable {        System.out.println("PageInterceptor插件 目标方法被增强。。。。");        StatementHandler statementHandler = (StatementHandler) invocation.getTarget();        MetaObject metaStatementHandler = SystemMetaObject.forObject(statementHandler);        // 分离代理对象链(由于目标类可能被多个拦截器拦截，从而形成多次代理，通过下面的两次循环        // 可以分离出最原始的的目标类)        while (metaStatementHandler.hasGetter("h")) {            Object object = metaStatementHandler.getValue("h");            metaStatementHandler =   SystemMetaObject.forObject(object);        }        // 分离最后一个代理对象的目标类        while (metaStatementHandler.hasGetter("target")) {            Object object = metaStatementHandler.getValue("target");            metaStatementHandler =   SystemMetaObject.forObject(object);        }        RowBounds rowBounds = null;        try {            rowBounds = (RowBounds)metaStatementHandler.getValue("delegate.rowBounds");        } catch (Exception var11) {            return invocation.proceed();        }
        if (rowBounds != null && rowBounds != RowBounds.DEFAULT) {            String originalSql = (String) metaStatementHandler.getValue("delegate.boundSql.sql");            Connection connection = (Connection) invocation.getArgs()[0];            MappedStatement mappedStatement = (MappedStatement) metaStatementHandler.getValue("delegate.mappedStatement");            BoundSql boundSql = (BoundSql) metaStatementHandler.getValue("delegate.boundSql");            int totalCount = this.getPageTotalCount(originalSql, connection, mappedStatement, boundSql);            if (totalCount > 0) {                String sql = "";                if (rowBounds.getOffset() > 0) {                    sql = originalSql + " limit " + rowBounds.getOffset() + "," + rowBounds.getLimit();                } else {                    sql = originalSql + " limit " + rowBounds.getLimit();                }                // 采用物理分页后，就不需要mybatis的内存分页了，所以重置下面的两个参数                metaStatementHandler.setValue("delegate.boundSql.sql", sql);                metaStatementHandler.setValue("delegate.rowBounds.offset", RowBounds.NO_ROW_OFFSET);                metaStatementHandler.setValue("delegate.rowBounds.limit", RowBounds.NO_ROW_LIMIT);            }            metaStatementHandler.setValue("delegate.boundSql.parameterObject.totalCount", totalCount);        }        // 将执行权交给下一个拦截器        return invocation.proceed();    }
    @Override    public Object plugin(Object target) {        //当目标类是StatementHandler类型时，才包装目标类，否者直接返回目标本身,减少目标被代理的        if (target instanceof StatementHandler){            System.out.println("PageInterceptor插件将要包装的⽬标对象："+target);            return Plugin.wrap(target,this);        }        return target;    }
    @Override    public void setProperties(Properties properties) {
    }
    private int getPageTotalCount(String sql, Connection connection, MappedStatement mappedStatement, BoundSql boundSql) {        String countSql = "select count(0) from (" + sql + ") as total";        PreparedStatement countStmt = null;        ResultSet rs = null;        int totalCount = 0;        try {            countStmt = connection.prepareStatement(countSql);
            BoundSql countBS = new BoundSql(mappedStatement.getConfiguration(), countSql, boundSql.getParameterMappings(), boundSql.getParameterObject());            additionalParameter(boundSql,countBS);            this.setParameters(countStmt, mappedStatement, countBS, boundSql.getParameterObject());            rs = countStmt.executeQuery();            if (rs.next()) {                totalCount = rs.getInt(1);            }        } catch (SQLException var22) {
        } finally {            try {                rs.close();            } catch (SQLException var21) {                var21.printStackTrace();            }
            try {                countStmt.close();            } catch (SQLException var20) {                var20.printStackTrace();            }
        }
        return totalCount;    }
    private void setParameters(PreparedStatement ps, MappedStatement mappedStatement, BoundSql boundSql, Object parameterObject) throws SQLException {        ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement, parameterObject, boundSql);        parameterHandler.setParameters(ps);    }
    private void additionalParameter(BoundSql boundSql,BoundSql targetBoundSql){        Class c = boundSql.getClass();        try {            Field field = c.getDeclaredField("additionalParameters");            field.setAccessible(true);            Map<String,Object> boundMap = (Map<String,Object>)field.get(boundSql);            if(boundMap!=null) {                for (Map.Entry<String, Object> entry : boundMap.entrySet()) {                    targetBoundSql.setAdditionalParameter(entry.getKey(), entry.getValue());                }            }        } catch (IllegalAccessException e) {            e.printStackTrace();        }catch (NoSuchFieldException e) {            e.printStackTrace();        }    }}

StatementHandler的默认实现类是RoutingStatementHandler，因此拦截的实际对象是它。RoutingStatementHandler的主要功能是分发，它根据配置Statement类型创建真正执行数据库操作的StatementHandler，并将其保存到delegate属性里。由于delegate是一个私有属性并且没有提供访问它的方法，因此需要借助MetaObject的帮忙。通过MetaObject的封装后我们可以轻易的获得想要的属性。

通过他们可以分离出原始的RoutingStatementHandler（而不是代理对象）。

在mybatis核心配置文件中配置PageInterceptor插件

<plugins>        <plugin interceptor="com.bcst.plugin.MyPlugin">            <property name="name" value="小堂"/>        </plugin>        <!--注意：分⻚助⼿的插件 配置在通⽤馆mapper之前*-->        <plugin interceptor="com.bcst.plugin.PageInterceptor">            <!--指定⽅⾔-->            <property name="dialect" value="mysql"/>        </plugin></plugins>

测试

PagingListBo

package com.bcst.pojo;
/**  分页请求体 *@description 欢迎关注公众号 编程识堂,每日更新技术相关文章，关注我不迷路 *@author 小堂 *@create 2023/7/20 20:54 */public class PagingListBo {
    /**     * 偏移量     */    private Integer offset=0;
    /**     * 限量每页多少条（不填默认10     */    private Integer limit=10;
    /**     * 总数量     */    private Integer totalCount=0;
    //总页数    private Integer pageCount=0;
    /**     * 页码当前多少页（不填默认1）     */    private Integer  pageIndex=1;
    public Integer getOffset() {        offset = limit * (this.pageIndex-1);        return offset;    }
    public void setOffset(Integer offset) {        this.offset = offset;    }
    public Integer getLimit() {        return limit;    }
    public void setLimit(Integer limit) {        this.limit = limit;    }
    public Integer getTotalCount() {        return totalCount;    }
    public void setTotalCount(Integer totalCount) {        this.totalCount = totalCount;    }
    public Integer getPageCount() {        pageCount= (this.totalCount + this.limit - 1) / this.limit;        return pageCount;    }
    public void setPageCount(Integer pageCount) {        this.pageCount = pageCount;    }
    public Integer getPageIndex() {        return  pageIndex;    }
    public void setPageIndex(Integer pageIndex) {        this. pageIndex = pageIndex;    }}

UserQueryBo

/**  用户请求体 *@description 欢迎关注公众号 编程识堂,每日更新技术相关文章，关注我不迷路 *@author 小堂 *@create 2023/7/20 20:54 */public class UserQueryBo extends PagingListBo{
    private String name;
    public String getName() {        return name;    }
    public void setName(String name) {        this.name = name;    }}

PageVO

package com.bcst.pojo;
import java.util.List;
/**  分页返回体 *@description 欢迎关注公众号 编程识堂,每日更新技术相关文章，关注我不迷路 *@author 小堂 *@create 2023/7/20 20:54 */public class PageVO<T>{
    /**     * 分页总数     */
    private long total;    /**     * 数据集     */    private List<T> rows;
    public PageVO() {    }
    public PageVO(long total, List<T> rows) {        this.total = total;        this.rows = rows;    }
    public long getTotal() {        return total;    }
    public void setTotal(long total) {        this.total = total;    }
    public List<T> getRows() {        return rows;    }
    public void setRows(List<T> rows) {        this.rows = rows;    }
}

IUsrDao

/* *@description 欢迎关注公众号 编程识堂,每日更新技术相关文章，关注我不迷路 *@author 小堂 *@create 2023/7/9 11:58 */public interface IUsrDao {
    List<User> findList( UserQueryBo userQueryBo, RowBounds rowBounds);
}

UserMapper.xml

<select id="findList" resultType="com.bcst.pojo.User">        select  username name,phone from user where username like concat('%',#{name},'%')</select>

sqlMapConfig.xml

<plugins>        <plugin interceptor="com.bcst.plugin.MyPlugin">            <property name="name" value="小堂"/>        </plugin>        <!--注意：分⻚助⼿的插件 配置在通⽤馆mapper之前*-->        <plugin interceptor="com.bcst.plugin.PageInterceptor">            <!--指定⽅⾔-->            <property name="dialect" value="mysql"/>        </plugin>    </plugins>

Test

 public void test7() throws IOException {        //加载核⼼配置⽂件        InputStream resourceAsStream = Resources.getResourceAsStream("SqlMapConfig.xml");        //获得sqlSession⼯⼚对象        SqlSessionFactory sqlSessionFactory = new                SqlSessionFactoryBuilder().build(resourceAsStream);        //获得sqlSession对象        SqlSession sqlSession = sqlSessionFactory.openSession();        IUsrDao usrDao = sqlSession.getMapper(IUsrDao.class);        UserQueryBo userQueryBo = new UserQueryBo();        userQueryBo.setName("u1105");        RowBounds rowBounds = new RowBounds(1,20);        List<User> users = usrDao.findList(userQueryBo,rowBounds);        PageVO<User> pageVO = new PageVO<>(userQueryBo.getTotalCount(),users);        System.out.println("总条数:"+pageVO.getTotal()+"当前页条数："+pageVO.getRows().size());    }

我是小堂，下期见～
··········  END  ··············
在看、点赞、转发，是对我最大的鼓励。

技术资料、面试笔记公众号内回复[ 资料 ] Get。

文章项目源码公众号内回复[ 源码] Get。
      
     
●Mybatis基础回顾
●自定义持久层框架
●Kubernetes系列之集群部署
●Kubernetes系列之Pod生命周期
三连给小编加鸡腿！

继续滑动看下一个