mybatis源码(十一) mybatis插件原理及其应用

mybatis源码(十一) mybatis插件原理及其应用

mybatis插件：MyBatis提供了扩展机制，能够在执行Mapper时改变SQL的执行行为。这种扩展机制是通过拦截器来实现的，用户自定义的拦截器也被称为MyBatis 插件。MyBatis框架支持对Executor、ParameterHandler、ResultSetHandler、 StatementHandler四种组件的方法进行拦截。

　　 Executor 的创建是在SqlSession创建的时候创建的

  private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
    Transaction tx = null;
    try {
      // 获取Mybatis主配置文件配置的环境信息
      final Environment environment = configuration.getEnvironment();
      // 创建事务管理器工厂
      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
      // 创建事务管理器
      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
      // 根据Mybatis主配置文件中指定的Executor类型创建对应的Executor实例
      final Executor executor = configuration.newExecutor(tx, execType);
      // 创建DefaultSqlSession实例
      return new DefaultSqlSession(configuration, executor, autoCommit);
    } catch (Exception e) {
      closeTransaction(tx); // may have fetched a connection so lets call close()
      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

　　StatementHandler 的创建是在执行sql语句前创建的，例如：

public class SimpleExecutor extends BaseExecutor {

  public SimpleExecutor(Configuration configuration, Transaction transaction) {
    super(configuration, transaction);
  }

  @Override
  public int doUpdate(MappedStatement ms, Object parameter) throws SQLException {
    Statement stmt = null;
    try {
      Configuration configuration = ms.getConfiguration();
      StatementHandler handler = configuration.newStatementHandler(this, ms, parameter, RowBounds.DEFAULT, null, null);
      stmt = prepareStatement(handler, ms.getStatementLog());
      return handler.update(stmt);
    } finally {
      closeStatement(stmt);
    }
  }

　　ParameterHandler、ResultSetHandler是在SimpleStatementHandler、PreparedStatementHandler、CallableStatementHandler的构造方法中，调用父类的构造方法实现的

  protected BaseStatementHandler(Executor executor, MappedStatement mappedStatement, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) {
    this.configuration = mappedStatement.getConfiguration();
    this.executor = executor;
    this.mappedStatement = mappedStatement;
    this.rowBounds = rowBounds;

    this.typeHandlerRegistry = configuration.getTypeHandlerRegistry();
    this.objectFactory = configuration.getObjectFactory();

    if (boundSql == null) { // issue #435, get the key before calculating the statement
      generateKeys(parameterObject);
      boundSql = mappedStatement.getBoundSql(parameterObject);
    }

    this.boundSql = boundSql;

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

　　总之，都是在执行sql前，就创建的对象

1.为什么只能拦截这四种插件呢？

　　1.mybatis可以根据用户配置的参数创建不同的实例，根据Configuration对象。（这4个组件）

　　2.mybatis通过工厂方式创建4种组件，在工厂方法中，可以执行拦截逻辑

　　Configuration类部分代码如下：

  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) {
    return newExecutor(transaction, defaultExecutorType);
  }

  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    executorType = executorType == null ? ExecutorType.SIMPLE : executorType;
    Executor executor;
    // 根据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);
    }
    // 如果cacheEnabled属性为ture，这使用CachingExecutor对上面创建的Executor进行装饰
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    // 执行拦截器链的拦截逻辑
    executor = (Executor) interceptorChain.pluginAll(executor);
    return executor;
  }

可以看到这四个方法里面，都有一个interceptorChain.pluginAll 的调用过程

pluginAll 返回ParameterHandler、ResultSetHandler、StatementHandler、Executor的代理对象

可以看下InterceptorChain 的源代码

public class InterceptorChain {

  // 通过List对象维护所有拦截器实例
  private final List<Interceptor> interceptors = new ArrayList<Interceptor>();

  // 调用所有拦截器对象的plugin（）方法执行拦截逻辑
  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);
  }

}

由上代码可以看到，mybatis的拦截器执行链中维护了一个所有拦截器的List集合。拦截器链执行的方法调用是interceptor.plugin(targer),

看下Interceptor接口，里面只有三个方法

public interface Interceptor {

  Object intercept(Invocation invocation) throws Throwable;

  Object plugin(Object target);

  void setProperties(Properties properties);

}

Interceptor接口中定义了3个方法：

　　intercept()方法用于定义拦截逻辑，该方法会在目标方法调用时执行。　　

　　plugin()方法用于创建Executor、ParameterHandler、 ResultSetHandler 或Statementh Handler的代理对象，该方法的参数即为Executor、ParameterHandler、ResultSetHandler或StatementHandler组件的实例。

　　setProperties()方法用于设置插件的属性值。

　　需要注意的是，intercept()接 收一一个Invocation对象作为参数，Invocation对象中封装了目标对象的方法及参数信息。

　　Invocation类的源代码如下：

　　Invocation类中提供了一个proceed()方法，该方法用于执行目标方法的逻辑。所以在自定义插件类中，拦截逻辑执行完毕后一般都需要调用proceed()方法执行目标方法的原有逻辑。

public class Invocation {

  // 目标对象，即ParameterHandler、ResultSetHandler、StatementHandler或者Executor实例
  private final Object target;
  // 目标方法，即拦截的方法
  private final Method method;
  // 目标方法参数
  private final 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;
  }

  /**
   * 执行目标方法
   * @return 目标方法执行结果
   * @throws InvocationTargetException
   * @throws IllegalAccessException
   */
  public Object proceed() throws InvocationTargetException, IllegalAccessException {
    return method.invoke(target, args);
  }

}

当我们自定义拦截器的时候，需要实现该接口。mybatis中提供了ExamplePlugin类，供我们参考，可以看一下源代码

@Intercepts({})
public class ExamplePlugin implements Interceptor {
  private Properties properties;
  @Override
  public Object intercept(Invocation invocation) throws Throwable {
    // TODO:自定义拦截逻辑
    return invocation.proceed();
  }

  @Override
  public Object plugin(Object target) {
    // 调用Plugin类的wrap（）方法返回一个动态代理对象
    return Plugin.wrap(target, this);
  }

  @Override
  public void setProperties(Properties properties) {
    // 设置插件的属性信息
    this.properties = properties;
  }

  public Properties getProperties() {
    return properties;
  }

}

我们深入interceptor.plugin(target);的方法，发现他调用的是Plugin.wrap(target, this); 继续深入，查看PluginPlugin的源代码如下：

public class Plugin implements InvocationHandler {

    //目标对象，即Executor、ParameterHandler、ResultSetHandler、StatementHandler对象
    private final Object target;
    // 用户自定义拦截器实例
    private final Interceptor interceptor;
    // Intercepts注解指定的方法
    private final Map<Class<?>, Set<Method>> signatureMap;

    private Plugin(Object target, Interceptor interceptor, Map<Class<?>, Set<Method>> signatureMap) {
        this.target = target;
        this.interceptor = interceptor;
        this.signatureMap = signatureMap;
    }

    /**
     * wrap()方法的第一个参数为目标对象，即Executor、ParameterHandler、 ResultSetHandler、 StatementHandler类的实例;
     * 第二个参数为拦截器实例。在wrap()方法中首先调用getSignatureMap()方法获取Intercepts注解指定的要拦截的组件及方法，
     * 然后调用getAllInterfaces()方法获取当前Intercepts注解指定要拦截的组件的接口信息，接着调用Proxy类的静态方法
     * newProxyInstance()创建一个动态代理对象。
     * 该方法用于创建Executor、ParameterHandler、ResultSetHandler、StatementHandler的代理对象
     *
     * @param target
     * @param interceptor
     * @return
     */
    public static Object wrap(Object target, Interceptor interceptor) {

        // 调用getSignatureMap（）方法获取自定义插件中，通过Intercepts注解指定的方法
        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类的invoke()方法会在调用目标对象的方法时执行，在invoke()方法中首先判断该方法是否被Intercepts注解指定为被拦截的方法，如果是，则调用用户自定义
     * 拦截器的intercept()方法，并把目标方法信息封装成Invocation对象作为intercept()方法的参数。
     *
     * @param proxy
     * @param method
     * @param args
     * @return
     * @throws Throwable
     */
    @Override
    public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
        try {
            // 如果该方法是Intercepts注解指定的方法，则调用拦截器实例的intercept（）方法执行拦截逻辑
            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);
        }
    }

    /**
     * Plugin类的getSignatureMap()方法中，首先获取Intercepts注解，然后获取Intercepts注解中配置的所有Signature注解，接着对所有的Signature注解信息进行遍历，
     * 将Signature注解中指定要拦截的组件及方法添加到Map对象中，其中
     * Key为Executor、 ParameterHandler、ResultSetHandler或StatementHandler对应的Class对象，Value为拦截的所有方法对应的Method对象数组。
     *
     * @param interceptor
     * @return
     */
    private static Map<Class<?>, Set<Method>> getSignatureMap(Interceptor interceptor) {
        // 获取Intercepts注解信息
        Intercepts interceptsAnnotation = interceptor.getClass().getAnnotation(Intercepts.class);
        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<Class<?>, Set<Method>>();
        // 对所有Signature注解进行遍历，把Signature注解指定拦截的组件及方法添加到Map中
        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;
    }

    /**
     * 获取目标类型的接口信息
     *
     * @param type
     * @param signatureMap
     * @return
     */
    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()]);
    }

}　

由上述代码，发现Plugin，实现了InvocationHandler 即JDK内置的动态代理方式创建代理对象，同时使用Proxy.newProxyInstance返回了代理对象。

如上面的代码所示，wrap()方法的第一个参数为目标对象，即Executor、ParameterHandler、 ResultSetHandler、 StatementHandler类的实例;第二个参数为拦截器实例。在wrap()方法中首先调用
getSignatureMap()方法获取Intercepts注解指定的要拦截的组件及方法，然后调用getAllInterfaces()方法获取当前Intercepts注解指定要拦截的组件的接口信息，接着调用Proxy类的静态方法
newProxyInstance()创建一个动态代理对象。

2.自定义mybatis插件

　　2.1mybatis自定义插件，都必须实现Interceptor接口，并在intercept()中编写拦截逻辑

　　2.2 拦截器上面要添加@Intercepts注解，标注拦截器的类型和拦截的方法

　　例如：

@Intercepts({
        @Signature(method = "prepare", type = StatementHandler.class, args = {Connection.class, Integer.class})
})
public class PageInterceptor implements Interceptor {

　　2.3 通过plugin()方法返回一个动态代理对象　　

　　例如：

    /**
     * 拦截器对应的封装原始对象的方法
     */
    public Object plugin(Object target) {
        return Plugin.wrap(target, this);
    }

 

　　2.4通过setProperties方法设置Plugin标签中配置的属性值

　　例如：

 

    /**
     * 设置注册拦截器时设定的属性
     */
    public void setProperties(Properties properties) {
        this.databaseType = properties.getProperty("databaseType");
    }

 

　　2.5 mybaits提供了ExamplePlugin的例子供参考

@Intercepts({})
public class ExamplePlugin implements Interceptor {
  private Properties properties;
  @Override
  public Object intercept(Invocation invocation) throws Throwable {
    // TODO:自定义拦截逻辑
    return invocation.proceed();
  }

  @Override
  public Object plugin(Object target) {
    // 调用Plugin类的wrap（）方法返回一个动态代理对象
    return Plugin.wrap(target, this);
  }

  @Override
  public void setProperties(Properties properties) {
    // 设置插件的属性信息
    this.properties = properties;
  }

  public Properties getProperties() {
    return properties;
  }

}

3.mybatis插件加载的地方

　　3.1 在mybatis的plugins标签下面，配置要加载的插件
　　

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
    PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
    "http://mybatis.org/dtd/mybatis-3-config.dtd">

<configuration>
  <settings>
     <setting name="useGeneratedKeys" value="true"/>
  </settings>
 
// 配置插件
  <plugins>
    <plugin interceptor="com.blog4java.plugin.pager.PageInterceptor">
       <property name="databaseType" value="hsqldb"/>
    </plugin>

    <plugin interceptor="com.blog4java.plugin.slowsql.SlowSqlInterceptor">
       <property name="limitSecond" value="0"/>
    </plugin>
  </plugins>

  <environments default="dev" >
     <environment id="dev">
       <transactionManager type="JDBC">
          <property name="" value="" />
       </transactionManager>
       <dataSource type="UNPOOLED">
          <property name="driver" value="org.hsqldb.jdbcDriver" />
          <property name="url" value="jdbc:hsqldb:mem:mybatis" />
          <property name="username" value="sa" />
          <property name="password" value="" />
       </dataSource>
     </environment>
     <environment id="qa">
       <transactionManager type="JDBC">
          <property name="" value="" />
       </transactionManager>
       <dataSource type="UNPOOLED">
          <property name="driver" value="org.hsqldb.jdbcDriver" />
          <property name="url" value="jdbc:hsqldb:mem:mybatis_qa" />
          <property name="username" value="admin" />
          <property name="password" value="admin" />
       </dataSource>
     </environment>
  </environments>

  <mappers>
     <mapper resource="com/blog4java/mybatis/example/mapper/UserMapper.xml"/>
  </mappers>
</configuration>

 

　　3.2 从XmlConfigBuilder类开始解析mybaits-config的主配置文件

　　首先调用XmlConfigBuilder.parse()方法　

  public Configuration parse() {
    // 防止parse（）方法被同一个实例多次调用
    if (parsed) {
      throw new BuilderException("Each XMLConfigBuilder can only be used once.");
    }
    parsed = true;
    // 调用XPathParser.evalNode（）方法，创建表示configuration节点的XNode对象。
    // 调用parseConfiguration（）方法对XNode进行处理
    parseConfiguration(parser.evalNode("/configuration"));
    return configuration;
  }

 

　　然后调用parseConfiguration 解析<configuration>标签

　　

  private void parseConfiguration(XNode root) {
    try {
      //issue #117 read properties first
      propertiesElement(root.evalNode("properties"));
      Properties settings = settingsAsProperties(root.evalNode("settings"));
      loadCustomVfs(settings);
      typeAliasesElement(root.evalNode("typeAliases"));
      pluginElement(root.evalNode("plugins"));
      objectFactoryElement(root.evalNode("objectFactory"));
      objectWrapperFactoryElement(root.evalNode("objectWrapperFactory"));
      reflectorFactoryElement(root.evalNode("reflectorFactory"));
      settingsElement(settings);
      // read it after objectFactory and objectWrapperFactory issue #631
      environmentsElement(root.evalNode("environments"));
      databaseIdProviderElement(root.evalNode("databaseIdProvider"));
      typeHandlerElement(root.evalNode("typeHandlers"));
      mapperElement(root.evalNode("mappers"));
    } catch (Exception e) {
      throw new BuilderException("Error parsing SQL Mapper Configuration. Cause: " + e, e);
    }
  }

　然后调用pluginElement(root.evalNode("plugins")); 解析mybatis主配置文件下面的plugins标签

    private void pluginElement(XNode parent) throws Exception {
    if (parent != null) {
      for (XNode child : parent.getChildren()) {
        // 获取<plugin>标签的interceptor属性
        String interceptor = child.getStringAttribute("interceptor");
        // 获取拦截器属性，转换为Properties对象
        Properties properties = child.getChildrenAsProperties();
        // 创建拦截器实例
        Interceptor interceptorInstance = (Interceptor) resolveClass(interceptor).newInstance();
        // 设置拦截器实例属性信息
        interceptorInstance.setProperties(properties);
        // 將拦截器实例添加到拦截器链中
        configuration.addInterceptor(interceptorInstance);
      }
    }
  }

由上代码可以看出，循环解析<plugins>标签下面的每一个<plugin> ,然后创建拦截器添加到集合中

Configuration.addInterceptor(interceptorInstance) 的源码如下：

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

刚才说过，interceptorChain内部维护了一个List集合，用来存储拦截器　　

4.Mybatis插件创建动态代理对象的工作原理

　　以执行一个查询操作为例，SqlSession是MyBatis中提供的面向用户的操作数据库的接口，而真正执行SQL操作的是Executor组件。MyBatis通过工厂模式创建Executor实例，
Configuration类中提供了一个newExecutor()工厂 方法，该方法返回的实际上是一个Executor的动态代理对象。
SqlSession获取Executor实例的过程如下:
　　(1) SqlSession中会调用Configuration类提供的newExecutor()工厂方法创建Executor对象。
　　(2) Configuration类中通过一个InterceptorChain对象维护了用户自定义的拦截器链。newExecutor()工厂方法中调用InterceptorChain对象的pluginAll()方法。
　　(3) InterceptorChain对象 的pluginAll()方法中会调用自定义拦截器的plugin()方法。
　　(4)自定义拦截器的plugin()方法是由我们来编写的，通常会调用Plugin类的wrap()静态方法创建一个代理对象。

　　　　　　　　　　　　　　　　　　　　mybatis动态代理对象创建过程

Sq|Session获取到的Executor实例实际上已经是一个动态代理对象了。当我们调用SqlSession对象的selectOne()方法执行查询操作时，大致会经历下面几个过程:
　　(1)SqlSession操作数据库需要依赖于Executor组件，SqlSession会调用Configuration对象的newExecutor()方法获取Executor的实例。
　　(2) SqlSession获取到的是Executor组件的代理对象，执行查询操作时会调用代理对象的query()方法。
　　(3)按照JDK动态代理机制，调用Executor代理对象的query()方法时，会调用Plugin类的invoke()方法。
　　(4) Plugin类的invoke()方法中会调用自定义拦截器对象的intercept()方法执行拦截逻辑。
　　(5)自定义拦截器对象的intercept()方法调用完毕后，调用目标Executor对象的query()方法。
　　(6)所有操作执行完毕后，会将查询结果返回给SqlSession对象。

 　　　　　　　　　　　　　　　　　　　　mybatis插件拦截逻辑执行过程