首先mybatisPlugin是针对于mybatis四大组件（Statementhandler、resultsethandler、parameterHandler、executor）做增强操作的。
要使用自定义plugin首先要实现Interceptor接口，如下：

public interface Interceptor {
//执行目标方法
Object intercept(Invocation invocation) throws Throwable;
//执行pluginAll调用
Object plugin(Object target);
//xml配置的初始化参数值
void setProperties(Properties properties);
}

首先自定义一个plugin实现接口如下：

@Intercepts({
        //type表示需要拦截的类型，method+args表示需要拦截的具体方法
        @Signature(type= Executor.class,method="query",args={MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class}),
})
public class MyPlugin implements Interceptor{
    @Override
    public Object intercept(Invocation invocation) throws Throwable {
        System.out.println("执行增强方法。。。");
        return invocation.proceed();
    }
    @Override
    public Object plugin(Object target) {
        System.out.println("执行pluginAll。。。");
        return Plugin.wrap(target,this);
    }
    @Override
    public void setProperties(Properties properties) {
        System.out.println("初始化。。。配置参数"+properties);
    }
}

第一个方法intercept里面执行了Invocarion对象的proceed方法，可以看出使用了反射执行了目标方法，这边有几个参数，分别有注释解释。

public class Invocation {
  //目标对象
  private final Object target;
  //目标方法
  private final Method method;
  //入参数
  private final Object[] args;
  //。。。构造函数、get、set方法
  public Object proceed() throws InvocationTargetException, IllegalAccessException {
    return method.invoke(target, args);
  }
}

第二个方法plugin执行了Plugin.Wrap方法，传入的参数是被代理对象，以及当前interceptor对象。Plugin对象如下：

public class Plugin implements InvocationHandler {
  //目标对象
  private final Object target;
  //interceptor对象
  private final Interceptor interceptor;
  //解析出来需要拦截的对象以及 方法
  private final Map<Class<?>, Set<Method>> signatureMap;
}

可以看出plugin实现了拦截器接口，对方法进行拦截，接下来看wrap方法做了什么：

public static Object wrap(Object target, Interceptor 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;
  }

这边具体看一下getAllInterfaces如何判断的：

private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
    //初始化接口集合
    Set<Class<?>> interfaces = new HashSet<Class<?>>();
   //type是目标对象
    while (type != null) {
      //遍历目标对象的接口方法，如果需要拦截的方法集合中存在了方法，则将方法加入interfaces集合中
      for (Class<?> c : type.getInterfaces()) {
        if (signatureMap.containsKey(c)) {
          interfaces.add(c);
        }
      }
      //获取父类并循环
      type = type.getSuperclass();
    }
    return interfaces.toArray(new Class<?>[interfaces.size()]);
  }

接下来看Plugin对象实现的invoke方法，在执行newProxyInstance方法时传入了一个新建的Plugin对象，包含了目标对象，interceptor以及需要拦截的方法：

@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)) {
        //如果有则执行intercepytor的intercept方法
        return interceptor.intercept(new Invocation(target, method, args));
      }
      //如果没有则执行原方法
      return method.invoke(target, args);
    } catch (Exception e) {
      throw ExceptionUtil.unwrapThrowable(e);
    }
  }

之前介绍过了，Interceptor的intercept方法执行了invocation方法的proceed方法，而proceed方法又是反射执行原方法，所以增强是在intercept方法执行的。

pluginAll调用处