//8.进⼊selectList⽅法，多个重载⽅法。
 public <E > List < E > selectList(String statement) {
 return this.selectList(statement, null);
 public <E > List < E > selectList(String statement, Object parameter) {
 return this.selectList(statement, parameter, RowBounds.DEFAULT);
 public <E > List < E > selectList(String statement, Object
parameter, RowBounds rowBounds) {
 try {
 //根据传⼊的全限定名+⽅法名从映射的Map中取出MappedStatement对象
 MappedStatement ms =
configuration.getMappedStatement(statement);
 //调⽤Executor中的⽅法处理
 //RowBounds是⽤来逻辑分⻚
 // wrapCollection(parameter)是⽤来装饰集合或者数组参数
 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();
 }

public void parameterize(Statement statement) throws SQLException {
 //使⽤ParameterHandler对象来完成对Statement的设值
 parameterHandler.setParameters((PreparedStatement) statement);
}

 /**
     * ParameterHandler 类的 setParameters(PreparedStatement ps) 实现
     * 对某⼀个Statement进⾏设置参数
     */
    public void setParameters(PreparedStatement ps) throws SQLException {
        ErrorContext.instance().activity("setting
                parameters").object(mappedStatement.getParameterMap().getId());
                List < ParameterMapping > parameterMappings = boundSql.getParameterMappings();
        if (parameterMappings != null) {
            for (int i = 0; i <
                    parameterMappings.size(); i++) {
                ParameterMapping parameterMapping =
                        parameterMappings.get(i);
                if (parameterMapping.getMode() != ParameterMode.OUT) {
                    Object value;
                    String propertyName = parameterMapping.getProperty();
                    if (boundSql.hasAdditionalParameter(propertyName)) { // issue #448
                        ask first for additional params
                        value = boundSql.getAdditionalParameter(propertyName);
                    } else if (parameterObject == null) {
                        value = null;
                    } else if
                    (typeHandlerRegistry.hasTypeHandler(parameterObject.getClass())) {
                        value =
                                parameterObject;
                    } else {
                        MetaObject metaObject =
                                configuration.newMetaObject(parameterObject);
                        value = metaObject.getValue(propertyName);
                    }
                    // 每⼀个 Mapping都有⼀个 TypeHandler，根据 TypeHandler 来对
                    preparedStatement 进 ⾏设置参数
                    TypeHandler typeHandler = parameterMapping.getTypeHandler();
                    JdbcType jdbcType = parameterMapping.getJdbcType();
                    if (value == null && jdbcType == null) jdbcType =
                            configuration.getJdbcTypeForNull();
                    //设置参数
                    typeHandler.setParameter(ps, i + 1, value, jdbcType);
                }
            }
        }
    }

public <E> List<E> query(Statement statement, ResultHandler resultHandler)
throws SQLException {
 // 1.调⽤preparedStatemnt。execute()⽅法，然后将resultSet交给ResultSetHandler处 理
 PreparedStatement ps = (PreparedStatement) statement;
 ps.execute();
 
 //2.使⽤ ResultHandler 来处理 ResultSet
 return resultSetHandler.<E> handleResultSets(ps);
}

 public List<Object> handleResultSets(Statement stmt) throws SQLException {
 ErrorContext.instance().activity("handling
results").object(mappedStatement.getId());
//多ResultSet的结果集合，每个ResultSet对应⼀个Object对象。⽽实际上，每 个 Object 是
List<Object> 对象。
//在不考虑存储过程的多ResultSet的情况，普通的查询，实际就⼀个ResultSet，也 就是说，
multipleResults最多就⼀个元素。
 final List<Object> multipleResults = new ArrayList<>();
 int resultSetCount = 0;
 //获得⾸个ResultSet对象，并封装成ResultSetWrapper对象
 ResultSetWrapper rsw = getFirstResultSet(stmt);
 //获得ResultMap数组
 //在不考虑存储过程的多ResultSet的情况，普通的查询，实际就⼀个ResultSet，也 就是
说，resultMaps就⼀个元素。
 List<ResultMap> resultMaps = mappedStatement.getResultMaps();
 int resultMapCount = resultMaps.size();
 validateResultMapsCount(rsw, resultMapCount); // 校验
 while (rsw != null && resultMapCount > resultSetCount) {
 //获得ResultMap对象
 ResultMap resultMap = resultMaps.get(resultSetCount);
 //处理ResultSet，将结果添加到multipleResults中
 handleResultSet(rsw, resultMap, multipleResults, null);
 //获得下⼀个ResultSet对象，并封装成ResultSetWrapper对象
 rsw = getNextResultSet(stmt);
 //清理
 cleanUpAfterHandlingResultSet();
 // resultSetCount ++
 resultSetCount++;
 }
 }

 //因为'mappedStatement.resultSets'只在存储过程中使⽤，本系列暂时不考虑，忽略即可
    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++;
        }
    }
    //如果是multipleResults单元素，则取⾸元素返回
 return

    collapseSingleResultList(multipleResults);
}

public static void main(String[] args) {
 //前三步都相同
 InputStream inputStream = Resources.getResourceAsStream("sqlMapConfig.xml");
 SqlSessionFactory factory = new SqlSessionFactoryBuilder().build(inputStream);
 SqlSession sqlSession = factory.openSession();
 //这⾥不再调⽤SqlSession的api,⽽是获得了接⼝对象，调⽤接⼝中的⽅法。

//使用JDK动态代理，对mapper接口产生代理对象
 UserMapper mapper = sqlSession.getMapper(UserMapper.class);
//代理对象调用接口的任意方法，都是执行的动态代理中的invoke方法
 List<User> list = mapper.getUserByName("tom");
 }

public Object invoke(Object proxy, Method method, Object[] args) throws
Throwable {
 try {
 //如果是Object定义的⽅法，直接调⽤
 if (Object.class.equals(method.getDeclaringClass())) {
 return method.invoke(this, args);
 } else if (isDefaultMethod(method)) {
 return invokeDefaultMethod(proxy, method, args);
 }
 } catch (Throwable t) {
 throw ExceptionUtil.unwrapThrowable(t);
 }
 // 获得 MapperMethod 对象
 final MapperMethod mapperMethod = cachedMapperMethod(method);
 //重点在这：MapperMethod最终调⽤了执⾏的⽅法
 return mapperMethod.execute(sqlSession, args);
 }

public Object execute(SqlSession sqlSession, Object[] args) {
 Object result;
 //判断mapper中的⽅法类型，最终调⽤的还是SqlSession中的⽅法 switch
(command.getType()) {
 case INSERT: {
 //转换参数
 Object param = method.convertArgsToSqlCommandParam(args);
 //执⾏INSERT操作
 // 转换 rowCount
 result = rowCountResult(sqlSession.insert(command.getName(),
param));
 break;
 }
 case UPDATE: {
 //转换参数
 Object param = method.convertArgsToSqlCommandParam(args);
 // 转换 rowCount
 result = rowCountResult(sqlSession.update(command.getName(),
param));
 break;
 }
 case DELETE: {
 //转换参数
 Object param = method.convertArgsToSqlCommandParam(args);
 // 转换 rowCount
 result = rowCountResult(sqlSession.delete(command.getName(),
 param));
 break;
 }
 case SELECT:
 //⽆返回，并且有ResultHandler⽅法参数，则将查询的结果，提交给 ResultHandler 进
⾏处理
 if (method.returnsVoid() && method.hasResultHandler()) {
 executeWithResultHandler(sqlSession, args);
 result = null;
 //执⾏查询，返回列表
 } else if (method.returnsMany()) {
 result = executeForMany(sqlSession, args);
 //执⾏查询，返回Map
 } else if (method.returnsMap()) {
 result = executeForMap(sqlSession, args);
 //执⾏查询，返回Cursor
 } else if (method.returnsCursor()) {
 result = executeForCursor(sqlSession, args);
 //执⾏查询，返回单个对象
 } else {
 //转换参数
 Object param = method.convertArgsToSqlCommandParam(args);
 //查询单条
 result = sqlSession.selectOne(command.getName(), param);
 if (method.returnsOptional() &&
 (result == null ||
 
!method.getReturnType().equals(result.getClass()))) {
 result = Optional.ofNullable(result);
 }
 }
 break;
 case FLUSH:
 result = sqlSession.flushStatements();
 break;
 default:
 throw new BindingException("Unknown execution method for: " +
command.getName()); 
 //返回结果为null，并且返回类型为基本类型，则抛出BindingException异常
 if(result ==null&&method.getReturnType().isPrimitive()
&&!method.returnsVoid()){
 throw new BindingException("Mapper method '" + command.getName() + "
attempted to return null from a method with a primitive
 return type(" + method.getReturnType() + "). ");
 }
 //返回结果
 return result; }

// CachingExecutor
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds
rowBounds, ResultHandler resultHandler) throws SQLException {
 BoundSql boundSql = ms.getBoundSql(parameterObject);
 // 创建 CacheKey
 CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
 return query(ms, parameterObject, rowBounds, resultHandler, key,
boundSql);
}
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds
rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
 throws SQLException {
 // 从 MappedStatement 中获取 Cache，注意这⾥的 Cache 是从MappedStatement中获取的
 // 也就是我们上⾯解析Mapper中<cache/>标签中创建的，它保存在Configration中
 // 我们在上⾯解析blog.xml时分析过每⼀个MappedStatement都有⼀个Cache对象，就是这⾥
 Cache cache = ms.getCache();
 // 如果配置⽂件中没有配置 <cache>，则 cache 为空
 if (cache != null) {
 //如果需要刷新缓存的话就刷新：flushCache="true"
 flushCacheIfRequired(ms);
 if (ms.isUseCache() && resultHandler == null) {
 ensureNoOutParams(ms, boundSql);
 // 访问⼆级缓存
 List<E> list = (List<E>) tcm.getObject(cache, key);
 // 缓存未命中
if (list == null) {
 // 如果没有值，则执⾏查询，这个查询实际也是先⾛⼀级缓存查询，⼀级缓存也没
有的话，则进⾏DB查询
 list = delegate.<E>query(ms, parameterObject, rowBounds,
resultHandler, key, boundSql);
 // 缓存查询结果
 tcm.putObject(cache, key, list);
 }
 return list;
 }
 }
 return delegate.<E>query(ms, parameterObject, rowBounds, resultHandler,
key, boundSql);
}

@Override
public void commit(boolean force) {
 try {
 // 主要是这句
 executor.commit(isCommitOrRollbackRequired(force));
　dirty = false;
 } catch (Exception e) {
 throw ExceptionFactory.wrapException("Error committing transaction. 
Cause: " + e, e);
 } finally {
 ErrorContext.instance().reset();
 }
}

@Override
public void commit(boolean required) throws SQLException {
 delegate.commit(required);
 tcm.commit();// 在这⾥
}

public int update(String statement, Object parameter) {
 int var4;
 try {
 this.dirty = true;
 MappedStatement ms = this.configuration.getMappedStatement(statement);
 var4 = this.executor.update(ms, this.wrapCollection(parameter));
 } catch (Exception var8) {
 throw ExceptionFactory.wrapException("Error updating database. Cause:
" + var8, var8);
 } finally {
 ErrorContext.instance().reset();
 }
 return var4; }
public int update(MappedStatement ms, Object parameterObject) throws
SQLException {
 this.flushCacheIfRequired(ms);
 return this.delegate.update(ms, parameterObject);
}
private void flushCacheIfRequired(MappedStatement ms) {
 //获取MappedStatement对应的Cache，进⾏清空
 Cache cache = ms.getCache();
 //SQL需设置flushCache="true" 才会执⾏清空
 if (cache != null && ms.isFlushCacheRequired()) {
 this.tcm.clear(cache);
 }
}

<!--引入映射配置文件-->
    <mappers>
        <mapper resource="LazyIUserMapper.xml"></mapper>
    </mappers>

public class User {
    private Integer id;
    private String username;
    private List<Order> orderList;
}

public class Order   {
    private Integer id;
    private String orderTime;
    private Double total;
}

public interface LazyIUserMapper
{
    /* 一对多 */
    List<User> selectById();

}

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

<mapper namespace="com.mytest.mapper.LazyIUserMapper">

    <!-- 延迟加载一对多映射 -->
    <resultMap id="lazyUserMap" type="com.mytest.pojo.lazy.User">
        <result property="id" column="id"></result>
        <result property="username" column="username"></result>
        <collection property="orderList" ofType="com.mytest.pojo.lazy.Order"
        select="com.mytest.mapper.LazyIUserMapper.selectOrderByUid" column="id" >
            <result property="id" column="oid"></result>
            <result property="orderTime" column="orderTime"></result>
            <result property="total" column="total"></result>
        </collection>
    </resultMap>
    <select id="selectById" resultMap="lazyUserMap" useCache="true">
        select * from user where id =#{id}
     </select>
    <select id="selectOrderByUid" resultType="com.mytest.pojo.lazy.Order">
        select * from ORDERS where uid =#{uid}
    </select>
</mapper>