MyBatis plugin的使用与源码解析

Posted 2022-08-22 叶长风

MyBatis plugin的使用与源码解析

这一节来讲下Mybatis中的plugin的使用，plugin作为对执行期间对Executor、StatementHandler的一种增强等等，我见过用的最多的应该就是Mybatis的分页插件PageHelper，PageHelper因为简单易用被广泛用于各种大小工程中，虽说PageHelper使用起来确实挺舒服，但是在遇到一些查询性能上的问题时，PageHelper带来的弊端倒是挺大的，这个以后有空单独抽一个专题出来说下PageHelper，这一节就不再多说了，就直说Plugin用法与原理。

1. Plugin用法

---

Plugin用法说起来挺简单的，和写拦截器一样，在这也想好具体写什么Plugin，就写一个拦截query方法的Plugin吧，打印方法具体耗时，命名为ExecuteLogPlugin，如下：

@Intercepts(@Signature(
        type = Executor.class,
        method = "query",
        args = MappedStatement.class,
                Object.class,
                RowBounds.class,
                ResultHandler.class
))
public class ExecuteLogPlugin implements Interceptor 

    @Override
    public Object intercept(Invocation invocation) throws Throwable 
        long start = System.currentTimeMillis();
        Object target = invocation.proceed();
        long end = System.currentTimeMillis();
        System.out.println("intercept " + invocation.getMethod().getName() + " cost : " + (end - start));
        return target;
    

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

    @Override
    public void setProperties(Properties properties) 

    

这段里面真正起作用的就是invocation.proceed()这段，就是执行代理方法，然后在前后埋点，最后输出对应method耗时，在这图简便，就没有单独引入log的包，就用System输出了，这个Plugin中最重要的就是@Intercepts注解，表明拦截的是什么类型，拦截方法。这个注解的解析在后面会提到。

除了编写Plugin之外，还需要做的事情就是在xml中需要配置Plugin，具体如下：

<plugins>
        <plugin interceptor="cn.com.plugin.ExecuteLogPlugin"></plugin>
</plugins>

这一切做完后，在运行main程序时就能得到期望的效果，在这几乎每个query方法都进行了拦截，如果只想对某一个或者几个方法进行拦截的话，invocation中args字段中有对应的class类与方法名，可以在这做些文章。

用法就到此为止了，运行中的截图也没啥好贴出来的，运行时可以自己看下，下面开始对原理性的分析。

2. 原理分析

---

分析Plugin的加载仍然需要回到configuration的初始化，继续回到Main程序的第一行开始分析，我们的main程序中的SessionFactory的初始化如下：

String resource = "conf.xml";
        //使用类加载器加载mybatis的配置文件（它也加载关联的映射文件）
        InputStream is = Main.class.getClassLoader().getResourceAsStream(resource);
        //构建sqlSession的工厂
        SqlSessionFactory sessionFactory = new SqlSessionFactoryBuilder().build(is);

还是进入到build方法中，查看configuration的初始化过程.

private void parseConfiguration(XNode root) 
    try 
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
     catch (Exception e) 
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    
  

如同第一篇文章！Mybatis源码解析之配置加载(一)一样，我们回到解析configuration的源码处，此次其他均不讲，只说pluginElement(root.evalNode(“plugins”))这一行，这一行就是plugin的具体加载过程，进入到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) resolveClass(interceptor).newInstance()，这一步追踪到最后就是调用了Class.forName()的过程，没有太多深究的东西。

在实例化完了后，将当前的plugin实例保存进InterceptorCahin中，等待Executor执行时调用，接下来我们再看session获取到mapper，mapper执行的过程。

UserMapper userMapper = session.getMapper(UserMapper.class);
//执行查询返回一个唯一user对象的sql
User user = userMapper.getUser(1);

从前几篇文章我们知这里的Mapper对象其实就是一个代理对象，真正在起作用的为MapperProxy,然后在执行调用方法时，是调用MapperProxy的invoke方法，然后对于select方法，最终都是调用selectList，selectList经过多层调用后最终还是调用doQuery方法，我们回到doQuery处。

@Override
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException 
    Statement stmt = null;
    try 
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.<E>query(stmt, resultHandler);
     finally 
      closeStatement(stmt);
    
  

此处我们看获取StatementHandler的方法，进入到newStatementHandler。

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;
  

此处调用了interceptorChain.pluginAll(statementHandler)得到statementHandler对象，而pluginAll中做的操作为:

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

就是调用了每个plugin的plugin方法，返回一个包装对象，然后在statementHandler调用的时候发挥代理的作用，这最终解释了Plugin中intercept方法发挥作用的时机，但是仍然没有解释到@Intercepts注解的作用，以及何时进行拦截，这里就要说下Plugin中plugin方法的作用了。plugin方法中做的事情为：

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

对target与当前对象进行了一层包装，进入到warp方法中。

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;
  

进行注解解析的一行代码为:

Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);

跳转到getSignatureMap方法中。

private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) 
    Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
    // issue #251
    if (interceptsAnnotation == null) 
      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;
  

这个方法做的事情就是解析**@Signature**注解，将对应的type、method保存进Map中返回。

然后在wrap方法中对当前class进行判断，如果是当前class是@Signature中指定的type的子类，则进行代理操作。

Class<?> type = target.getClass();
    Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
    if (interfaces.length > 0) 
      return Proxy.newProxyInstance(
          type.getClassLoader(),
          interfaces,
          new Plugin(target, interceptor, signatureMap));
    

对当前class的判断方法为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()]);
  

这里判断了当前signatureMap中是否包含当前class，如果是则返回包含当前class的数组，如果不是则返回空数组，而在上一代码块中得知，只有当当前数组长度大于0时，才会返回代理对象，我们在@Signature注解中标注拦截的type为Executor，那么所有的方法基本都会被返回代理对象，但是我们选择拦截方法是query，不能拦截update、delete等操作，所以这里的玄机就在于实例化的对象传入的参数包括signatureMap。

new Plugin(target, interceptor, signatureMap))

代理对象最终执行的方法为invoke方法，我们看当前Plugin的invoke方法。

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);
    
  

这里一切明了，只有signatureMap取出的methods中包含当前方法名才会调用代理对象的intercept方法，否则直接进行method.invoke操作，不会对方法进行拦截。

Plugin的用法以及原理分析就到此为止了。