MyBatis(11) MyBatis 插件

MyBatis 插件

插件介绍

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

MyBatis插件介绍

MyBatis作为一个应用广泛的优秀ORM开源框架，具有强大的灵活性，在四大组件（Executor / StatementHandler / ParameterHandler / ResultSetHandler）处提供了简单易用的插件扩展机制。

MyBatis对持久层的操作就是借助于四大核心对象。MyBatis支持插件对四大核心对象进行拦截，对MyBatis来说，插件就是拦截器，用来增强核心对象的功能，增强功能本质上是借助底层的动态代理实现的，换句话说，MyBatis中的四大对象都是代理对象

MyBatis 所允许拦截的方法如下：

• 执行器Executor（update、query、commit、rollback等方法）
• SQL语法构建器StatemantHandler （prepare、parameterize、batch、update、query等方法）
• 参数处理器ParameterHandler（getParameterObject、setParameters方法）
• 结果处理器ResultSetHandler（handleResultSets、handleOutputParameters等方法）

MyBatis插件原理

在四大对象创建的时候

• 每个创建出来的对象不是直接返回的，而是interceptorChain.pluginAll(parameterHandler);
• 获取到所有的Interceptor（拦截器）（插件需要实现的接口），调用interceptor.plugin(target) 返回target包装后的对象
• 插件机制，我们可以使用插件为目标对象创建一个队里对象；AOP（面向切面）我们的插件可以为四大队向创建出代理对象，代理对象就可以拦截到四大对象的每一个执行

拦截

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

在org.apache.ibatis.session.Configuration类中

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

ParameterHandler在初始化时，并不是直接返回一个原始的ParameterHandler对象，而是调用了interceptor.plugin(target) 方法获得一个代理对象

InterceptorChain 保存了所有的拦截器（Interceptors），是MyBatis初始化的时候创建的。调用拦截链中的拦截器依次对目标进行拦截或增强。

interceptor.plugin(target) 中的target就可以理解为MyBatis中的四大对象，返回的target是被重重代理后的对象

package org.apache.ibatis.plugin;

public class InterceptorChain {
    
  public Object pluginAll(Object target) {
    for (Interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }
}

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

public class ExamplePlugin implements Interceptor {
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        return null;
    }

    @Override
    public Object plugin(Object target) {
        return null;
    }

    @Override
    public void setProperties(Properties properties) {

    }
}

需要实现Interceptor接口，并重写接口内的三个方法，除此之外，还需要将插件配置到sqlMapConfig.xml中

<!-- 配置插件 -->
<plugins>
    <plugin interceptor="com.demo.plugin.ExamplePlugin"/>
</plugins>

这样MyBatis在启动时可以加载插件，并保存插件实例到 InterceptorChain （拦截器链）中。

待准备工作做完后，MyBatis处于就绪状态，我们在执行sql的时候，需要先通过DefaultSqlSessionFactory创建SqlSession。Executor实例会在创建SqlSession的过程中被创建，Executor实例创建完毕后，MyBatis会通过JDK动态代理为实例生成代理类。这样，插件逻辑即可在Executor相关方法被调用前执行。

以上就是MyBatis插件机制的基本原理

自定义插件

• MyBatis插件接口 - Interceptor

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

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

• 设计实现一个自定义插件

  /**
   * 拦截器可以同时对多个方法进行拦截 使用多个@Signature即可
   * @Signature type：拦截的核心对象，method：指定拦截哪个方法 args：拦截方法的参数，方法重载时通过参数确定方法
   */
  @Intercepts({
          @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("自定义插件生效了");
          // 执行原方法
          return invocation.proceed();
      }
  
      /**
       * 主要是为了把这个拦截器生成一个代理放到拦截器链中
       * @Description 包装目标对象 为目标对象创建代理对象
       * @param target 要拦截的对象
       * @return 代理对象
       */
      @Override
      public Object plugin(Object target) {
          System.out.println("要包装的对象" + target);
          return Plugin.wrap(target, this);
      }
  
      /**
       * 获取配置文件的属性
       * 插件初始化的时候调用，也只调用一次
       * 插件配置的属性从这里设置进来
       * @param properties 插件配置参数
       */
      @Override
      public void setProperties(Properties properties) {
          System.out.println("插件的参数" + properties);
      }
  }
  

  sqlMapConfig.xml

  <!-- 配置插件 -->
  <plugins>
      <plugin interceptor="com.demo.plugin.MyPlugin">
          <!-- 配置参数 -->
          <property name="name" value="zzzzz"/>
      </plugin>
  </plugins>
  

  测试类：

  public class PluginTest {
      private UserMapper userMapper;
  
      @Before
      public void before() throws IOException {
          // 1.Resources工具类，配置文件的加载，把配置文件加载成字节输入流
          InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");
          // 2.解析了配置文件，并创建了sqlSessionFactory
          SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
          // 3.生成sqlSession （默认开启一个事务，但是该事务不会自动提交， 参数为true为自动提交）
          SqlSession sqlSession = sqlSessionFactory.openSession(true);
          userMapper = sqlSession.getMapper(UserMapper.class);
      }
  
      @Test
      public void testSelect(){
          List<User> users = userMapper.selectAll();
          for (User user : users) {
              System.out.println(user);
          }
      }
  }
  

  执行输出：

  插件的参数{name=zzzzz}
  要包装的对象org.apache.ibatis.executor.CachingExecutor@e88be079
  要包装的对象org.apache.ibatis.scripting.defaults.DefaultParameterHandler@b50fbe
  要包装的对象org.apache.ibatis.executor.resultset.DefaultResultSetHandler@7bd643f5
  要包装的对象org.apache.ibatis.executor.statement.RoutingStatementHandler@dc2819a9
  自定义插件生效了
  User{id=1, username='原始数据', orderList=[], roleList=[]}
  User{id=2, username='coco', orderList=[], roleList=[]}
  User{id=3, username='kk', orderList=[], roleList=[]}
  User{id=4, username='ccham', orderList=[], roleList=[]}
  User{id=5, username='zz', orderList=[], roleList=[]}
  

  这样我们就实现了一个简单的MyBatis插件

源码分析

接下来我们通过查看源码，来了解下MyBatis插件的执行逻辑

org.apache.ibatis.plugin.Plugin 类实现了 InvocationHandler 接口，因此它的 invoke 方法会拦截所有的方法调用。invoke 方法会对所拦截的方法进行检测，以决定是否执行插件逻辑。该方法的逻辑如下

@Override
public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
        // 获取拦截方法列表 比如
        // signatureMap.get(Executor.class) 可能返回[query,update,commit]
        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);
    }
}

invoke方法的代码比较少，逻辑不难理解。

首先，invoke方法会检测被拦截方法是否配置在插件的@Singnature 注解里，若是，则执行插件逻辑，否则执行被拦截方法。

插件逻辑封装在intercept中，该方法的参数类型为 invocation。invocation主要用于存储目标类，方法以及方法参数列表。下面简单看下该类的定义

public class Invocation {

  private final Object target;
  private final Method method;
  private final 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);
  }

}