转载

MyBatis 的插件对象如何创建出来的

1. 自定义插件友情提醒

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

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

这些接口中方法的细节可以通过查看每个方法的签名来发现，或者直接查看 MyBatis 发行包中的源代码。如果你想做的不仅仅是监控方法的调用，那么你最好相当了解要重写的方法的行为。因为如果在试图修改或重写已有方法的行为的时候，你很可能在破坏 MyBatis 的核心模块。这些都是更低层的类和方法，所以使用插件的时候要特别当心。

2. 自定义插件方式

通过 MyBatis 提供的强大机制，使用插件是非常简单的，只需实现 Interceptor 接口，并指定想要拦截的方法签名即可。

// ExamplePlugin.java
@Intercepts({
  @Signature(  
     type= Executor.class,
     method = "query",
     args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
public class ExamplePlugin implements Interceptor {

  public Object intercept(Invocation invocation) throws Throwable {
    return invocation.proceed();
  }

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

  public void setProperties(Properties properties) {
  }

}复制代码

3. 插件配置方式

定义好插件后，一般将插件配置在 MyBatis-config.xml 中即可使用：

<plugins>  
    <plugin interceptor="org.apache.ibatis.builder.ExamplePlugin" >    
        <property name="pluginProperty" value="100"/>  
    </plugin>
</plugins>复制代码

如果你用的是 Spring 项目，还可以通过在 SqlSessionFactoryBean 中注入使用：

//配置分页插件，详情请查阅官方文档
ExamplePlugin examplePlugin = new ExamplePlugin();Properties properties = new Properties();
properties.setProperty("xxx", "xxx");

examplePlugin .setProperties(properties);

//添加插件
factory.setPlugins(new Interceptor[]{examplePlugin });复制代码

4. 插件对象如何创建的

在 ExamplePlugin 中，有一个 plugin(Object target) 方法，这个方法内部调用了 Plugin.warp(Object target, Interceptor interceptor) 方法，这个 warp 方法就是要为 target 对象创建代理对象 proxy 。而这个创建出来的代理对象 proxy 就是我们要的插件对象。那这个对象是何时何地创建出来的呢？

在 Mybatis 中，创建代理对象 proxy 的类只有一个，就是上面说的 Plugin 类，源码如下：

public class Plugin implements InvocationHandler {  
    // 保存拦截器拦截的对象（这个target可能是个拦截器，也可能就是目标对象）
    private final Object target;  
    // 拦截器对象
    private final Interceptor interceptor;  
    // 见 getSignatureMap 方法
    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;  
    } 

    // 判断interceptor是否支持target拦截，支持则创建target的代理对象，否则原样返回target  
    // 如果一个对象适配多个interceptor，则会被多次代理  
    public static Object wrap(Object target, Interceptor interceptor) {  
        // 解析 interceptor 的 @interceptors 注解中定义的内容
        Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
   
        // 获取 target 的字节码对象
        Class<?> type = target.getClass();    

        // 根据 type 和 signatureMap，获取 type 查找所有匹配的拦截器支持拦截的接口字节码对象数组
        Class<?>[] interfaces = getAllInterfaces(type, signatureMap);   

        // 如果 interfaces 的大小大于 0，则给 target 对象创建代理对象。否则不创建代理对象
        if (interfaces.length > 0) {      

            // 创建 target 的代理类对象。利用的是 JDK 动态代理  
            return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));    
        }    
        return target; 
     } 

     // 实现 JDK 的 InvocationHandler 接口的 invoke 方法
     @Override  
     public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {    
        try {      
            // 获取 method 所属类或接口的字节码对象
            Set<Method> methods = signatureMap.get(method.getDeclaringClass()); 
            // 判断 methods 中是否包括 method，包含则执行 拦截器的 intercept 方法     
            if (methods != null && methods.contains(method)) {        
                return interceptor.intercept(new Invocation(target, method, args));     
             }      
            // 调用 method 的 invoke 方法，进入下一层调用
            return method.invoke(target, args);   
         } catch (Exception e) {      
            throw ExceptionUtil.unwrapThrowable(e);    
         }  
     }  

    private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {    
        // 获取 @Intercepts 注解对应的字节码对象 interceptsAnnotation
        Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);    

        // 如果 interceptsAnnotation 为空，抛出插件定义错误的异常
        if (interceptsAnnotation == null) {     
            throw new PluginException("No @Intercepts annotation was found in interceptor " + interceptor.getClass().getName());          
        }    

        // 获取所有 @Intercepts 中的所有 Signature   
        Signature[] sigs = interceptsAnnotation.value();
 
        // 定义 type 和 method 的映射 map
        Map<Class<?>, Set<Method>> signatureMap = new HashMap<>();    

        // 遍历 sigs ，初始化 signatureMap 
        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;  
    }  

    // 判断目标对象（Executor、StatementHandler、ParameterHandler和ResultSetHandler四个接口中的一种）是否有拦截器拦截 
    // 方法参数：  type：目标对象的字节码对象； signatureMap：是我们在 getSignatureMap 方法中得到的
    private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {    
        Set<Class<?>> interfaces = new HashSet<>();   
        while (type != null) {   
            // 获取 type 的父接口，并遍历  
            for (Class<?> c : type.getInterfaces()) {    
                 // 判断 signatureMap 中是否包含 type 的父接口   
                 if (signatureMap.containsKey(c)) {          
                    interfaces.add(c);       
                 }      
            }     
           // 获取 type 的父类，继续 while 循环
           type = type.getSuperclass();    
        }   

     // 返回匹配到的所有接口字节码对象
     return interfaces.toArray(new Class<?>[interfaces.size()]);  
   }
}
复制代码

Plugin 类实现了 JDK 中的 InvocationHandler 接口。包含 5 个方法和 3 个字段。上面的源码分析基本每一句都做了注释，看懂应该没有问题，毕竟大家都是老司机了。

其中 5 个方法作用：

（1）getSignatureMap(Interceptor interceptor){.......} 方法：

解析 interceptor 的 @Intercepts 注解中的值。返回接口字节码对象和拦截方法的映射集合 map。

比如上面的 ExamplePlugin，@Intercepts 注解中的内容是：

@Intercepts({
  @Signature(
  type= Executor.class,
  method = "query",  args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})
})复制代码

解析后得到的 Map 包含的值如下图：

MyBatis 的插件对象如何创建出来的

（2）wrap(Object target, Interceptor interceptor) {.....} 方法：

判断 interceptor 是佛支持 target 拦截，支持则创建 target 的代理对象，否则返回原 target。

（3）getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap){......}方法：

根据给定的 type 字节码对象，获取 signatureMap 中的 key 的值，组成集合返回。

MyBatis 的插件对象如何创建出来的

（4）invoke(Object proxy, Method method, Object[] args){......} 方法：

拦截器被 MyBatis 执行的入口就是这个 invoke 方法。具体的执行逻辑在上面的源码分析中已经添加了注释，老铁往上翻翻即可。不过这个方法中有一行代码我需要解释下，这行代码是这样的：

// 获取 method 所属类或接口的字节码对象
Set<Method> methods = signatureMap.get(method.getDeclaringClass());复制代码

这里的 method 想要从 signatureMap 中拿到值 methods，则 method 必须是拦截器作用的四大接口中的方法，即

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

中的方法。因为 signatureMap 中存储的 key 就是以上四大接口的字节码对象。可以看下图：

signatureMap 中存储的 key 和 value 示例：

MyBatis 的插件对象如何创建出来的