MyBatis中的插件分析与开发

刺骨的言语ヽ痛彻心扉 2022-09-04 13:52 181阅读 0赞

**流程原理分析系列：**  
[MyBatis原理分析之获取SqlSessionFactory][MyBatis_SqlSessionFactory]  
[MyBatis原理分析之获取SqlSession][MyBatis_SqlSession]  
[MyBatis原理分析之获取Mapper接口的代理对象][MyBatis_Mapper]  
[MyBatis原理分析之查询单个对象][MyBatis]  
[MyBatis Plus插件机制与执行流程原理分析][MyBatis Plus]

# 【1】MyBatis的插件机制 #

MyBatis在四大对象的创建过程中，都会有插件进行介入。插件可以利用动态代理机制一层层的包装目标对象，而实现在目标对象执行目标方法之前进行拦截的效果。

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

*  Executor(update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
 *  ParameterHandler(getParameterObject, setParameters)
 *  ResultSetHandler(handleResultSets, handleOutputParameters)
 *  StatementHandler(prepare, parameterize, batch, update, query)

**这里我们再回顾一下，在创建StatementHandler时，我们看到了如下代码：**

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 ##

在全局配置Configuration中维护了一个`InterceptorChain interceptorChain = new InterceptorChain()`拦截器链，其内部维护了一个私有常量`List<Interceptor> interceptors`，其`pluginAll`方法为遍历`interceptors`并调用每个拦截器的`plugin`方法。

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

**MyBatis中拦截器接口**

package org.apache.ibatis.plugin;
    import java.util.Properties;
    public interface Interceptor { 
      //拦截处理，也就是代理对象目标方法执行前被处理 
      Object intercept(Invocation invocation) throws Throwable;
      //生成代理对象
      Object plugin(Object target);
      //设置属性
      void setProperties(Properties properties);
    }

如果想自定义插件，那么就需要实现该接口。

**MyBatis中的Invocation**

package org.apache.ibatis.plugin;
    import java.lang.reflect.InvocationTargetException;
    import java.lang.reflect.Method;
    
    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 getTarget() {  return target;}
     public Method getMethod() { return method;}
     public Object[] getArgs() { return args;}
     //proceed-继续，也就是说流程继续往下执行，这里看方法就是目标方法反射调用。
     public Object proceed() throws InvocationTargetException, IllegalAccessException { 
       return method.invoke(target, args);
     }
    
    }

## ② MyBatis中的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;
    
    public class Plugin implements InvocationHandler { 
      //目标对象 ,被代理的对象
      private final Object target;
      //拦截器
      private final Interceptor interceptor;
      //方法签名集合
      private final 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;
      }
      //该方法会获取signatureMap中包含的所有target实现的接口，然后生成代理对象
      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;
      }
      //每一个InvocationHandler 的invoke方法会在代理对象的目标方法执行前被触发
      @Override
      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);
        }
      }
    	//获取拦截器感兴趣的接口与方法
      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<>();
        for (Signature sig : sigs) { 
          Set<Method> methods = signatureMap.computeIfAbsent(sig.type(), k -> new HashSet<>());
          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;
      }
    	//该方法会获取signatureMap中包含的所有type实现的接口与上级接口
      private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) { 
        Set<Class<?>> interfaces = new HashSet<>();
        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()]);
      }
    }

这里`Plugin`实现了`InvocationHandler`，那么其`invoke`方法会在代理对象的目标方法执行前被触发。其`invoke`方法解释如下：

*  ① 获取当前Plugin感兴趣的方法类型，判断目标方法Method是否被包含；
 *  ② 如果当前目标方法是Plugin感兴趣的，那么就`interceptor.intercept(new Invocation(target, method, args));`触发拦截器的intercept方法；
 *  ③ 如果当前目标方法不是Plugin感兴趣的，直接执行目标方法。

上面说`Plugin感兴趣`其实是指内部的interceptor感兴趣。

# 【2】MyBatis插件开发 #

如下所示，编写插件实现`Interceptor`接口，并使用`@Intercepts`注解完成插件签名。

package com.mybatis.dao;
    
    import java.util.Properties;
    
    import org.apache.ibatis.executor.parameter.ParameterHandler;
    import org.apache.ibatis.executor.statement.StatementHandler;
    import org.apache.ibatis.plugin.Interceptor;
    import org.apache.ibatis.plugin.Intercepts;
    import org.apache.ibatis.plugin.Invocation;
    import org.apache.ibatis.plugin.Plugin;
    import org.apache.ibatis.plugin.Signature;
    import org.apache.ibatis.reflection.MetaObject;
    import org.apache.ibatis.reflection.SystemMetaObject;
    
    /** * 完成插件签名：告诉MyBatis当前插件用来拦截哪个对象的哪个方法 */
    @Intercepts({ @Signature(type=StatementHandler.class,method="parameterize",args=java.sql.Statement.class)})
    public class MyFirstPlugin implements Interceptor{ 
    	@Override
    	public Object intercept(Invocation invocation) throws Throwable { 
    		// TODO Auto-generated method stub
    		System.out.println("MyFirstPlugin...intercept:"+invocation.getMethod());
    		Object target = invocation.getTarget();
    		System.out.println("当前拦截到的对象："+target);
    		//拿到：StatementHandler==>ParameterHandler===>parameterObject
    		//拿到target的元数据
    		MetaObject metaObject = SystemMetaObject.forObject(target);
    		Object value = metaObject.getValue("parameterHandler.parameterObject");
    		System.out.println("sql语句用的参数是："+value);
    		//修改完sql语句要用的参数
    		metaObject.setValue("parameterHandler.parameterObject", 11);
    		//执行目标方法
    		Object proceed = invocation.proceed();
    		//返回执行后的返回值
    		return proceed;
    	}
    	 //plugin：包装目标对象的：包装：为目标对象创建一个代理对象
    	@Override
    	public Object plugin(Object target) { 
    		//我们可以借助Plugin的wrap方法来使用当前Interceptor包装我们目标对象
    		System.out.println("MyFirstPlugin...plugin:mybatis将要包装的对象"+target);
    		Object wrap = Plugin.wrap(target, this);
    		//返回为当前target创建的动态代理
    		return wrap;
    	}
    	 //setProperties：将插件注册时 的property属性设置进来
    	@Override
    	public void setProperties(Properties properties) { 
    		// TODO Auto-generated method stub
    		System.out.println("插件配置的信息："+properties);
    	}
    }

**注册到mybatis的全局配置文件中，示例如下(`注意，插件是可以设置属性的如这里我们可以设置用户名、密码`)：**

那么mybatis在执行过程中实例化`Executor、ParameterHandler、ResultSetHandler和StatementHandler`时都会触发上面我们自定义插件的`plugin`方法。

如果有多个插件，那么`拦截器链包装的时候会从前到后，执行的时候会从后到前`。如这里生成的`StatementHandler`代理对象如下：  
![在这里插入图片描述][watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]  
**总结**

*  按照插件注解声明，按照插件配置顺序调用插件`plugin`方法，生成被拦截对象的动态代理；
 *  多个插件依次生成目标对象的代理对象，层层包裹，先声明的先包裹，形成代理链；
 *  目标方法执行时依次从外到内执行插件的`intercept`方法。
 *  多个插件情况下，我们往往需要在某个插件中分离出目标对象。可以借助`MyBatis`提供的`SystemMetaObject`类来进行获取最后一层的`h`以及`target`属性的值

[MyBatis_SqlSessionFactory]: https://janus.blog.csdn.net/article/details/119334417
[MyBatis_SqlSession]: https://editor.csdn.net/md/?articleId=119485997
[MyBatis_Mapper]: https://blog.csdn.net/J080624/article/details/119510355
[MyBatis]: https://janus.blog.csdn.net/article/details/53203688
[MyBatis Plus]: https://janus.blog.csdn.net/article/details/108441600
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L0owODA2MjQ_size_16_color_FFFFFF_t_70]: /images/20220829/43e63e3ac8cd492cb365fc59fee97442.png