MyBatis2

/* 往缓存中写入数据，也就是缓存查询结果 */
localCache.putObject(key, list);
if (ms.getStatementType() == StatementType.CALLABLE) {
    localOutputParameterCache.putObject(key, parameter);
}
return list;

    /* 子流程1: SQL查询参数的设置 */
    stmt = prepareStatement(handler, ms.getStatementLog());

    /* 子流程2: SQL查询操作和结果集封装 */
    return handler.query(stmt, resultHandler);
} finally {
    closeStatement(stmt);
}

/* 准备Statement */
stmt = handler.prepare(connection, transaction.getTimeout());

/* 设置SQL查询中的参数值 */
handler.parameterize(stmt);
return stmt;

final List multipleResults = new ArrayList();

int resultSetCount = 0;
/**
 * 获取第一个ResultSet，同时获取数据库的MetaData数据，包括数据表列名、列的类型、类序号等。
 * 这些信息都存储在了ResultSetWrapper中了
 */
ResultSetWrapper rsw = getFirstResultSet(stmt);

List resultMaps = mappedStatement.getResultMaps();
int resultMapCount = resultMaps.size();
validateResultMapsCount(rsw, resultMapCount);
while (rsw != null && resultMapCount > resultSetCount) {
  ResultMap resultMap = resultMaps.get(resultSetCount);
  handleResultSet(rsw, resultMap, multipleResults, null);
  rsw = getNextResultSet(stmt);
  cleanUpAfterHandlingResultSet();
  resultSetCount++;
}

String[] resultSets = mappedStatement.getResultSets();
if (resultSets != null) {
  while (rsw != null && resultSetCount < resultSets.length) {
    ResultMapping parentMapping = nextResultMaps.get(resultSets[resultSetCount]);
    if (parentMapping != null) {
      String nestedResultMapId = parentMapping.getNestedResultMapId();
      ResultMap resultMap = configuration.getResultMap(nestedResultMapId);
      handleResultSet(rsw, resultMap, null, parentMapping);
    }
    rsw = getNextResultSet(stmt);
    cleanUpAfterHandlingResultSet();
    resultSetCount++;
  }
}

return collapseSingleResultList(multipleResults);
 
}
 复制代码
 ResultSetWrapper是ResultSet的包装类，调用getFirstResultSet方法获取第一个ResultSet，同时获取数据库的MetaData数据，包括数据表列名、列的类型、类序号等，这些信息都存储在ResultSetWrapper类中了。然后调用handleResultSet方法来来进行结果集的封装。 
复制代码
 // DefaultResultSetHandler类
 private void handleResultSet(ResultSetWrapper rsw, ResultMap resultMap, List multipleResults, ResultMapping parentMapping) throws SQLException {
 try {
 if (parentMapping != null) {
 handleRowValues(rsw, resultMap, null, RowBounds.DEFAULT, parentMapping);
 } else {
 if (resultHandler == null) {
 DefaultResultHandler defaultResultHandler = new DefaultResultHandler(objectFactory);
 handleRowValues(rsw, resultMap, defaultResultHandler, rowBounds, null);
 multipleResults.add(defaultResultHandler.getResultList());
 } else {
 handleRowValues(rsw, resultMap, resultHandler, rowBounds, null);
 }
 }
 } finally {
 // issue #228 (close resultsets)
 closeResultSet(rsw.getResultSet());
 }
 }
 复制代码
 这里调用handleRowValues方法进行结果值的设置。 
复制代码
 // DefaultResultSetHandler类
 public void handleRowValues(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler resultHandler, RowBounds rowBounds, ResultMapping parentMapping) throws SQLException {
 if (resultMap.hasNestedResultMaps()) {
 ensureNoRowBounds();
 checkResultHandler();
 handleRowValuesForNestedResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
 } else {
 // 封装数据
 handleRowValuesForSimpleResultMap(rsw, resultMap, resultHandler, rowBounds, parentMapping);
 }
 } 
private void handleRowValuesForSimpleResultMap(ResultSetWrapper rsw, ResultMap resultMap, ResultHandler resultHandler, RowBounds rowBounds, ResultMapping parentMapping)
 throws SQLException {
 DefaultResultContext resultContext = new DefaultResultContext();
 skipRows(rsw.getResultSet(), rowBounds);
 while (shouldProcessMoreRows(resultContext, rowBounds) && rsw.getResultSet().next()) {
 ResultMap discriminatedResultMap = resolveDiscriminatedResultMap(rsw.getResultSet(), resultMap, null);
 Object rowValue = getRowValue(rsw, discriminatedResultMap);
 storeObject(resultHandler, resultContext, rowValue, parentMapping, rsw.getResultSet());
 }
 } 
private Object getRowValue(ResultSetWrapper rsw, ResultMap resultMap) throws SQLException {
 final ResultLoaderMap lazyLoader = new ResultLoaderMap();
 // createResultObject为新创建的对象，数据表对应的类
 Object rowValue = createResultObject(rsw, resultMap, lazyLoader, null);
 if (rowValue != null && !hasTypeHandlerForResultObject(rsw, resultMap.getType())) {
 final MetaObject metaObject = configuration.newMetaObject(rowValue);
 boolean foundValues = this.useConstructorMappings;
 if (shouldApplyAutomaticMappings(resultMap, false)) {
 // 这里把数据填充进去，metaObject中包含了resultObject信息
 foundValues = applyAutomaticMappings(rsw, resultMap, metaObject, null) || foundValues;
 }
 foundValues = applyPropertyMappings(rsw, resultMap, metaObject, lazyLoader, null) || foundValues;
 foundValues = lazyLoader.size() > 0 || foundValues;
 rowValue = (foundValues || configuration.isReturnInstanceForEmptyRow()) ? rowValue : null;
 }
 return rowValue;
 } 
private boolean applyAutomaticMappings(ResultSetWrapper rsw, ResultMap resultMap, MetaObject metaObject, String columnPrefix) throws SQLException {
 List autoMapping = createAutomaticMappings(rsw, resultMap, metaObject, columnPrefix);
 boolean foundValues = false;
 if (autoMapping.size() > 0) {
 // 这里进行for循环调用，因为user表中总共有7列，所以也就调用7次
 for (UnMappedColumnAutoMapping mapping : autoMapping) {
 // 这里将esultSet中查询结果转换为对应的实际类型
 final Object value = mapping.typeHandler.getResult(rsw.getResultSet(), mapping.column);
 if (value != null) {
 foundValues = true;
 }
 if (value != null || (configuration.isCallSettersOnNulls() && !mapping.primitive)) {
 // gcode issue #377, call setter on nulls (value is not ‘found’)
 metaObject.setValue(mapping.property, value);
 }
 }
 }
 return foundValues;
 }
 复制代码
 mapping.typeHandler.getResult会获取查询结果值的实际类型，比如我们user表中id字段为int类型，那么它就对应Java中的Integer类型，然后通过调用statement.getInt(“id”)来获取其int值，其类型为Integer。metaObject.setValue方法会把获取到的Integer值设置到Java类中的对应字段。 
复制代码
 // MetaObject类
 public void setValue(String name, Object value) {
 PropertyTokenizer prop = new PropertyTokenizer(name);
 if (prop.hasNext()) {
 MetaObject metaValue = metaObjectForProperty(prop.getIndexedName());
 if (metaValue == SystemMetaObject.NULL_META_OBJECT) {
 if (value == null && prop.getChildren() != null) {
 // don’t instantiate child path if value is null
 return;
 } else {
 metaValue = objectWrapper.instantiatePropertyValue(name, prop, objectFactory);
 }
 }
 metaValue.setValue(prop.getChildren(), value);
 } else {
 objectWrapper.set(prop, value);
 }
 }
 复制代码
 metaValue.setValue方法最后会调用到Java类中对应数据域的set方法，这样也就完成了SQL查询结果集的Java类封装过程。最后贴一张调用栈到达Java类的set方法中的快照： 
MyBatis缓存 
MyBatis提供查询缓存，用于减轻数据库压力，提高性能。MyBatis提供了一级缓存和二级缓存。 
一级缓存是SqlSession级别的缓存，每个SqlSession对象都有一个哈希表用于缓存数据，不同SqlSession对象之间缓存不共享。同一个SqlSession对象对象执行2遍相同的SQL查询，在第一次查询执行完毕后将结果缓存起来，这样第二遍查询就不用向数据库查询了，直接返回缓存结果即可。MyBatis默认是开启一级缓存的。 
二级缓存是mapper级别的缓存，二级缓存是跨SqlSession的，多个SqlSession对象可以共享同一个二级缓存。不同的SqlSession对象执行两次相同的SQL语句，第一次会将查询结果进行缓存，第二次查询直接返回二级缓存中的结果即可。MyBatis默认是不开启二级缓存的，可以在配置文件中使用如下配置来开启二级缓存： 当SQL语句进行更新操作(删除/添加/更新)时，会清空对应的缓存，保证缓存中存储的都是最新的数据。MyBatis的二级缓存对细粒度的数据级别的缓存实现不友好，比如如下需求：对商品信息进行缓存，由于商品信息查询访问量大，但是要求用户每次都能查询最新的商品信息，此时如果使用mybatis的二级缓存就无法实现当一个商品变化时只刷新该商品的缓存信息而不刷新其它商品的信息，因为mybaits的二级缓存区域以mapper为单位划分，当一个商品信息变化会将所有商品信息的缓存数据全部清空。解决此类问题需要在业务层根据需求对数据有针对性缓存，具体业务具体实现