【Mybatis】MyBatis之插件开发（十）

MyBatis插件开发原理

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

　　MyBatis在四大对象的创建过程中，都会有插件进行介入。插件可以利用动态代理机制一层层的包装目标对象，而实现目标对象在执行目标方法之前进行拦截的效果。
　　插件介入指的是：创建过程中都会涉及到调用interceptChain.pluginAll()方法对四大对象进行重新包装，返回一个代理对象。
　　MyBatis 允许在已映射语句执行过程中的某一点进行拦截调用，默认情况下，MyBatis 允许使用插件来拦截的方法调用包括：

　　1、拦截执行器的方法：Executor(update, query, flushStatements, commit, rollback, getTransaction, close, isClosed)
　　2、拦截参数的处理：ParameterHandler(getParameterObject, setParameters)
　　3、拦截结果集的处理：ResultSetHandler(handleResultSets, handleOutputParameters)
　　4、拦截Sql语法构建的处理：StatementHandler(prepare, parameterize, batch, update, query)

　　默认情况下，Mybatis允许使用插件来拦截的接口和方法包括以下几个：

　　插件开发是基于动态代理实现的，所有有必要对动态代理有所了解。

　　我们可以看一下MyBatis是怎么创建这四大接口对象的。找到源码BaseStatementHandler　　

 this.parameterHandler = configuration.newParameterHandler(mappedStatement, parameterObject, boundSql);
 this.resultSetHandler = configuration.newResultSetHandler(executor, mappedStatement, rowBounds, parameterHandler, resultHandler, boundSql);

　　进入configuration类，下面几处都是在创建newParameterHandler,ResultSetHandler,StatementHandler这几个对象，在调用的过程中，大家都看到了都使用了interceptorChain.pluginAll方法分别对每一个对象进行了重新包装并返回

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

　　点进interceptorChain.pluginAll方法里面

 /**
 *每一个拦截器对目标类都进行一次代理
 *@target
 *@return 层层代理后的对象
 **/
 public Object pluginAll(Object target) {
     for (Interceptor interceptor : interceptors) {
       target = interceptor.plugin(target);
     }
     return target;

 }

　　这一段代码可以看到：获取所有的Interceptor(拦截器)，我们如果需要自定义拦截器就得实现Interceptor这个接口。然后调用interceptor.plugin(target);返回target包装之后的对象。

　　所以，我们可以使用插件为目标对象创建一个代理对象，这Spring的AOP一样，其实都是动态代理，面向切面的编程。

MyBatis插件开发　

　　下面我们通过案例为StatementHandler创建代理对象

　　1、新建一个maven工程，引入mybatis依赖及相关数据库依赖

　　　　

　　2、新建一个MyFirstPlugin拦截器类，并且实现Interceptor接口

 package com.test.mybatis.plugin;

 import java.util.Properties;

 import org.apache.ibatis.executor.statement.StatementHandler;
 import org.apache.ibatis.plugin.Interceptor;
 import org.apache.ibatis.plugin.Intercepts;
 import org.apache.ibatis.plugin.Invocation;
 import org.apache.ibatis.plugin.Plugin;
 import org.apache.ibatis.plugin.Signature;

 /**
  * 完成插件签名：
  *        告诉MyBatis当前插件用来拦截哪个对象的哪个方法
  *    @Intercepts(org.apache.ibatis.plugin.Intercepts)和
  *    签名注解@Signature(org.apache.ibatis.plugin.Signature)，这两个注解用来配置拦截器要拦截的接口的方法。
  *
  *    @Intercepts注解中的属性是一个@Signature（签名）数组，可以在同一个拦截器中同时拦截不同的接口和方法。
  *
  *  @Signature中
  *      type：设置拦截的接口，可选值是4个：Executor、ParameterHandler、ResultSetHandler、StatementHandler
  *      method：设置拦截接口中的方法名，需要和接口匹配
  *      args：设置拦截方法的参数类型数组，通过方法名和参数类型可以确定唯一一个方法
  */
 @Intercepts(
         {
             @Signature(type=StatementHandler.class,method="parameterize",args=java.sql.Statement.class)
         })
 public class MyFirstPlugin implements Interceptor {

     /**
      * intercept：拦截： 拦截目标对象的目标方法的执行；
      */
     public Object intercept(Invocation invocation) throws Throwable {
         // TODO Auto-generated method stub
         System.out.println("MyFirstPlugin...intercept:" + invocation.getMethod());
         // 执行目标方法
         Object proceed = invocation.proceed();
         // 返回执行后的返回值
         return proceed;
     }

     /**
      * plugin： 包装目标对象的：包装：为目标对象创建一个代理对象
      */
     public Object plugin(Object target) {
         // TODO Auto-generated method stub
         // 我们可以借助Plugin的wrap方法来使用当前Interceptor包装我们目标对象
         System.out.println("MyFirstPlugin...plugin:mybatis将要包装的对象" + target);
         Object wrap = Plugin.wrap(target, this);
         // 返回为当前target创建的动态代理
         return wrap;
     }

     /**
      * setProperties：
      *         将插件注册时 的property属性设置进来
      */
     public void setProperties(Properties properties) {
         // TODO Auto-generated method stub
         System.out.println("插件配置的信息：" + properties);
     }

 }

　　3、在mybatis的全局配置文件中配置

 <!--plugins：注册插件 -->
 <plugins>
     <plugin interceptor="com.test.mybatis.plugin.MyFirstPlugin">
         <property name="username" value="root" />
         <property name="password" value="123456" />
     </plugin>
 </plugins>

　　4、编辑测试类TestMybatis.java

 public static void main(String[] args) throws IOException {

     // 获取SqlSessionFactory
     InputStream inputStream = Resources.getResourceAsStream("mybatis-config.xml");
     SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

     SqlSession session = sqlSessionFactory.openSession();
     try {
         EmployeeMapper mapper = session.getMapper(EmployeeMapper.class);

         Employee employee01 = mapper.selectByPrimaryKey(1);
         System.out.println(employee01.getId());

     } finally {
         session.close();
     }
 }

　　5、运行结果如下：

　　　　

插件开发总结

　　插件开发步骤如下

　　　　1、编写插件实现Interceptor接口，并使用@Intercepts注解完成插件签名

 @Intercepts({                                  @Signature(type=StatementHandler.class,method="parameterize",args=java.sql.Statement.class)
 })
 public class MyFirstPlugin implements Interceptor {

　　　　2、在全局配置文件中注册插件

 <!--plugins：注册插件 -->
 <plugins>
     <plugin interceptor="com.test.mybatis.plugin.MyFirstPlugin">
         <property name="username" value="root" />
         <property name="password" value="123456" />
     </plugin>
 </plugins>

　　插件的原理

　　　　按照插件注解声明，按照插件配置顺序调用插件plugin方法，生成被拦截对象的动态代理
　　　　多个插件依次生成目标对象的代理对象，层层包裹，先声明的先包裹；形成代理链
　　　　目标方法执行时依次从外到内执行插件的intercept方法

　　插件的作用　　　　

　　　　1、可以统计SQL的执行时间

　　　　2、可以进行分页操作，如插件：Mybatis-PageHelper

　　　　......