MyBatis 拦截器介绍-Toy模板网

这篇具有很好参考价值的文章主要介绍了MyBatis 拦截器介绍。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

MyBatis 拦截器介绍

MyBatis 提供了一种插件 (plugin) 的功能，虽然叫做插件，但其实这是拦截器功能。那么拦截器拦截 MyBatis 中的哪些内容呢？

我们进入官网看一看：

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

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

我们看到了可以拦截 Executor 接口的部分方法，比如 update，query，commit，rollback 等方法，还有其他接口的一些方法等。

总体概括为：

拦截执行器的方法
拦截参数的处理
拦截结果集的处理
拦截 Sql 语法构建的处理

拦截器的使用

拦截器介绍及配置

首先我们看下 MyBatis 拦截器的接口定义：

public interface Interceptor {

  Object intercept(Invocation invocation) throws Throwable;

  Object plugin(Object target);

  void setProperties(Properties properties);

}

比较简单，只有 3 个方法。 MyBatis 默认没有一个拦截器接口的实现类，开发者们可以实现符合自己需求的拦截器。

下面的 MyBatis 官网的一个拦截器实例：

@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) {
  }
}

全局 xml 配置：

<plugins>
    <plugin interceptor="org.format.mybatis.cache.interceptor.ExamplePlugin"></plugin>
</plugins>

这个拦截器拦截 Executor 接口的 update 方法（其实也就是 SqlSession 的新增，删除，修改操作），所有执行 executor 的 update 方法都会被该拦截器拦截到。

源码分析

下面我们分析一下这段代码背后的源码。

首先从源头 -> 配置文件开始分析：

XMLConfigBuilder 解析 MyBatis 全局配置文件的 pluginElement 私有方法：

private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        String interceptor = child.getStringAttribute("interceptor");
        Properties properties = child.getChildrenAsProperties();
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
        interceptorInstance.setProperties(properties);
        configuration.addInterceptor(interceptorInstance);
      }
    }
}

具体的解析代码其实比较简单，就不贴了，主要就是通过反射实例化 plugin 节点中的 interceptor 属性表示的类。然后调用全局配置类 Configuration 的 addInterceptor 方法。

public void addInterceptor(Interceptor interceptor) {
       interceptorChain.addInterceptor(interceptor);
     }

这个 interceptorChain 是 Configuration 的内部属性，类型为 InterceptorChain，也就是一个拦截器链，我们来看下它的定义：

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

}

现在我们理解了拦截器配置的解析以及拦截器的归属，现在我们回过头看下为何拦截器会拦截这些方法（Executor，ParameterHandler，ResultSetHandler，StatementHandler 的部分方法）：

public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
    return parameterHandler;
}

public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler,
  ResultHandler resultHandler, BoundSql boundSql) {
    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
    return resultSetHandler;
}

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

public Executor newExecutor(Transaction transaction, ExecutorType executorType, boolean autoCommit) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    if (ExecutorType.BATCH == executorType) {
      executor = new BatchExecutor(this, transaction);
    } else if (ExecutorType.REUSE == executorType) {
      executor = new ReuseExecutor(this, transaction);
    } else {
      executor = new SimpleExecutor(this, transaction);
    }
    if (cacheEnabled) {
      executor = new CachingExecutor(executor, autoCommit);
    }
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
}

以上 4 个方法都是 Configuration 的方法。这些方法在 MyBatis 的一个操作 (新增，删除，修改，查询) 中都会被执行到，执行的先后顺序是 Executor，ParameterHandler，ResultSetHandler，StatementHandler (其中 ParameterHandler 和 ResultSetHandler 的创建是在创建 StatementHandler [3 个可用的实现类 CallableStatementHandler,PreparedStatementHandler,SimpleStatementHandler] 的时候，其构造函数调用的 [这 3 个实现类的构造函数其实都调用了父类 BaseStatementHandler 的构造函数])。

这 4 个方法实例化了对应的对象之后，都会调用 interceptorChain 的 pluginAll 方法，InterceptorChain 的 pluginAll 刚才已经介绍过了，就是遍历所有的拦截器，然后调用各个拦截器的 plugin 方法。注意：拦截器的 plugin 方法的返回值会直接被赋值给原先的对象

由于可以拦截 StatementHandler，这个接口主要处理 sql 语法的构建，因此比如分页的功能，可以用拦截器实现，只需要在拦截器的 plugin 方法中处理 StatementHandler 接口实现类中的 sql 即可，可使用反射实现。

MyBatis 还提供了 @Intercepts 和 @Signature 关于拦截器的注解。官网的例子就是使用了这 2 个注解，还包括了 Plugin 类的使用：

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

下面我们就分析这 3 个 "新组合" 的源码，首先先看 Plugin 类的 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);
    if (interfaces.length > 0) {
      return Proxy.newProxyInstance(
          type.getClassLoader(),
          interfaces,
          new Plugin(target, interceptor, signatureMap));
    }
    return target;
}

Plugin 类实现了 InvocationHandler 接口，很明显，我们看到这里返回了一个 JDK 自身提供的动态代理类。我们解剖一下这个方法调用的其他方法：

getSignatureMap 方法：

private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
    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;
}

getSignatureMap 方法解释：首先会拿到拦截器这个类的 @Interceptors 注解，然后拿到这个注解的属性 @Signature 注解集合，然后遍历这个集合，遍历的时候拿出 @Signature 注解的 type 属性 (Class 类型)，然后根据这个 type 得到带有 method 属性和 args 属性的 Method。由于 @Interceptors 注解的 @Signature 属性是一个属性，所以最终会返回一个以 type 为 key，value 为 Set<Method > 的 Map。

@Intercepts({@Signature(
  type= Executor.class,
  method = "update",
  args = {MappedStatement.class,Object.class})})

比如这个 @Interceptors 注解会返回一个 key 为 Executor，value 为集合 (这个集合只有一个元素，也就是 Method 实例，这个 Method 实例就是 Executor 接口的 update 方法，且这个方法带有 MappedStatement 和 Object 类型的参数)。这个 Method 实例是根据 @Signature 的 method 和 args 属性得到的。如果 args 参数跟 type 类型的 method 方法对应不上，那么将会抛出异常。

getAllInterfaces 方法：

private static Class<?>[] getAllInterfaces(Class<?> type, Map<Class<?>, Set<Method>> signatureMap) {
    Set<Class<?>> interfaces = new HashSet<Class<?>>();
    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()]);
}

getAllInterfaces 方法解释：根据目标实例 target (这个 target 就是之前所说的 MyBatis 拦截器可以拦截的类，Executor,ParameterHandler,ResultSetHandler,StatementHandler) 和它的父类们，返回 signatureMap 中含有 target 实现的接口数组。

所以 Plugin 这个类的作用就是根据 @Interceptors 注解，得到这个注解的属性 @Signature 数组，然后根据每个 @Signature 注解的 type，method，args 属性使用反射找到对应的 Method。最终根据调用的 target 对象实现的接口决定是否返回一个代理对象替代原先的 target 对象。

比如 MyBatis 官网的例子，当 Configuration 调用 newExecutor 方法的时候，由于 Executor 接口的 update (MappedStatement ms, Object parameter) 方法被拦截器被截获。因此最终返回的是一个代理类 Plugin，而不是 Executor。这样调用方法的时候，如果是个代理类，那么会执行：

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

没错，如果找到对应的方法被代理之后，那么会执行 Interceptor 接口的 interceptor 方法。

这个 Invocation 类如下：

public class Invocation {

  private Object target;
  private Method method;
  private 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;
  }

  public Object proceed() throws InvocationTargetException, IllegalAccessException {
    return method.invoke(target, args);
  }

}

它的 proceed 方法也就是调用原先方法 (不走代理)。