spring mvc mybatis 拦截器 mybatis拦截器作用

拦截器

拦截器的作用就是在执行sql的过程中插入一些执行逻辑，比如记录当前执行的sql、分页等

使用

@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.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) {
  }
}

使用另一个自定义的拦截器，只需要另找个拦截器实现Interceptor接口，并且使用注解@Intercepts来声明对哪些类的哪些方法进行拦截即可

接口

public interface Interceptor {

  // 用来对一次调用进行拦截操作
  Object intercept(Invocation invocation) throws Throwable;
  // 在目标对象外层包裹interceptor
  default Object plugin(Object target) {
    return Plugin.wrap(target, this);
  }

  default void setProperties(Properties properties) {
    // NOP
  }

}

加载

在使用XMLConfigBuilder解析mybatis配置文件的时候，会调用pluginElement方法

pluginElement(root.evalNode("plugins"));

private void pluginElement(XNode parent) throws Exception {
  if (parent != null) {
    // 遍历plugins标签下的所有plugin标签，每个plugin标签对应一个拦截器
    for (XNode child : parent.getChildren()) {
      // 拦截器类的全路径名称
      String interceptor = child.getStringAttribute("interceptor");
      // 其他属性
      Properties properties = child.getChildrenAsProperties();
      // 创建一个拦截器实例，并且将其他属性赋值给该拦截器实例
      Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).getDeclaredConstructor().newInstance();
      interceptorInstance.setProperties(properties);
      // 将拦截器添加到全局配置中
      	  configuration.addInterceptor(interceptorInstance);
    }
  }
}

public void addInterceptor(Interceptor interceptor) {
  // 底层会调用interceptorChain
  interceptorChain.addInterceptor(interceptor);
}

public void addInterceptor(Interceptor interceptor) {
  // interceptors就是一个list
  interceptors.add(interceptor);
}

拦截

通过源码可以知道，interceptorChain的pluginAll在四个地方被调用

分别对应ParameterHandler、ResultSetHandler、StatementHandler、Executor的创建过程

也就是说当我们调用上述四个类的实例的方法的时候，会开启拦截功能

下面看下InterceptorChain的pluginAll方法

public Object pluginAll(Object target) {
  // 遍历当前所有的拦截器，不断地在目标对象上套上interceptor
  // 这样在执行的时候，就会经过一层层的拦截器，执行其拦截操作，最后调用目标对象的执行逻辑
  for (Interceptor interceptor : interceptors) {
    target = interceptor.plugin(target);
  }
  return target;
}

plugin

下面看下plugin的具体实现

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

public static Object wrap(Object target, Interceptor interceptor) {
  // key是需要拦截的类，value是该类需要拦截的所有方法
  Map<Class<?>, Set<Method>> signatureMap = getSignatureMap(interceptor);
  Class<?> type = target.getClass();
  // 遍历当前类实现的接口，父类实现的接口以及祖先类实现的接口，返回哪些接口需要拦截
  Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
  if (interfaces.length > 0) {
    // 如果需要拦截，返回动态代理生成的对象，主要逻辑在plugin中
    // 这里使用的接口集合是之前解析过的需要进行拦截的接口集合
    return Proxy.newProxyInstance(
        type.getClassLoader(),
        interfaces,
        new Plugin(target, interceptor, signatureMap));
  }
  // 如果不需要拦截，返回当前对象本身
  return target;
}

getSignatureMap

private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
  // 获取Intercepts注解
  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属性,该属性指定对哪个类的哪个方法进行拦截
  Signature[] sigs = interceptsAnnotation.value();
  Map<Class<?>, Set<Method>> signatureMap = new HashMap<>();
  // Signature是一个数组，因此可以对多个方法进行拦截
  for (Signature sig : sigs) {
    // type是需要拦截的类
    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;
}

getAllInterfaces

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 = type.getSuperclass();
  }
  return interfaces.toArray(new Class<?>[interfaces.size()]);
}

Plugin.invoke

Plugin实现了InvocationHandler接口，因此主要的拦截逻辑在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);
  }
}