一、概述　

　　Mybatis采用责任链模式，通过动态代理组织多个插件（拦截器），通过这些插件可以改变Mybatis的默认行为（诸如SQL重写之类的）

　　Mybatis是通过动态代理的方式实现拦截的
　　拦截器（Interceptor）在 Mybatis 中被当做插件（plugin）对待，官方文档提供了 Executor（拦截执行器的方法），ParameterHandler（拦截参数的处理），ResultSetHandler（拦截结果集的处理），StatementHandler（拦截Sql语法构建的处理） 共4种，并且提示“这些类中方法的细节可以通过查看每个方法的签名来发现，或者直接查看 MyBatis 发行包中的源代码”。

　　拦截器的使用场景主要是更新数据库的通用字段，分库分表，加解密等的处理。
　　MyBatis提供了一种插件(plugin)的功能，虽然叫做插件，但其实这是拦截器功能。
　　MyBatis 允许你在已映射语句执行过程中的某一点进行拦截调用。默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：
　　　　Executor (update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)：拦截执行器的方法
　　　　Mybatis的内部执行器，它负责调用StatementHandler操作数据库，并把结果集通过 ResultSetHandler进行自动映射，另外，他还处理了二级缓存的操作。从这里可以看出，我们也是可以通过插件来实现自定义的二级缓存的。
　　　　ParameterHandler (getParameterObject, setParameters)：拦截参数的处理是Mybatis实现Sql入参设置的对象。插件可以改变我们Sql的参数默认设置。
　　　　ResultSetHandler (handleResultSets, handleOutputParameters)：拦截结果集的处理是Mybatis把ResultSet集合映射成POJO的接口对象。我们可以定义插件对Mybatis的结果集自动映射进行修改。
　　　　StatementHandler (prepare, parameterize, batch, update, query)：拦截Sql语法构建的处理是Mybatis直接和数据库执行sql脚本的对象。另外它也实现了Mybatis的一级缓存。这里，我们可以使用插件来实现对一级缓存的操作(禁用等等)。

　　mybatis 拦截器原理 - 图2

　　Mybatis插件能够对这四大对象进行拦截，可以说包含到了Mybatis一次SQL执行的所有操作

二、 原理

　　mybatis 拦截器原理 - 图3

　　Mybatis的拦截器实现机制,使用的是JDK的InvocationHandler.
　　当我们调用ParameterHandler,ResultSetHandler,StatementHandler,Executor的对象的时候，实际上使用的是Plugin这个代理类的对象,这个类实现了InvocationHandler接口
　　接下来我们就知道了,在调用上述被代理类的方法的时候,就会执行Plugin的invoke方法.
　　Plugin在invoke方法中根据@Intercepts的配置信息(方法名,参数等)动态判断是否需要拦截该方法.
　　再然后使用需要拦截的方法Method封装成Invocation,并调用Interceptor的proceed方法.
　　这样我们就达到了拦截目标方法的结果.
　　例如Executor的执行大概是这样的流程:
　　拦截器代理类对象->拦截器->目标方法
　　　　Executor->Plugin->Interceptor->Invocation
　　　　Executor.Method->Plugin.invoke->Interceptor.intercept->Invocation.proceed->method.invoke

2.1、拦截器接口

　　拦截器均需要实现该 org.apache.ibatis.plugin.Interceptor 接口

  1. public interface Interceptor {
  2.   Object intercept(Invocation invocation) throws Throwable;
  3.   Object plugin(Object target);
  4.   void setProperties(Properties properties);
  5. }

　　有3个方法。 MyBatis默认没有一个拦截器接口的实现类
　　setProperties方法是在Mybatis进行配置插件的时候可以配置自定义相关属性，即：接口实现对象的参数配置。
　　plugin方法是插件用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理，可以决定是否要进行拦截进而决定要返回一个什么样的目标对象，官方提供了示例：return Plugin.wrap(target, this)。
　　　　理解这个接口的定义，先要知道java动态代理机制。plugin接口即返回参数target对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。在调用对应对象的接口的时候，可以进行拦截并处理。
　　intercept方法就是要进行拦截的时候要执行的方法。

2.2、拦截器四大接口实例

　　上述的Executor、ParameterHandler、ResultSetHandler、StatementHandler具体实现

2.2.1、实例创建

  1. public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
  2.    //确保ExecutorType不为空(defaultExecutorType有可能为空)
  3.    executorType = executorType == null ? defaultExecutorType : executorType;
  4.    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
  5.    Executor executor;   if (ExecutorType.BATCH == executorType) {
  6.       executor = new BatchExecutor(this, transaction);
  7.    } else if (ExecutorType.REUSE == executorType) {
  8.       executor = new ReuseExecutor(this, transaction);
  9.    } else {
  10.       executor = new SimpleExecutor(this, transaction);
  11.    }   if (cacheEnabled) {
  12.       executor = new CachingExecutor(executor);
  13.    }
  14.    executor = (Executor) interceptorChain.pluginAll(executor);
  15.    return executor;
  16. }
  17. public StatementHandler newStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
  18.    StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement, parameterObject, rowBounds, resultHandler, boundSql);
  19.    statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);
  20.    return statementHandler;
  21. }
  22. public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {
  23.    ParameterHandler parameterHandler = mappedStatement.getLang().createParameterHandler(mappedStatement, parameterObject, boundSql);
  24.    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);
  25.    return parameterHandler;
  26. }
  27. public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement, RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {
  28.    ResultSetHandler resultSetHandler = new DefaultResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);
  29.    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);
  30.    return resultSetHandler;
  31. }


　　查看源码可以发现， Mybatis框架在创建好这四大接口对象的实例后，都会调用InterceptorChain.pluginAll()方法。InterceptorChain对象是插件执行链对象，看源码就知道里面维护了Mybatis配置的所有插件(Interceptor)对象。

2.2.2、插件加载执行过程

1、plugin
　　target —> Executor/ParameterHandler/ResultSetHander/StatementHandler

  1. public Object pluginAll(Object target) {
  2.     for (Interceptor interceptor : interceptors) {
  3.        target = interceptor.plugin(target);
  4.     }
  5.     return target;
  6. }

　　其实就是按顺序执行我们插件的plugin方法，一层一层返回我们原对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。当我们调用四大接口的方法的时候，实际上是调用代理对象的相应方法，代理对象又会调用四大接口的实例。
　　Plugin对象
　　我们知道，官方推荐插件实现plugin方法为：Plugin.wrap(target, this);

2、wrap

  1. public static Object wrap(Object target, Interceptor interceptor) {
  2.  　// 获取插件的Intercepts注解
  3.  　Map, Set> signatureMap = getSignatureMap(interceptor);
  4.  　Class<?> type = target.getClass();
  5.  　Class<?>[] interfaces = getAllInterfaces(type, signatureMap);
  6.  　if (interfaces.length > 0) {
  7.    　return Proxy.newProxyInstance(type.getClassLoader(), interfaces, new Plugin(target, interceptor, signatureMap));
  8.  　}
  9.  　return target;
  10. }

　　这个方法其实是Mybatis简化我们插件实现的工具方法。其实就是根据当前拦截的对象创建了一个动态代理对象。代理对象的InvocationHandler处理器为新建的Plugin对象。

3、插件配置注解@Intercepts
　　Mybatis的插件都要有Intercepts注解来指定要拦截哪个对象的哪个方法。我们知道，Plugin.warp方法会返回四大接口对象的代理对象(通过new Plugin()创建的IvocationHandler处理器)，会拦截所有的执行方法。在代理对象执行对应方法的时候，会调用InvocationHandler处理器的invoke方法。Mybatis中利用了注解的方式配置指定拦截哪些方法。具体如下：

  1. public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  2.  　try {
  3.    　Set<Method> methods = signatureMap.get(method.getDeclaringClass());
  4.     if (methods != null && methods.contains(method)) {
  5.       return interceptor.intercept(new Invocation(target, method, args));
  6.    　}
  7.       // 反射执行目标方法
  8.   return method.invoke(target, args);
  9.  　} catch (Exception e) {
  10.    　throw ExceptionUtil.unwrapThrowable(e);
  11.  　}
  12. }

　　可以看到，只有通过Intercepts注解指定的方法才会执行我们自定义插件的intercept方法。未通过Intercepts注解指定的将不会执行我们的intercept方法。
4、官方插件开发方式

  1. @Intercepts({@Signature(type = Executor.class, method = "query",args = {MappedStatement.class, Object.class, RowBounds.class, ResultHandler.class})})
  2. public class TestInterceptor implements Interceptor {
  3.  　public Object intercept(Invocation invocation) throws Throwable {
  4.    　Object target = invocation.getTarget(); //被代理对象
  5.      Method method = invocation.getMethod(); //代理方法
  6.    　Object[] args = invocation.getArgs(); //方法参数
  7.     // do something ...... 方法拦截前执行代码块
  8.    　Object result = invocation.proceed();
  9.     // do something .......方法拦截后执行代码块
  10.     return result;
  11.  　}
  12.  　public Object plugin(Object target) {
  13.    return Plugin.wrap(target, this);
  14.  　}
  15. }

　　以上就是Mybatis官方推荐的插件实现的方法，通过Plugin对象创建被代理对象的动态代理对象。可以发现，Mybatis的插件开发还是很简单的。
　　自定义开发方式
　　Mybatis的插件开发通过内部提供的Plugin对象可以很简单的开发。只有理解了插件实现原理，对应不采用Plugin对象我们一样可以自己实现插件的开发。下面是我个人理解之后的自己实现的一种方式。
5、实例；

  1. public class TestInterceptor implements Interceptor {
  2. public Object intercept(Invocation invocation) throws Throwable {
  3.     Object target = invocation.getTarget(); //被代理对象
  4.     Method method = invocation.getMethod(); //代理方法
  5.     Object[] args = invocation.getArgs(); //方法参数
  6.     // do something ...... 方法拦截前执行代码块
  7.     Object result = invocation.proceed();
  8.     // do something .......方法拦截后执行代码块
  9.     return result;
  10. }
  11. public Object plugin(final Object target) {
  12.     return Proxy.newProxyInstance(Interceptor.class.getClassLoader(), target.getClass().getInterfaces(), new InvocationHandler() {
  13.         public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
  14.             return intercept(new Invocation(target, method, args));
  15.         }
  16.     });
  17. }
  18. public void setProperties(Properties properties) {
  19. }
  20. }

　　当然，Mybatis插件的那这个时候Intercepts的注解起不到作用了。

6、小结
　　如果有N个插件，就有N个代理，每个代理都要执行上面的逻辑。这里面的层层代理要多次生成动态代理，是比较影响性能的。虽然能指定插件拦截的位置，但这个是在执行方法时动态判断，初始化的时候就是简单的把插件包装到了所有可以拦截的地方。
　　因此，在编写插件时需注意以下几个原则：
　　　　不编写不必要的插件；
　　　　实现plugin方法时判断一下目标类型，是本插件要拦截的对象才执行Plugin.wrap方法，否者直接返回目标本身，这样可以减少目标被代理的次数。
　　　　// 假如我们只要拦截Executor对象，那么我们应该这么做，默认是【return Plugin.wrap(target, this);】

  1. @Override
  2.     public Object plugin(Object target) {
  3.         if (target instanceof Executor) {
  4.             return Plugin.wrap(target, this);
  5.         } else {
  6.             return target;
  7.         }
  8.     }


　　Mybatis插件很强大，可以对Mybatis框架进行很大的扩展。当然，如果你不理解Mybatis插件的原理，开发起来只能是模拟两可。在实际开发过程中，我们可以参考别人写的插件。下面是一个Mybatis分页的插件，可以为以后开发做参考。
　　每一个拦截器对目标类都进行一次代理，原对象如果是X，那么第一个拦截器代理后为P(X)，第二个代理后P(P(X))……最后返回这样的多重代理对象并执行。所以先配置的拦截器会后执行，因为先配置的先被包装成代理对象。
　　最后在调用真实对象方法的时候，实际上是调用多重代理的invoke方法，当符合拦截条件的时候执行我们编写的interceptor.intercept，intercept方法最后必定是调用invocation.proceed，proceed也是一个method.invoke，促使拦截链往下进行，不符合拦截条件的时候直接调用method.invoke，即不执行我们的拦截方法，继续拦截链。

2.3、对象方法说明

2.3.1、Executor类说明

1、拦截器注解

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

　　拦截器的使用需要查看每一个type所提供的方法参数。
　　Signature 对应 Invocation 构造器，type 为 Invocation.Object，method 为 Invocation.Method，args 为 Invocation.Object[]。
　　method 对应的 update 包括了最常用的 insert/update/delete 三种操作，因此 update 本身无法直接判断sql为何种执行过程。
　　args 包含了其余所有的操作信息, 按数组进行存储, 不同的拦截方式有不同的参数顺序, 具体看type接口的方法签名, 然后根据签名解析。

2、Object 对象类型
　　args 参数列表中，Object.class 是特殊的对象类型。如果有数据库统一的实体 Entity 类，即包含表公共字段，比如创建、更新操作对象和时间的基类等，在编写代码时尽量依据该对象来操作，会简单很多。该对象的判断使用

  1. Object parameter = invocation.getArgs()[1];
  2. if (parameter instanceof BaseEntity) {
  3.     BaseEntity entity = (BaseEntity) parameter;
  4. }

　　即可，根据语句执行类型选择对应字段的赋值。
　　如果参数不是实体，而且具体的参数，那么 Mybatis 也做了一些处理，比如 @Param("name") String name 类型的参数，会被包装成 Map 接口的实现来处理，即使是原始的 Map 也是如此。使用

  1. Object parameter = invocation.getArgs()[1];
  2. if (parameter instanceof Map) {
  3.     Map map = (Map) parameter;
  4. }

即可，对具体统一的参数进行赋值。

3、SqlCommandType 命令类型
Executor 提供的方法中，update 包含了 新增，修改和删除类型，无法直接区分，需要借助 MappedStatement 类的属性 SqlCommandType 来进行判断，该类包含了所有的操作类型

  1. public enum SqlCommandType {
  2.   UNKNOWN, INSERT, UPDATE, DELETE, SELECT, FLUSH;
  3. }

毕竟新增和修改的场景，有些参数是有区别的，比如创建时间和更新时间，update 时是无需兼顾创建时间字段的

  1. MappedStatement ms = (MappedStatement) invocation.getArgs()[0];
  2. SqlCommandType commandType = ms.getSqlCommandType();