概述

Mybatis插件又称拦截器，本篇文章中出现的拦截器都表示插件。

Mybatis采用责任链模式，通过动态代理组织多个插件(拦截器)，通过这些插件可以改变Mybatis的默认行为(诸如SQL重写之类的)，由于插件会深入到Mybatis的核心，因此在编写自己的插件前最好了解下它的原理，以便写出安全高效的插件。

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

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

总体概括为：

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

Mybatis是通过动态代理的方式实现拦截的，阅读此篇文章需要先对Java的动态代理机制有所了解。

Mybatis四大接口

既然Mybatis是对四大接口进行拦截的，那我们先要知道Mybatis的四大接口是哪些： Executor, StatementHandler, ResultSetHandler, ParameterHandler。

上图Mybatis框架的整个执行过程。Mybatis插件能够对这四大对象进行拦截，可以说包含到了Mybatis一次SQL执行的所有操作。可见Mybatis的的插件很强大。

1. Executor是 Mybatis的内部执行器，它负责调用StatementHandler操作数据库，并把结果集通过 ResultSetHandler进行自动映射，另外，他还处理了二级缓存的操作。从这里可以看出，我们也是可以通过插件来实现自定义的二级缓存的。
2. StatementHandler是Mybatis直接和数据库执行sql脚本的对象。另外它也实现了Mybatis的一级缓存。这里，我们可以使用插件来实现对一级缓存的操作(禁用等等)。
3. ParameterHandler是Mybatis实现Sql入参设置的对象。插件可以改变我们Sql的参数默认设置。
4. ResultSetHandler是Mybatis把ResultSet集合映射成POJO的接口对象。我们可以定义插件对Mybatis的结果集自动映射进行修改。

   插件Interceptor

   Mybatis的插件实现要实现Interceptor接口，我们看下这个接口定义的方法。

   publicinterfaceInterceptor{
   Objectintercept(Invocationinvocation)throwsThrowable;
   Objectplugin(Objecttarget);
   voidsetProperties(Propertiesproperties);
   }
   

   这个接口只声明了三个方法：

   • setProperties方法是在Mybatis进行配置插件的时候可以配置自定义相关属性，即：接口实现对象的参数配置。
   • plugin方法是插件用于封装目标对象的，通过该方法我们可以返回目标对象本身，也可以返回一个它的代理，可以决定是否要进行拦截进而决定要返回一个什么样的目标对象，官方提供了示例：return Plugin.wrap(target, this)。
   • intercept方法就是要进行拦截的时候要执行的方法。

   理解这个接口的定义，先要知道java动态代理机制。plugin接口即返回参数target对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。在调用对应对象的接口的时候，可以进行拦截并处理。

   Mybatis四大接口对象创建方法

   Mybatis的插件是采用对四大接口的对象生成动态代理对象的方法来实现的。那么现在我们看下Mybatis是怎么创建这四大接口对象的。

   publicExecutornewExecutor(Transactiontransaction,ExecutorTypeexecutorType){
   //确保ExecutorType不为空(defaultExecutorType有可能为空)
   executorType=executorType==null?defaultExecutorType:executorType;
   executorType=executorType==null?ExecutorType.SIMPLE:executorType;
   Executorexecutor;if(ExecutorType.BATCH==executorType){
   executor=newBatchExecutor(this,transaction);
   }elseif(ExecutorType.REUSE==executorType){
   executor=newReuseExecutor(this,transaction);
   }else{
   executor=newSimpleExecutor(this,transaction);
   }if(cacheEnabled){
   executor=newCachingExecutor(executor);
   }
   executor=(Executor)interceptorChain.pluginAll(executor);
   returnexecutor;
   }
   
   publicStatementHandlernewStatementHandler(Executorexecutor,MappedStatementmappedStatement,ObjectparameterObject,RowBoundsrowBounds,ResultHandlerresultHandler,BoundSqlboundSql){
   StatementHandlerstatementHandler=newRoutingStatementHandler(executor,mappedStatement,parameterObject,rowBounds,resultHandler,boundSql);
   statementHandler=(StatementHandler)interceptorChain.pluginAll(statementHandler);
   returnstatementHandler;
   }
   
   publicParameterHandlernewParameterHandler(MappedStatementmappedStatement,ObjectparameterObject,BoundSqlboundSql){
   ParameterHandlerparameterHandler=mappedStatement.getLang().createParameterHandler(mappedStatement,parameterObject,boundSql);
   parameterHandler=(ParameterHandler)interceptorChain.pluginAll(parameterHandler);
   returnparameterHandler;
   }
   
   publicResultSetHandlernewResultSetHandler(Executorexecutor,MappedStatementmappedStatement,RowBoundsrowBounds,ParameterHandlerparameterHandler,ResultHandlerresultHandler,BoundSqlboundSql){
   ResultSetHandlerresultSetHandler=newDefaultResultSetHandler(executor,mappedStatement,parameterHandler,resultHandler,boundSql,rowBounds);
   resultSetHandler=(ResultSetHandler)interceptorChain.pluginAll(resultSetHandler);
   returnresultSetHandler;
   }
   

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

   //target-->Executor/ParameterHandler/ResultSetHander/StatementHandler
   publicObjectpluginAll(Objecttarget){
   for(Interceptorinterceptor:interceptors){
   target=interceptor.plugin(target);
   }
   returntarget;
   }
   

   其实就是按顺序执行我们插件的plugin方法，一层一层返回我们原对象(Executor/ParameterHandler/ResultSetHander/StatementHandler)的代理对象。当我们调用四大接口的方法的时候，实际上是调用代理对象的相应方法，代理对象又会调用四大接口的实例。

   Plugin对象

   我们知道，官方推荐插件实现plugin方法为：Plugin.wrap(target, this);

   publicstaticObjectwrap(Objecttarget,Interceptorinterceptor){
   //获取插件的Intercepts注解
   Map<Class<?>,Set<Method>>signatureMap=getSignatureMap(interceptor);
   Class<?>type=target.getClass();
   Class<?>[]interfaces=getAllInterfaces(type,signatureMap);
   if(interfaces.length>0){
   returnProxy.newProxyInstance(type.getClassLoader(),interfaces,newPlugin(target,interceptor,signatureMap));
   }
   returntarget;
   }
   

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

   插件配置注解@Intercepts

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

   publicObjectinvoke(Objectproxy,Methodmethod,Object[]args)throwsThrowable{
   try{
   Set<Method>methods=signatureMap.get(method.getDeclaringClass());
   if(methods!=null&&methods.contains(method)){
   returninterceptor.intercept(newInvocation(target,method,args));
   }
   returnmethod.invoke(target,args);
   }catch(Exceptione){
   throwExceptionUtil.unwrapThrowable(e);
   }
   }
   

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

   官方插件开发方式

   @Intercepts({@Signature(type=Executor.class,method="query",
   args={MappedStatement.class,Object.class,RowBounds.class,ResultHandler.class})})
   publicclassTestInterceptorimplementsInterceptor{
   publicObjectintercept(Invocationinvocation)throwsThrowable{
   Objecttarget=invocation.getTarget();//被代理对象
   Methodmethod=invocation.getMethod();//代理方法
   Object[]args=invocation.getArgs();//方法参数
   //dosomething......方法拦截前执行代码块
   Objectresult=invocation.proceed();
   //dosomething.......方法拦截后执行代码块
   returnresult;
   }
   publicObjectplugin(Objecttarget){
   returnPlugin.wrap(target,this);
   }
   }