MyBATIS原理第三篇: SqlSession下的四大对象之一——执行器（executor）

来源：互联网发布：最终幻想mac版编辑：程序博客网时间：2024/06/05 03:06

首先我先解释一下标题四大对象是指：executor, statementHandler,parameterHandler，resultHandler对象。（为了方便下面的文章说道四大对象就专指它们）

它们都是sqlSession的底层类实现，也是插件能够拦截的四大对象。所以这里已经触及了MyBATIS的底层，动态代理，反射随时可以看到，如果没有第一篇作为基础，你将十分难以理解它。了解他们的协作，是插件编写的基础之一，所以这是十分的重要。

Executor在sqlSession中的应用

上篇我们谈到了一个问题，一个mapper被执行是通过动态代理来完成的，然后进入到了sqlSession的方法中去。这个并不难理解，但是sqlSession内部是怎么运行的呢?答案四大对象的协作。在SqlSession它还是一个接口，mybatis内部是通过DefaultSqlSession这个实现类为我们提供服务的,它比较长，但是我们不需要全部看到，我们只看到很常用的selectList方法便可以了。

[java] view plain copy
package org.apache.ibatis.session.defaults;  
public class DefaultSqlSession implements SqlSession {  
  
  private Configuration configuration;  
  private Executor executor;  
  
  private boolean autoCommit;  
  private boolean dirty;  
  
.......  
@Override  
  public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {  
    try {  
      MappedStatement ms = configuration.getMappedStatement(statement);  
      return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);  
    } catch (Exception e) {  
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);  
    } finally {  
      ErrorContext.instance().reset();  
    }  
  }  
......  
}  

我们可以看到它是通过executor去执行方法来完成查询的。

初认Executor

那么我们对executor就很感兴趣，于是我们看看executor是怎么样的，首先在MyBATIS中有三种executor:

SimpleExecutor -- SIMPLE 就是普通的执行器。

ReuseExecutor -执行器会重用预处理语句（prepared statements）

BatchExecutor --它是批量执行器

这些就是mybatis的三种执行器。你可以通过配置文件的settings里面的元素defaultExecutorType，配置它，默认是采用SimpleExecutor如果你在Spring运用它，那么你可以这么配置它：

[html] view plain copy
<bean id="sqlSessionTemplateBatch" class="org.mybatis.spring.SqlSessionTemplate">       
<constructor-arg index="0" ref="sqlSessionFactory" />    
<!--更新采用批量的executor -->    
<constructor-arg index="1" value="BATCH"/>    
</bean>    

这样，它便是一个批量的执行器。mybatis的三个executor都有一个共同的父类——BaseExecutor。

Executor初始化

首先我们先了解一下mybatis是怎么样生成executor的。我们看到生成Executor的地方(org.apache.ibatis.session.Configuration)：

[java] view plain copy
public Executor newExecutor(Transaction transaction, ExecutorType executorType) {  
    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);  
    }  
    executor = (Executor) interceptorChain.pluginAll(executor);  
    return executor;  
  }  

这里大部分都很好理解，但是有个地方就好不好理解，它就是：

[java] view plain copy
executor = (Executor) interceptorChain.pluginAll(executor);  

这是一段非常重要的代码，它是采用责任链模式，来产生代理对象。我们需要再深入理解它，打开它具体的pluginAll方法：

[java] view plain copy
public Object pluginAll(Object target) {  
    for (Interceptor interceptor : interceptors) {  
      target = interceptor.plugin(target);  
    }  
    return target;  
  }  

我们这里先介绍一下这段代码：

Interceptor它是mybatis拦截器必须要实现的接口，换句话说，这个遍历就是遍历mybatis的拦截器。

然后调用plugin方法，这个方法是为了生成代理对象（占位）的。

于是可以想象我们的插件的代理对象将会是一层层的嵌套，所以当中任何一个插件（Interceptor）都有机会拦截这个真是的服务对象(executor)，则便是责任链模式，我们完全可以提供插件（Interceptor），进入到代理对象的invoke方法里面，来改变executor的行为和方法。

但是我要在这里强调，当你使用插件的时候，你将改变mybatis的executor内容实现，你必须慎重的使用它。

如果要我们自己编写动态的代理，那么工作量可不小，好在mybatis为我们提供了Plugin.java类来完成我们所需要的功能。

[java] view plain copy
public class Plugin implements InvocationHandler {  
  
  private Object target;  
  private Interceptor interceptor;  
  private 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;  
  }  
  
  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;  
  }  
    
  @Override  
  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);  
    }  
  }  
 ......  
}  

这里有一个wrap方法：它会为我们生成代理对象。一旦我们的插件和它绑定，那么我们可以想到就会进入invoke方法里面。

invoke方法：很简单，它运行首先通过class和method的过滤，看看是否需要拦截这个方法，如果被拦截，那么它就运行interceptor的intercept方法。所以当我们配置了签名，就能够拦截我们的方法。

我们先讨论那么多，我们知道后面讲插件的时候我们还会提及它，这里我们知道它会根据插件的个数生成一层层的代理对象就可以了。

executor的执行

executor的执行是依赖于Statement对象来操作的，让我们以SimpleExecutor的doQuery方法为例子：

[java] view plain copy
public class SimpleExecutor extends BaseExecutor {  
......  
    
  @Override  
  public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {  
    Statement stmt = null;  
    try {  
      Configuration configuration = ms.getConfiguration();  
      StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);  
      stmt = prepareStatement(handler, ms.getStatementLog());  
      return handler.<E>query(stmt, resultHandler);  
    } finally {  
      closeStatement(stmt);  
    }  
  }  
  
  ......  
  private Statement prepareStatement(StatementHandler handler, Log statementLog) throws SQLException {  
    Statement stmt;  
    Connection connection = getConnection(statementLog);  
    stmt = handler.prepare(connection);  
    handler.parameterize(stmt);  
    return stmt;  
  }  
  
}  

很显然这里调度的是一个查询方法

首先它先生成StatementHandler对象。

通过prepareStatement方法调用prepare方法初始化参数。

然后使用parameterize方法设置参数到运行环境。

然后便通过handler.<E>query(stmt, resultHandler);方法来完成结果组装。

于是我们的焦点就集中在了StatementHandler对象上，下章我们将谈及它。

http://blog.csdn.net/ykzhen2015/article/details/50315027

阅读全文

0 0