《深入理解Mybatis原理》MyBatis的sqlSession执行流程

sqlSessionFactory 与 SqlSession

正如其名，Sqlsession对应着一次数据库会话。由于数据库会话不是永久的，因此Sqlsession的生命周期也不应该是永久的，相反，在你每次访问数据库时都需要创建它（当然并不是说在Sqlsession里只能执行一次sql，你可以执行多次，当一旦关闭了Sqlsession就需要重新创建它）。
那么咱们就先看看是怎么获取SqlSession的吧：

首先，SqlSessionFactoryBuilder去读取mybatis的设置文件，然后build一个DefaultSqlSessionFactory。源码如下：

1. /**
2.   * 一系列的构造方法最终都会调用本方法（配置文件为Reader时会调用本方法，还有一个InputStream方法与此对应）
3.   * @param reader
4.   * @param environment
5.   * @param properties
6.   * @return
7.   */
8. public SqlSessionFactory build(Reader reader, String environment, Properties properties) {
9.    try {
10.      //通过XMLConfigBuilder解析配置文件，解析的配置相关信息都会封装为一个Configuration对象
11.      XMLConfigBuilder parser = new XMLConfigBuilder(reader, environment, properties);
12.      //这儿创建DefaultSessionFactory对象
13.      return build(parser.parse());
14.    } catch (Exception e) {
15.      throw ExceptionFactory.wrapException("Error building SqlSession.", e);
16.    } finally {
17.      ErrorContext.instance().reset();
18.      try {
19.        reader.close();
20.      } catch (IOException e) {
21.        // Intentionally ignore. Prefer previous error.
22.      }
23.    }
24. }
26. public SqlSessionFactory build(Configuration config) {
27.    return new DefaultSqlSessionFactory(config);
28. }

复制代码

当我们获取到SqlSessionFactory之后，就可以通过SqlSessionFactory去获取SqlSession对象。源码如下：

1. /**
2.   * 通常一系列openSession方法最终都会调用本方法
3.   * @param execType
4.   * @param level
5.   * @param autoCommit
6.   * @return
7.   */
8. private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {
9.    Transaction tx = null;
10.    try {
11.      //通过Confuguration对象去获取Mybatis相关配置信息, Environment对象包含了数据源和事务的配置
12.      final Environment environment = configuration.getEnvironment();
13.      final TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);
14.      tx = transactionFactory.newTransaction(environment.getDataSource(), level, autoCommit);
15.      //之前说了，从表面上来看，咱们是用sqlSession在执行sql语句， 实际呢，其实是通过excutor执行， excutor是对于Statement的封装
16.      final Executor executor = configuration.newExecutor(tx, execType);
17.      //关键看这儿，创建了一个DefaultSqlSession对象
18.      return new DefaultSqlSession(configuration, executor, autoCommit);
19.    } catch (Exception e) {
20.      closeTransaction(tx); // may have fetched a connection so lets call close()
21.      throw ExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);
22.    } finally {
23.      ErrorContext.instance().reset();
24.    }
25. }

复制代码

通过以上步骤，咱们已经得到SqlSession对象了。接下来就是该干嘛干嘛去了（话说还能干嘛，当然是执行sql语句咯）。看了上面，咱们也回想一下之前写的Demo：

1. SqlSessionFactory sessionFactory = null;  
2. String resource = "mybatis-conf.xml";  
3. try {
4.     //SqlSessionFactoryBuilder读取配置文件
5.    sessionFactory = new SqlSessionFactoryBuilder().build(Resources.getResourceAsReader(resource));
6. } catch (IOException e) {  
7.    e.printStackTrace();  
8. }   
9. //通过SqlSessionFactory获取SqlSession
10. SqlSession sqlSession = sessionFactory.openSession();

复制代码

创建Sqlsession的地方只有一个，那就是SqlsessionFactory的openSession方法：

1. public SqlSessionopenSession() {  
2.     return openSessionFromDataSource(configuration.getDefaultExecutorType(),null, false);  
3. }

复制代码

我们可以看到现实创建SqlSession的地方是openSessionFromDataSource，如下：

1. private SqlSession openSessionFromDataSource(ExecutorType execType, TransactionIsolationLevel level, boolean autoCommit) {  
3.     Connection connection = null;  
5.     try {  
7.         final Environment environment = configuration.getEnvironment();  
9.         final DataSource dataSource = getDataSourceFromEnvironment(environment);  
10.         
11.         // MyBatis对事务的处理相对简单，TransactionIsolationLevel中定义了几种隔离级别，并不支持内嵌事务这样较复杂的场景，同时由于其是持久层的缘故，所以真正在应用开发中会委托Spring来处理事务实现真正的与开发者隔离。分析事务的实现是个入口，借此可以了解不少JDBC规范方面的事情。
12.         TransactionFactory transactionFactory = getTransactionFactoryFromEnvironment(environment);  
14.         connection = dataSource.getConnection();  
16.         if (level != null) {  
17.             connection.setTransactionIsolation(level.getLevel());
18.         }  
20.         connection = wrapConnection(connection);  
22.         Transaction tx = transactionFactory.newTransaction(connection,autoCommit);  
24.         Executorexecutor = configuration.newExecutor(tx, execType);  
26.         return newDefaultSqlSession(configuration, executor, autoCommit);  
28.     } catch (Exceptione) {  
29.         closeConnection(connection);  
30.         throwExceptionFactory.wrapException("Error opening session.  Cause: " + e, e);  
31.     } finally {
32.         ErrorContext.instance().reset();
33.     }
34. }  

复制代码

可以看出，创建sqlsession颠末了以下几个主要步骤：

• 从设置中获取Environment；
  
• 从Environment中取得DataSource；
  
• 从Environment中取得TransactionFactory；
  
• 从DataSource里获取数据库连接对象Connection；
  
• 在取得的数据库连接上创建事务对象Transaction；
  
• 创建Executor对象（该对象非常重要，事实上sqlsession的全部操作都是通过它完成的）；
  
• 创建sqlsession对象。
  

SqlSession咱们也拿到了，咱们可以调用SqlSession中一系列的select..., insert..., update..., delete...方法轻松自如的进行CRUD操作了。就这样？那咱设置的映射文件去哪儿了？别急，咱们接着往下看。
MapperProxy

在mybatis中，通过MapperProxy动态代理咱们的dao， 也就是说， 当咱们执行自己写的dao里面的方法的时候，实在是对应的mapperProxy在代理。那么，咱们就看看怎么获取MapperProxy对象吧：
通过SqlSession从Configuration中获取。源码如下：

1. /**
2.   * 什么都不做，直接去configuration中找
3.   */
4. @Override
5. public <T> T getMapper(Class<T> type) {
6.    return configuration.<T>getMapper(type, this);
7. }

复制代码

SqlSession把包袱甩给了Configuration, 接下来就看看Configuration。源码如下：

1. public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
2.    return mapperRegistry.getMapper(type, sqlSession);
3. }

复制代码

接着调用了MapperRegistry，源码如下：

1. @SuppressWarnings("unchecked")
2. public <T> T getMapper(Class<T> type, SqlSession sqlSession) {
3.    //交给MapperProxyFactory去做
4.    final MapperProxyFactory<T> mapperProxyFactory = (MapperProxyFactory<T>) knownMappers.get(type);
5.    if (mapperProxyFactory == null) {
6.      throw new BindingException("Type " + type + " is not known to the MapperRegistry.");
7.    }
8.    try {
9.      //关键在这儿
10.      return mapperProxyFactory.newInstance(sqlSession);
11.    } catch (Exception e) {
12.      throw new BindingException("Error getting mapper instance. Cause: " + e, e);
13.    }
14. }

复制代码

MapperProxyFactory源码：

1.   @SuppressWarnings("unchecked")
2. protected T newInstance(MapperProxy<T> mapperProxy) {
3.    //动态代理dao接口
4.    return (T) Proxy.newProxyInstance(mapperInterface.getClassLoader(), new Class[] { mapperInterface }, mapperProxy);
5. }
7. public T newInstance(SqlSession sqlSession) {
8.    final MapperProxy<T> mapperProxy = new MapperProxy<T>(sqlSession, mapperInterface, methodCache);
9.    return newInstance(mapperProxy);
10. }

复制代码

通过以上的动态代理，咱们就可以方便地使用dao接口啦， 就像之前咱们写的demo那样：

1. UserDao userMapper = sqlSession.getMapper(UserDao.class);  
2. User insertUser = new User();

复制代码

这下方便多了吧， 呵呵， 貌似mybatis的源码就这么一回事儿啊。具体详细先容，请拜见MyBatis Mapper 接口如何通过JDK动态代理来包装SqlSession 源码分析。别急，还没完， 咱们还没看具体是怎么执行sql语句的呢。
Excutor

Executor与Sqlsession的关系就像市长与书记，Sqlsession只是个门面，真正干事的是Executor，Sqlsession对数据库的操作都是通过Executor来完成的。与Sqlsession一样，Executor也是动态创建的：

• Executor创建的源代码：
  

1. public Executor newExecutor(Transaction transaction, ExecutorType executorType) {  
3.     executorType = executorType == null ? defaultExecutorType : executorType;  
5.     executorType = executorType == null ?ExecutorType.SIMPLE : executorType;  
7.     Executor executor;  
9.     if(ExecutorType.BATCH == executorType) {
10.         executor = new BatchExecutor(this,transaction);
11.     } else if(ExecutorType.REUSE == executorType) {
12.         executor = new ReuseExecutor(this,transaction);  
13.     } else {  
14.         executor = newSimpleExecutor(this, transaction);
15.     }
17.     if (cacheEnabled) {
18.         executor = new CachingExecutor(executor);  
19.     }
20.     executor = (Executor) interceptorChain.pluginAll(executor);  
21.     return executor;  
22. }  

复制代码

可以看出，

• 如果不开启cache的话，创建的Executor是3种基础类型之一
  
  
  
  • BatchExecutor专门用于执行批量sql操作
    
  • ReuseExecutor会重用statement执行sql操作
    
  • SimpleExecutor只是简单执行sql没有什么特别的
    
  
  
• 开启cache的话（默认是开启的并且没有任何来由去关闭它），就会创建CachingExecutor，它从前面创建的Executor作为唯一参数。CachingExecutor在查询数据库前先查找缓存，若没找到的话调用delegate（就是构造时传入的Executor对象）从数据库查询，并将查询结果存入缓存中。
  

Executor对象是可以被插件拦截的，如果界说了针对Executor类型的插件，终极天生的Executor对象是被各个插件插入后的代理对象。
接下来，去看sql的执行过程。上面，拿到了MapperProxy, 每个MapperProxy对应一个dao接口， 那么在使用的时候，MapperProxy是怎么做的呢？

• MapperProxy
  

我们知道对被代理对象的方法的访问都会落实到代理者的invoke上来，MapperProxy的invoke如下：

1.   /**
2.    * MapperProxy在执行时会触发此方法
3.    */
4.   @Override
5.   public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
6.     if (Object.class.equals(method.getDeclaringClass())) {
7.       try {
8.         return method.invoke(this, args);
9.       } catch (Throwable t) {
10.         throw ExceptionUtil.unwrapThrowable(t);
11.       }
12.     }
13.     final MapperMethod mapperMethod = cachedMapperMethod(method);
14.     //二话不说，主要交给MapperMethod自己去管
15.     return mapperMethod.execute(sqlSession, args);
16.   }

复制代码

• MapperMethod
  

就像是一个分发者，他根据参数和返回值类型选择差别的sqlsession方法来执行。这样mapper对象与sqlsession就真正的关联起来了。

1.   /**
2.    * 看着代码不少，不过其实就是先判断CRUD类型，然后根据类型去选择到底执行sqlSession中的哪个方法，绕了一圈，又转回sqlSession了
3.    * @param sqlSession
4.    * @param args
5.    * @return
6.    */
7.   public Object execute(SqlSession sqlSession, Object[] args) {
8.     Object result;
9.     if (SqlCommandType.INSERT == command.getType()) {
10.       Object param = method.convertArgsToSqlCommandParam(args);
11.       result = rowCountResult(sqlSession.insert(command.getName(), param));
12.     } else if (SqlCommandType.UPDATE == command.getType()) {
13.       Object param = method.convertArgsToSqlCommandParam(args);
14.       result = rowCountResult(sqlSession.update(command.getName(), param));
15.     } else if (SqlCommandType.DELETE == command.getType()) {
16.       Object param = method.convertArgsToSqlCommandParam(args);
17.       result = rowCountResult(sqlSession.delete(command.getName(), param));
18.     } else if (SqlCommandType.SELECT == command.getType()) {
19.       if (method.returnsVoid() && method.hasResultHandler()) {
20.         executeWithResultHandler(sqlSession, args);
21.         result = null;
22.       } else if (method.returnsMany()) {
23.         result = executeForMany(sqlSession, args);
24.       } else if (method.returnsMap()) {
25.         result = executeForMap(sqlSession, args);
26.       } else {
27.         Object param = method.convertArgsToSqlCommandParam(args);
28.         result = sqlSession.selectOne(command.getName(), param);
29.       }
30.     } else {
31.       throw new BindingException("Unknown execution method for: " + command.getName());
32.     }
33.     if (result == null && method.getReturnType().isPrimitive() && !method.returnsVoid()) {
34.       throw new BindingException("Mapper method '" + command.getName()
35.           + " attempted to return null from a method with a primitive return type (" + method.getReturnType() + ").");
36.     }
37.     return result;
38.   }

复制代码

既然又回到SqlSession了，前面提到过，sqlsession只是一个门面，真正发挥作用的是executor，对sqlsession方法的访问终极都会落到executor的相应方法上去。Executor分成两大类，一类是CacheExecutor，另一类是普通Executor。Executor的创建前面已经先容了，那么咱们就看看SqlSession的CRUD方法了，为了省事，还是就选择其中的一个方法来做分析吧。这儿，咱们选择了selectList方法：

1.   public <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds) {
2.     try {
3.       MappedStatement ms = configuration.getMappedStatement(statement);
4.       //CRUD实际上是交给Excetor去处理， excutor其实也只是穿了个马甲而已，小样，别以为穿个马甲我就不认识你嘞！
5.       return executor.query(ms, wrapCollection(parameter), rowBounds, Executor.NO_RESULT_HANDLER);
6.     } catch (Exception e) {
7.       throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
8.     } finally {
9.       ErrorContext.instance().reset();
10.     }
11.   }

复制代码

• CacheExecutor
  

CacheExecutor有一个重要属性delegate，它生存的是某类普通的Executor，值在构照时传入。执行数据库update操作时，它直接调用delegate的update方法，执行query方法时先实验从cache中取值，取不到再调用delegate的查询方法，并将查询结果存入cache中。代码如下：

1. public List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds,ResultHandler resultHandler) throws SQLException {  
2.     if (ms != null) {  
3.         Cache cache = ms.getCache();  
4.         if (cache != null) {  
5.             flushCacheIfRequired(ms);  
6.             cache.getReadWriteLock().readLock().lock();  
7.             try {  
8.                 if (ms.isUseCache() && resultHandler ==null) {  
9.                     CacheKey key = createCacheKey(ms, parameterObject, rowBounds);  
10.                     final List cachedList = (List)cache.getObject(key);  
11.                     if (cachedList != null) {  
12.                         return cachedList;  
13.                     } else {  
14.                         List list = delegate.query(ms,parameterObject, rowBounds, resultHandler);  
15.                         tcm.putObject(cache,key, list);  
16.                         return list;  
17.                     }  
18.                 } else {  
19.                     return delegate.query(ms,parameterObject, rowBounds, resultHandler);  
20.                 }  
21.             } finally {  
22.                 cache.getReadWriteLock().readLock().unlock();  
23.             }
24.         }  
25.     }  
26.     return delegate.query(ms,parameterObject, rowBounds, resultHandler);  
27. }

复制代码

• 普通Executor
  

有3类，他们都继续于BaseExecutor

• BatchExecutor专门用于执行批量sql操作
  
• ReuseExecutor会重用statement执行sql操作
  
• SimpleExecutor只是简单执行sql没有什么特别的
  

下面以SimpleExecutor为例：

1. public List doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds,ResultHandler resultHandler) throws SQLException {  
2.     Statement stmt = null;  
3.     try {  
4.         Configuration configuration = ms.getConfiguration();  
5.         StatementHandler handler = configuration.newStatementHandler(this, ms,parameter, rowBounds,resultHandler);  
6.         stmt =prepareStatement(handler);  
7.         returnhandler.query(stmt, resultHandler);  
8.     } finally {  
9.         closeStatement(stmt);  
10.     }  
11. }

复制代码

然后，通过一层一层的调用，终极会来到doQuery方法， 这儿咱们就随便找个Excutor看看doQuery方法的实现吧，我这儿选择了SimpleExecutor:

1.   public <E> List<E> doQuery(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, BoundSql boundSql) throws SQLException {
2.     Statement stmt = null;
3.     try {
4.       Configuration configuration = ms.getConfiguration();
5.       StatementHandler handler = configuration.newStatementHandler(wrapper, ms, parameter, rowBounds, resultHandler, boundSql);
6.       stmt = prepareStatement(handler, ms.getStatementLog());
7.       //StatementHandler封装了Statement, 让 StatementHandler 去处理
8.       return handler.<E>query(stmt, resultHandler);
9.     } finally {
10.       closeStatement(stmt);
11.     }
12.   }

复制代码

Mybatis内置的ExecutorType有3种，默认的是simple，该模式下它为每个语句的执行创建一个新的预处置惩罚语句，单条提交sql；而batch模式重复使用已经预处置惩罚的语句， 并且批量执行全部更新语句，显然batch性能将更优；
但batch模式也有自己的问题，好比在Insert操作时，在事务没有提交之前，是没有办法获取到自增的id，这在某型情况下是不符合业务要求的；
通过走码和研读spring相干文件发现，在同一事务中batch模式和simple模式之间无法转换，由于本项目一开始选择了simple模式，所以碰到需要批量更新时，只能在单独的事务中进行；
在代码中使用batch模式可以使用以下方式：

1. //从spring注入原有的sqlSessionTemplate
2. @Autowired
3. private SqlSessionTemplate sqlSessionTemplate;
5. public void testInsertBatchByTrue() {
6.     //新获取一个模式为BATCH，自动提交为false的session
7.     //如果自动提交设置为true,将无法控制提交的条数，改为最后统一提交，可能导致内存溢出
8.     SqlSession session = sqlSessionTemplate.getSqlSessionFactory().openSession(ExecutorType.BATCH, false);
9.     //通过新的session获取mapper
10.     fooMapper = session.getMapper(FooMapper.class);
11.     int size = 10000;
12.     try {
13.         for (int i = 0; i < size; i++) {
14.             Foo foo = new Foo();
15.             foo.setName(String.valueOf(System.currentTimeMillis()));
16.             fooMapper.insert(foo);
17.             if (i % 1000 == 0 || i == size - 1) {
18.                 //手动每1000个一提交，提交后无法回滚
19.                 session.commit();
20.                 //清理缓存，防止溢出
21.                 session.clearCache();
22.             }
23.         }
24.     } catch (Exception e) {
25.         //没有提交的数据可以回滚
26.         session.rollback();
27.     } finally {
28.         session.close();
29.     }
30. }

复制代码

上述代码没有使用spring的事务，改手动控制，如果和原spring事务一起使用，将无法回滚，必须留意，最好单独使用；
StatementHandler

可以看出，Executor本质上也没有进行处置惩罚，具体的事情原来是StatementHandler来完成的。当Executor将指挥棒交给StatementHandler后，接下来的工作就是StatementHandler的事了。我们先看看StatementHandler是如何创建的：

1. public StatementHandler newStatementHandler(Executor executor, MappedStatementmappedStatement,  
2.         ObjectparameterObject, RowBounds rowBounds, ResultHandler resultHandler) {  
3.     StatementHandler statementHandler = new RoutingStatementHandler(executor, mappedStatement,parameterObject,rowBounds, resultHandler);  
4.     statementHandler = (StatementHandler) interceptorChain.pluginAll(statementHandler);  
5.     return statementHandler;
6. }  

复制代码

可以看到每次创建的StatementHandler都是RoutingStatementHandler，它只是一个分发者，他一个属性delegate用于指定用哪种具体的StatementHandler。可选的StatementHandler有SimpleStatementHandler、PreparedStatementHandler和CallableStatementHandler三种。选用哪种在mapper设置文件的每个statement里指定，默认的是PreparedStatementHandler。同时还要留意到StatementHandler是可以被拦截器拦截的，和Executor一样，被拦截器拦截后的对像是一个代理对象。由于mybatis没有实现数据库的物理分页，众多物理分页的实现都是在这个地方使用拦截器实现的，本文作者也实现了一个分页拦截器，在后续的章节会分享给大家，敬请等待。
StatementHandler创建后需要执行一些初始操作，好比statement的开启和参数设置、对于PreparedStatement还需要执行参数的设置操作等。代码如下：

1. private Statement prepareStatement(StatementHandler handler) throws SQLException {  
2.     Statement stmt;  
3.     Connection connection = transaction.getConnection();  
4.     stmt =handler.prepare(connection);  
5.     handler.parameterize(stmt);  
6.     return stmt;  
7. }

复制代码

statement的开启和参数设置没什么特别的地方，handler.parameterize倒是可以看看是怎么回事。handler.parameterize通过调用ParameterHandler的setParameters完成参数的设置，ParameterHandler随着StatementHandler的创建而创建，默认的实现是DefaultParameterHandler：

1. public ParameterHandler newParameterHandler(MappedStatement mappedStatement, Object parameterObject, BoundSql boundSql) {  
2.    ParameterHandler parameterHandler = new DefaultParameterHandler(mappedStatement,parameterObject,boundSql);  
3.    parameterHandler = (ParameterHandler) interceptorChain.pluginAll(parameterHandler);  
4.    return parameterHandler;  
5. }

复制代码

同Executor和StatementHandler一样，ParameterHandler也是可以被拦截的。DefaultParameterHandler里设置参数的代码如下：

1. public void setParameters(PreparedStatement ps) throws SQLException {  
2.     ErrorContext.instance().activity("settingparameters").object(mappedStatement.getParameterMap().getId());  
3.     List<ParameterMapping> parameterMappings = boundSql.getParameterMappings();  
4.     if(parameterMappings != null) {  
5.         MetaObject metaObject = parameterObject == null ? null :configuration.newMetaObject(parameterObject);  
6.         for (int i = 0; i< parameterMappings.size(); i++) {  
7.             ParameterMapping parameterMapping = parameterMappings.get(i);  
8.             if(parameterMapping.getMode() != ParameterMode.OUT) {  
9.                 Object value;  
10.                 String propertyName = parameterMapping.getProperty();  
11.                 PropertyTokenizer prop = newPropertyTokenizer(propertyName);  
12.                 if (parameterObject == null) {  
13.                     value = null;  
14.                 } else if (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())){  
15.                     value = parameterObject;  
16.                 } else if (boundSql.hasAdditionalParameter(propertyName)){  
17.                     value = boundSql.getAdditionalParameter(propertyName);  
18.                 } else if(propertyName.startsWith(ForEachSqlNode.ITEM_PREFIX)  
19.                         && boundSql.hasAdditionalParameter(prop.getName())){  
20.                     value = boundSql.getAdditionalParameter(prop.getName());  
21.                     if (value != null) {  
22.                         value = configuration.newMetaObject(value).getValue(propertyName.substring(prop.getName().length()));  
23.                     }  
24.                 } else {  
25.                     value = metaObject == null ? null :metaObject.getValue(propertyName);  
26.                 }  
27.                 TypeHandler typeHandler = parameterMapping.getTypeHandler();  
28.                 if (typeHandler == null) {  
29.                    throw new ExecutorException("Therewas no TypeHandler found for parameter " + propertyName  + " of statement " + mappedStatement.getId());  
30.                 }  
31.                 typeHandler.setParameter(ps, i + 1, value,parameterMapping.getJdbcType());  
32.             }  
33.   
34.         }  
35.   
36.     }  
37. }

复制代码

这里面最重要的一句实在就是最后一句代码，它的作用是用合适的TypeHandler完成参数的设置。那么什么是合适的TypeHandler呢，它又是如何决断出来的呢？BaseStatementHandler的构造方法里有这么一句：

1. this.boundSql= mappedStatement.getBoundSql(parameterObject);

复制代码

它触发了sql 的剖析，在剖析sql的过程中，TypeHandler也被决断出来了，决断的原则就是根据参数的类型和参数对应的JDBC类型决定使用哪个TypeHandler。好比：参数类型是String的话就用StringTypeHandler，参数类型是整数的话就用IntegerTypeHandler等。
参数设置完毕后，执行数据库操作（update或query）。如果是query最后另有个查询结果的处置惩罚过程。
接下来，咱们看看StatementHandler 的一个实现类 PreparedStatementHandler（这也是我们最常用的，封装的是PreparedStatement）, 看看它使怎么去处置惩罚的：

1.   public <E> List<E> query(Statement statement, ResultHandler resultHandler) throws SQLException {
2.     // 到此，原形毕露， PreparedStatement, 这个大家都已经滚瓜烂熟了吧
3.     PreparedStatement ps = (PreparedStatement) statement;
4.     ps.execute();
5.     // 结果交给了ResultSetHandler 去处理
6.     return resultSetHandler.<E> handleResultSets(ps);
7.   }

复制代码

结果处置惩罚使用ResultSetHandler来完成，默认的ResultSetHandler是FastResultSetHandler，它在创建StatementHandler时一起创建，代码如下：

1. public ResultSetHandler newResultSetHandler(Executor executor, MappedStatement mappedStatement,  
2. RowBounds rowBounds, ParameterHandler parameterHandler, ResultHandler resultHandler, BoundSql boundSql) {  
3.    ResultSetHandler resultSetHandler = mappedStatement.hasNestedResultMaps() ? newNestedResultSetHandler(executor, mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds): new FastResultSetHandler(executor,mappedStatement, parameterHandler, resultHandler, boundSql, rowBounds);  
4.    resultSetHandler = (ResultSetHandler) interceptorChain.pluginAll(resultSetHandler);  
5.    return resultSetHandler;  
6. }

复制代码

可以看出ResultSetHandler也是可以被拦截的，可以编写自己的拦截器改变ResultSetHandler的默认举动。ResultSetHandler内部一条记载一条记载的处置惩罚，在处置惩罚每条记载的每一列时会调用TypeHandler转换结果，如下：

1. protected boolean applyAutomaticMappings(ResultSet rs, List<String> unmappedColumnNames,MetaObject metaObject) throws SQLException {  
2.     boolean foundValues = false;  
3.     for (String columnName : unmappedColumnNames) {  
4.         final String property = metaObject.findProperty(columnName);  
5.         if (property!= null) {  
6.             final ClasspropertyType =metaObject.getSetterType(property);  
7.             if (typeHandlerRegistry.hasTypeHandler(propertyType)) {  
8.                 final TypeHandler typeHandler = typeHandlerRegistry.getTypeHandler(propertyType);  
9.                 final Object value = typeHandler.getResult(rs,columnName);  
10.                 if (value != null) {  
11.                     metaObject.setValue(property, value);  
12.                     foundValues = true;  
13.                 }  
14.             }  
15.         }  
16.     }  
17.     return foundValues;  
18. }

复制代码

从代码里可以看到，决断TypeHandler使用的是结果参数的属性类型。因此我们在界说作为结果的对象的属性时肯定要考虑与数据库字段类型的兼容性。到此， 一次sql的执行流程就完了。

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！更多信息从访问主页：qidao123.com:ToB企服之家，中国第一个企服评测及商务社交产业平台。