<settings>
    <setting name="localCacheScope" value="SESSION"/>
</settings>

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING" />
    <setting name="cacheEnabled" value="false"/>
    <setting name="localCacheScope" value="SESSION"/>
</settings>

public interface BookMapper {
    Book selectBookById(int id);
}

<?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.mybatis.learn.dao.BookMapper">
    <resultMap id="bookResultMap" type="com.mybatis.learn.entity.Book">
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
    </resultMap>
    <select id="selectBookById" resultMap="bookResultMap">
        SELECT
            b.id, 
            b.b_name, 
            b.b_price
        FROM book b
        WHERE b.id=#{id}
    </select>
</mapper>

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
        SqlSession sqlSession = sqlSessionFactory.openSession(false);
        BookMapper bookMapper = sqlSession.getMapper(BookMapper.class);
        System.out.println(bookMapper.selectBookById(1));
        System.out.println(bookMapper.selectBookById(1));
        System.out.println(bookMapper.selectBookById(1));
    }
}

public interface BookMapper {
    Book selectBookById(int id);
    // 根據(jù)id更改圖書價(jià)格
    void updateBookPriceById(@Param("id") int id, @Param("bookPrice") float bookPrice);
}

<?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.mybatis.learn.dao.BookMapper">
    <resultMap id="bookResultMap" type="com.mybatis.learn.entity.Book">
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
    </resultMap>
    <select id="selectBookById" resultMap="bookResultMap">
        SELECT
            b.id, 
            b.b_name, 
            b.b_price
        FROM book b
        WHERE b.id=#{id}
    </select>
    <update id="updateBookPriceById">
        UPDATE book SET b_price=#{bookPrice}
        WHERE id=#{id}
    </update>
</mapper>

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
        SqlSession sqlSession = sqlSessionFactory.openSession(false);
        BookMapper bookMapper = sqlSession.getMapper(BookMapper.class);
        System.out.println(bookMapper.selectBookById(1));
        System.out.println("Change database.");
        bookMapper.updateBookPriceById(1, 22.5f);
        sqlSession.commit();
        System.out.println(bookMapper.selectBookById(1));
    }
}

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
        SqlSession sqlSession1 = sqlSessionFactory.openSession(false);
        SqlSession sqlSession2 = sqlSessionFactory.openSession(false);
        BookMapper bookMapper1 = sqlSession1.getMapper(BookMapper.class);
        BookMapper bookMapper2 = sqlSession2.getMapper(BookMapper.class);
        System.out.println(bookMapper1.selectBookById(1));
        System.out.println("Change database.");
        bookMapper2.updateBookPriceById(1, 22.5f);
        sqlSession2.commit();
        System.out.println(bookMapper1.selectBookById(1));
    }
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, 
                       ResultHandler resultHandler) throws SQLException {
    // 獲取Sql語句
    BoundSql boundSql = ms.getBoundSql(parameter);
    // 生成CacheKey
    CacheKey key = createCacheKey(ms, parameter, rowBounds, boundSql);
    // 調(diào)用重載的query()方法
    return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
}

public CacheKey() {
    this.hashcode = DEFAULT_HASHCODE;
    this.multiplier = DEFAULT_MULTIPLIER;
    this.count = 0;
    this.updateList = new ArrayList<>();
}

public void update(Object object) {
    int baseHashCode = object == null ? 1 : ArrayUtil.hashCode(object);
    count++;
    checksum += baseHashCode;
    baseHashCode *= count;
    hashcode = multiplier * hashcode + baseHashCode;
    updateList.add(object);
}

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, 
                               RowBounds rowBounds, BoundSql boundSql) {
    // ......
    // 創(chuàng)建CacheKey
    CacheKey cacheKey = new CacheKey();
    // 基于MappedStatement的id更新CacheKey
    cacheKey.update(ms.getId());
    // 基于RowBounds的offset更新CacheKey
    cacheKey.update(rowBounds.getOffset());
    // 基于RowBounds的limit更新CacheKey
    cacheKey.update(rowBounds.getLimit());
    // 基于Sql語句更新CacheKey
    cacheKey.update(boundSql.getSql());
    // ......
    // 基于查詢參數(shù)更新CacheKey
    cacheKey.update(value);
    // ......
    // 基于Environment的id更新CacheKey
    cacheKey.update(configuration.getEnvironment().getId());
    return cacheKey; 
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, 
                         CacheKey key, BoundSql boundSql) throws SQLException {
    ErrorContext.instance().resource(ms.getResource()).activity("executing a query").object(ms.getId());
    if (closed) {
        throw new ExecutorException("Executor was closed.");
    }
    // queryStack是BaseExecutor的成員變量
    // queryStack主要用于遞歸調(diào)用query()方法時(shí)防止一級(jí)緩存被清空
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
        clearLocalCache();
    }
    List<E> list;
    try {
        queryStack++;
        // 先從一級(jí)緩存中根據(jù)CacheKey命中查詢結(jié)果
        list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
        if (list != null) {
            // 處理存儲(chǔ)過程相關(guān)邏輯
            handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
        } else {
            // 未命中，則直接查數(shù)據(jù)庫(kù)
            list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
        }
    } finally {
        queryStack--;
    }
    if (queryStack == 0) {
        for (BaseExecutor.DeferredLoad deferredLoad : deferredLoads) {
            deferredLoad.load();
        }
        deferredLoads.clear();
        // 如果一級(jí)緩存作用范圍是STATEMENT時(shí)，每次query()執(zhí)行完畢就需要清空一級(jí)緩存
        if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
            clearLocalCache();
        }
    }
    return list;
}

private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, 
                    ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list;
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
        // 調(diào)用doQuery()進(jìn)行查詢操作
        list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
        localCache.removeObject(key);
    }
    // 將查詢結(jié)果添加到一級(jí)緩存中
    localCache.putObject(key, list);
    if (ms.getStatementType() == StatementType.CALLABLE) {
        localOutputParameterCache.putObject(key, parameter);
    }
    // 返回查詢結(jié)果
    return list;
}

@Override
public int update(MappedStatement ms, Object parameter) throws SQLException {
    ErrorContext.instance().resource(ms.getResource())
            .activity("executing an update").object(ms.getId());
    if (closed) {
      throw new ExecutorException("Executor was closed.");
    }
    // 執(zhí)行操作前先清空緩存
    clearLocalCache();
    return doUpdate(ms, parameter);
}

<settings>
    <setting name="logImpl" value="STDOUT_LOGGING" />
    <setting name="cacheEnabled" value="true"/>
    <setting name="localCacheScope" value="STATEMENT"/>
</settings>

public interface BookMapper {
    Book selectBookById(int id);
    void updateBookPriceById(@Param("id") int id, @Param("bookPrice") float bookPrice);
}

<?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.mybatis.learn.dao.BookMapper">
    <!-- 二級(jí)緩存相關(guān)設(shè)置 -->
    <cache eviction="LRU"
           type="org.apache.ibatis.cache.impl.PerpetualCache"
           flushInterval="600000"
           size="1024"
           readOnly="true"
           blocking="false"/>
    <resultMap id="bookResultMap" type="com.mybatis.learn.entity.Book">
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
    </resultMap>
    <select id="selectBookById" resultMap="bookResultMap">
        SELECT
            b.id, 
            b.b_name, 
            b.b_price
        FROM book b
        WHERE b.id=#{id}
    </select>
    <update id="updateBookPriceById">
        UPDATE book SET b_price=#{bookPrice}
        WHERE id=#{id}
    </update>
</mapper>

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
        SqlSession sqlSession1 = sqlSessionFactory.openSession(false);
        SqlSession sqlSession2 = sqlSessionFactory.openSession(false);
        BookMapper bookMapper1 = sqlSession1.getMapper(BookMapper.class);
        BookMapper bookMapper2 = sqlSession2.getMapper(BookMapper.class);
        System.out.println(bookMapper1.selectBookById(1));
        System.out.println(bookMapper1.selectBookById(1));
        System.out.println(bookMapper2.selectBookById(1));
    }
}

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
        SqlSession sqlSession1 = sqlSessionFactory.openSession(false);
        SqlSession sqlSession2 = sqlSessionFactory.openSession(false);
        BookMapper bookMapper1 = sqlSession1.getMapper(BookMapper.class);
        BookMapper bookMapper2 = sqlSession2.getMapper(BookMapper.class);
        System.out.println(bookMapper1.selectBookById(1));
        sqlSession1.commit();
        System.out.println(bookMapper1.selectBookById(1));
        System.out.println(bookMapper2.selectBookById(1));
    }
}

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
	// 將事務(wù)隔離級(jí)別設(shè)置為讀已提交
        SqlSession sqlSession1 = sqlSessionFactory.openSession(
			TransactionIsolationLevel.READ_COMMITTED);
        SqlSession sqlSession2 = sqlSessionFactory.openSession(
			TransactionIsolationLevel.READ_COMMITTED);
        BookMapper bookMapper1 = sqlSession1.getMapper(BookMapper.class);
        BookMapper bookMapper2 = sqlSession2.getMapper(BookMapper.class);
        System.out.println(bookMapper1.selectBookById(1));
        sqlSession1.commit();
        System.out.println("Change database.");
        bookMapper2.updateBookPriceById(1, 20.5f);
        sqlSession2.commit();
        System.out.println(bookMapper1.selectBookById(1));
    }
}

CREATE TABLE book(
    id INT(11) PRIMARY KEY AUTO_INCREMENT,
    b_name VARCHAR(255) NOT NULL,
    b_price FLOAT NOT NULL,
    bs_id INT(11) NOT NULL,
    FOREIGN KEY book(bs_id) REFERENCES bookstore(id)
);
CREATE TABLE bookstore(
    id INT(11) PRIMARY KEY AUTO_INCREMENT,
    bs_name VARCHAR(255) NOT NULL
)

INSERT INTO book (b_name, b_price, bs_id) VALUES ("Math", 20.5, 1);
INSERT INTO book (b_name, b_price, bs_id) VALUES ("English", 21.5, 1);
INSERT INTO book (b_name, b_price, bs_id) VALUES ("Water Margin", 30.5, 2);
INSERT INTO bookstore (bs_name) VALUES ("XinHua");
INSERT INTO bookstore (bs_name) VALUES ("SanYou")

@Data
public class BookStore {
    private String id;
    private String bookStoreName;
}

@Data
public class BookDetail {
    private long id;
    private String bookName;
    private float bookPrice;
    private BookStore bookStore;
}

public interface BookMapper {
    Book selectBookById(int id);
    void updateBookPriceById(@Param("id") int id, @Param("bookPrice") float bookPrice);
    BookDetail selectBookDetailById(int id);
}

<?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.mybatis.learn.dao.BookMapper">
    <cache eviction="LRU"
           type="org.apache.ibatis.cache.impl.PerpetualCache"
           flushInterval="600000"
           size="1024"
           readOnly="true"
           blocking="false"/>
    <resultMap id="bookResultMap" type="com.mybatis.learn.entity.Book">
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
    </resultMap>
    <resultMap id="bookDetailResultMap" type="com.mybatis.learn.entity.BookDetail">
        <id property="id" column="id"/>
        <result property="bookName" column="b_name"/>
        <result property="bookPrice" column="b_price"/>
        <association property="bookStore">
            <id property="id" column="id"/>
            <result property="bookStoreName" column="bs_name"/>
        </association>
    </resultMap>
    <select id="selectBookById" resultMap="bookResultMap">
        SELECT
            b.id, 
            b.b_name, 
            b.b_price
        FROM book b
        WHERE b.id=#{id}
    </select>
    <update id="updateBookPriceById">
        UPDATE book SET b_price=#{bookPrice}
        WHERE id=#{id}
    </update>
    <select id="selectBookDetailById" resultMap="bookDetailResultMap">
        SELECT
            b.id, 
            b.b_name, 
            b.b_price, 
            bs.id, 
            bs.bs_name
        FROM book b, bookstore bs
        WHERE b.id=#{id}
            AND b.bs_id = bs.id
    </select>
</mapper>

public interface BookStoreMapper {
    void updateBookPriceById(@Param("id") int id, @Param("bookStoreName") String bookStoreName);
}

<?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.mybatis.learn.dao.BookStoreMapper">
    <cache eviction="LRU"
           type="org.apache.ibatis.cache.impl.PerpetualCache"
           flushInterval="600000"
           size="1024"
           readOnly="true"
           blocking="false"/>
    <update id="updateBookPriceById">
        UPDATE bookstore SET bs_name=#{bookStoreName}
        WHERE id=#{id}
    </update>
</mapper>

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
	// 將事務(wù)隔離級(jí)別設(shè)置為讀已提交
        SqlSession sqlSession1 = sqlSessionFactory.openSession(
                TransactionIsolationLevel.READ_COMMITTED);
        SqlSession sqlSession2 = sqlSessionFactory.openSession(
                TransactionIsolationLevel.READ_COMMITTED);
        BookMapper bookMapper1 = sqlSession1.getMapper(BookMapper.class);
        BookStoreMapper bookStoreMapper = sqlSession2.getMapper(BookStoreMapper.class);
        System.out.println(bookMapper1.selectBookDetailById(1));
        sqlSession1.commit();
        System.out.println("Change database.");
        bookStoreMapper.updateBookStoreById(1, "ShuXiang");
        sqlSession2.commit();
        System.out.println(bookMapper1.selectBookDetailById(1));
    }
}

<?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.mybatis.learn.dao.BookStoreMapper">
    <cache-ref namespace="com.mybatis.learn.dao.BookMapper"/>
    <update id="updateBookStoreById">
        UPDATE bookstore SET bs_name=#{bookStoreName}
        WHERE id=#{id}
    </update>
</mapper>

public class MybatisTest {
    public static void main(String[] args) throws Exception {
        String resource = "mybatis-config.xml";
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder()
                .build(Resources.getResourceAsStream(resource));
	// 將事務(wù)隔離級(jí)別設(shè)置為讀已提交
        SqlSession sqlSession1 = sqlSessionFactory.openSession(
                TransactionIsolationLevel.READ_COMMITTED);
        SqlSession sqlSession2 = sqlSessionFactory.openSession(
                TransactionIsolationLevel.READ_COMMITTED);
        BookMapper bookMapper1 = sqlSession1.getMapper(BookMapper.class);
        BookStoreMapper bookStoreMapper = sqlSession2.getMapper(BookStoreMapper.class);
        System.out.println(bookMapper1.selectBookDetailById(1));
        sqlSession1.commit();
        System.out.println("Change database.");
        bookStoreMapper.updateBookStoreById(1, "ShuXiang");
        sqlSession2.commit();
        System.out.println(bookMapper1.selectBookDetailById(1));
    }
}

private void configurationElement(XNode context) {
    try {
        String namespace = context.getStringAttribute("namespace");
        if (namespace == null || namespace.isEmpty()) {
            throw new BuilderException("Mapper's namespace cannot be empty");
        }
        builderAssistant.setCurrentNamespace(namespace);
	// 解析<cache-ref>標(biāo)簽
        cacheRefElement(context.evalNode("cache-ref"));
	// 解析<cache>標(biāo)簽
        cacheElement(context.evalNode("cache"));
        parameterMapElement(context.evalNodes("/mapper/parameterMap"));
        resultMapElements(context.evalNodes("/mapper/resultMap"));
        sqlElement(context.evalNodes("/mapper/sql"));
        buildStatementFromContext(context.evalNodes("select|insert|update|delete"));
    } catch (Exception e) {
        throw new BuilderException("Error parsing Mapper XML. The XML location is '" 
                + resource + "'. Cause: " + e, e);
    }
}

private void cacheElement(XNode context) {
    if (context != null) {
        // 獲取<cache>標(biāo)簽的type屬性值
        String type = context.getStringAttribute("type", "PERPETUAL");
        Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
        // 獲取<cache>標(biāo)簽的eviction屬性值
        String eviction = context.getStringAttribute("eviction", "LRU");
        Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
        // 獲取<cache>標(biāo)簽的flushInterval屬性值
        Long flushInterval = context.getLongAttribute("flushInterval");
        // 獲取<cache>標(biāo)簽的size屬性值
        Integer size = context.getIntAttribute("size");
        // 獲取<cache>標(biāo)簽的readOnly屬性值并取反
        boolean readWrite = !context.getBooleanAttribute("readOnly", false);
        // 獲取<cache>標(biāo)簽的blocking屬性值
        boolean blocking = context.getBooleanAttribute("blocking", false);
        Properties props = context.getChildrenAsProperties();
        builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
    }
}

public Cache useNewCache(Class<? extends Cache> typeClass,
                         Class<? extends Cache> evictionClass,
                         Long flushInterval,
                         Integer size,
                         boolean readWrite,
                         boolean blocking,
                         Properties props) {
    Cache cache = new CacheBuilder(currentNamespace)
            .implementation(valueOrDefault(typeClass, PerpetualCache.class))
            .addDecorator(valueOrDefault(evictionClass, LruCache.class))
            .clearInterval(flushInterval)
            .size(size)
            .readWrite(readWrite)
            .blocking(blocking)
            .properties(props)
            .build();
    configuration.addCache(cache);
    currentCache = cache;
    return cache;
}

public CacheBuilder(String id) {
    this.id = id;
    this.decorators = new ArrayList<>();
}

public Cache build() {
    setDefaultImplementations();
    // 創(chuàng)建PerpetualCache，作為基礎(chǔ)Cache對(duì)象
    Cache cache = newBaseCacheInstance(implementation, id);
    setCacheProperties(cache);
    if (PerpetualCache.class.equals(cache.getClass())) {
        // 為基礎(chǔ)Cache對(duì)象添加緩存淘汰策略相關(guān)的裝飾器
        for (Class<? extends Cache> decorator : decorators) {
            cache = newCacheDecoratorInstance(decorator, cache);
            setCacheProperties(cache);
        }
        // 繼續(xù)添加裝飾器
        cache = setStandardDecorators(cache);
    } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
        cache = new LoggingCache(cache);
    }
    return cache;
}

<cache eviction="LRU"
       type="org.apache.ibatis.cache.impl.PerpetualCache"
       flushInterval="600000"
       size="1024"
       readOnly="false"
       blocking="true"/>

public void addCache(Cache cache) {
    caches.put(cache.getId(), cache);
}

private void cacheRefElement(XNode context) {
    if (context != null) {
        // 在Configuration的cacheRefMap中將當(dāng)前映射文件命名空間與引用的映射文件命名空間建立映射關(guān)系
        configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
        CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
        try {
            // CacheRefResolver會(huì)將引用的映射文件的二級(jí)緩存從Configuration中獲取出來并賦值給MapperBuilderAssistant的currentCache
            cacheRefResolver.resolveCacheRef();
        } catch (IncompleteElementException e) {
            configuration.addIncompleteCacheRef(cacheRefResolver);
        }
    }
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, 
        RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 獲取Sql語句
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    // 創(chuàng)建CacheKey
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

@Override
public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, 
              ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    // 從MappedStatement中將二級(jí)緩存獲取出來
    Cache cache = ms.getCache();
    if (cache != null) {
        // 清空二級(jí)緩存（如果需要的話）
        flushCacheIfRequired(ms);
        if (ms.isUseCache() && resultHandler == null) {
            // 處理存儲(chǔ)過程相關(guān)邏輯
            ensureNoOutParams(ms, boundSql);
            // 從二級(jí)緩存中根據(jù)CacheKey命中查詢結(jié)果
            List<E> list = (List<E>) tcm.getObject(cache, key);
            if (list == null) {
                // 未命中緩存，則查數(shù)據(jù)庫(kù)
                list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                // 將從數(shù)據(jù)庫(kù)查詢到的結(jié)果緩存到二級(jí)緩存中
                tcm.putObject(cache, key, list);
            }
            // 返回查詢結(jié)果
            return list;
        }
    }
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
}

public Object getObject(Cache cache, CacheKey key) {
    return getTransactionalCache(cache).getObject(key);
}
private TransactionalCache getTransactionalCache(Cache cache) {
    return transactionalCaches.computeIfAbsent(cache, TransactionalCache::new);
}

@Override
public Object getObject(Object key) {
    // 在二級(jí)緩存中命中查詢結(jié)果
    Object object = delegate.getObject(key);
    if (object == null) {
        // 未命中則將CacheKey添加到entriesMissedInCache中
        // 用于統(tǒng)計(jì)命中率
        entriesMissedInCache.add(key);
    }
    if (clearOnCommit) {
        return null;
    } else {
        return object;
    }
}

private void flushCacheIfRequired(MappedStatement ms) {
    Cache cache = ms.getCache();
    if (cache != null && ms.isFlushCacheRequired()) {
        tcm.clear(cache);
    }
}

@Override
public void clear() {
    clearOnCommit = true;
    entriesToAddOnCommit.clear();
}

public void putObject(Cache cache, CacheKey key, Object value) {
    getTransactionalCache(cache).putObject(key, value);
}

@Override
public void putObject(Object key, Object object) {
    entriesToAddOnCommit.put(key, object);
}

@Override
public void commit() {
    commit(false);
}
@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);
    // 調(diào)用TransactionalCacheManager的commit()方法
    tcm.commit();
}

public void commit() {
    for (TransactionalCache txCache : transactionalCaches.values()) {
        // 調(diào)用TransactionalCache的commit()方法
        txCache.commit();
    }
}

public void commit() {
    if (clearOnCommit) {
        delegate.clear();
    }
    flushPendingEntries();
    reset();
}
private void flushPendingEntries() {
    // 將entriesToAddOnCommit中暫存的查詢結(jié)果全部緩存到二級(jí)緩存中
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
        delegate.putObject(entry.getKey(), entry.getValue());
    }
    for (Object entry : entriesMissedInCache) {
        if (!entriesToAddOnCommit.containsKey(entry)) {
            delegate.putObject(entry, null);
        }
    }
}

boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);