mybatis插件机制

目录

mybatis插件机制

mybatis的插件机制使用动态代理实现，不了解的朋友请先了解代理模式和动态代理；插件本质是功能增强，那么它如果需要对某个方法进行增强，首先要拦截这个方法，其实也就类似于拦截器，mybatis的插件在代码中定义为interceptor，也就是拦截器；后面统一称作拦截器；

主要 类/接口 和 方法

• interceptor

方法	主要功能
object intercept(invocation invocation)	拦截器功能具体实现
object plugin(object target)	为被代理类生成代理对象
void setproperties(properties properties)	获取自定义配置

• interceptorchain

方法	主要功能
public object pluginall(object target)	生成代理对象，通过代理的方式注入拦截器功能
public void addinterceptor(interceptor interceptor)	注册插件
...getinterceptors()	获取一个不可修改的拦截器集合

• plugin

方法	主要功能
public static object wrap(object target, interceptor interceptor)	使用动态代理生成代理对象
public object invoke(object proxy, method method, object[] args)	调用拦截器的intercept方法或者直接调用被代理对象的当前方法
...getsignaturemap(interceptor interceptor)	根据拦截器上的注解反射获取目标方法

mybatis插件机制实现

interceptorchain中维护了一个拦截器列表，也就说所有的拦截器都要在这里注册；

interceptorchain中关键的一个方法是pluginall：

  public object pluginall(object target) {
    for (interceptor interceptor : interceptors) {
      target = interceptor.plugin(target);
    }
    return target;
  }

pluginall方法中是调用了interceptor的plugin方法，
这个plugin方法是一个覆写方法，需要插件开发者自己实现，但是mybatis已经提供了相应的实现：

  @override
    public object plugin(object target) {
        return plugin.wrap(target, this);
    }

打开plugin这个工具类发现它实现了invocationhandler接口，再看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);
    //判断是否是否实现了接口，如果是则使用jdk动态代理生成代理对象，否则返回原对象
    if (interfaces.length > 0) {
      return proxy.newproxyinstance(
          type.getclassloader(),
          interfaces,
          new plugin(target, interceptor, signaturemap));
    }
    return target;
  }

实际上就是使用jdk动态代理为target创建了一个代理对象，并且这个被代理的对象必须是一个接口的实现类（jdk动态代理必须有接口），否则不会生成代理对象，也就是说拦截器只能拦截接口的方法；既然是动态代理肯定要看一下invoke方法：

 public object invoke(object proxy, method method, object[] args) throws throwable {
    try {
      set<method> methods = signaturemap.get(method.getdeclaringclass());
      //如果当前执行的方法是拦截器想要拦截的方法则执行拦截器intercept方法否则，执行原方法；
      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方法中signaturemap是否有存在当前调用的method决定了是否调用interceptor的intercept方法，也就是说interceptor只对signaturemap中的方法生效，那么再来看signaturemap是怎么来的：

 private static map<class<?>, set<method>> getsignaturemap(interceptor interceptor) {
    //获取拦截器intercepts注解
    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;
  }

到这里可以看到，interceptor需要拦截的方法通过@intercepts注解申明，这里根据注解中的方法签名（类类型，方法名，方法参数）反射获取具体方法并添加到signaturemap中；interceptor中的intercepts注解就是定义需要拦截的方法集合；

那么再回过头看interceptorchain的pluginall方法，方法内遍历所有的拦截器并调用plugin方法，实际上就是每个插件都是一层代理，通过多层代理来绑定多个插件；换句话说，某个对象要想被interceptorchain中的拦截器拦截，那么此对象必须经过interceptorchain的pluginall(object target)方法的包装，当然由于jdk动态代理的关系必须是接口对象；

比如mybatis分页插件：

@suppresswarnings({"rawtypes", "unchecked"})
@intercepts(
    {
        @signature(type = executor.class, method = "query", args = {mappedstatement.class, object.class, rowbounds.class, resulthandler.class}),
        @signature(type = executor.class, method = "query", args = {mappedstatement.class, object.class, rowbounds.class, resulthandler.class, cachekey.class, boundsql.class}),
    }
)
public class pageinterceptor implements interceptor {
    //缓存count查询的ms
    protected cache<cachekey, mappedstatement> mscountmap = null;
    private dialect dialect;
    private string default_dialect_class = "com.github.pagehelper.pagehelper";
    private field additionalparametersfield;

    @override
    public object intercept(invocation invocation) throws throwable {
        //分页逻辑
    }

    @override
    public object plugin(object target) {
        return plugin.wrap(target, this);
    }

    @override
    public void setproperties(properties properties) {
       //获取配置
    }

}

通过上文我们知道它需要拦截executor的query方法，executor是mybatis运行sql的核心组件，之所以能够被拦截是因为：
在configuration类中创建executor之后，有这样一句代码：

executor = (executor) interceptorchain.pluginall(executor);

完~