一文搞懂MyBatis的一级缓存和二级缓存

秒速五厘米 2024-03-23 15:46 55阅读 0赞

![format_png][]

### 前言 ###

在本篇文章中，将结合示例与源码，**对`MyBatis`中的`一级缓存`和`二级缓存`进行说明**。

**MyBatis**版本：**3.5.6**

### 正文 ###

#### 一. 一级缓存机制展示 ####

在**MyBatis**中如果多次执行完全相同的**SQL**语句时，**MyBatis**提供了**一级缓存**机制用于提高查询效率。一级缓存是默认开启的，如果想要手动配置，需要在**MyBatis**配置文件中加入如下配置。

<settings>
        <setting name="localCacheScope" value="SESSION"/>
    </settings>
    复制代码

其中**localCacheScope**可以配置为**SESSION（默认）** 或者**STATEMENT**，含义如下所示。

<table> 
 <thead> 
  <tr> 
   <th>属性值</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>SESSION</strong></td> 
   <td>一级缓存在一个会话中生效。即在一个会话中的所有查询语句，均会共享同一份一级缓存，不同会话中的一级缓存不共享。</td> 
  </tr> 
  <tr> 
   <td><strong>STATEMENT</strong></td> 
   <td>一级缓存仅针对当前执行的<strong>SQL</strong>语句生效。当前执行的<strong>SQL</strong>语句执行完毕后，对应的一级缓存会被清空。</td> 
  </tr> 
 </tbody> 
</table>

下面以一个例子对**MyBatis**的一级缓存机制进行演示和说明。首先开启日志打印，然后关闭二级缓存，并将一级缓存作用范围设置为**SESSION**，配置如下。

<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>
    复制代码

**MyBatis**的执行代码如下所示。

在执行代码中，连续执行了三次查询操作，看一下日志打印，如下所示。

![format_png 1][]

可以知道，只有第一次查询时和数据库进行了交互，后面两次查询均是从一级缓存中查询的数据。现在往映射接口和映射文件中加入更改数据的逻辑，如下所示。

public interface BookMapper {
    
        Book selectBookById(int id);
        // 根据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">
        <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>
    复制代码

执行的操作为先执行一次查询操作，然后执行一次更新操作并提交事务，最后再执行一次查询操作，执行代码如下所示。

执行结果如下所示。

![format_png 2][]

通过上述结果可以知道，在执行更新操作之后，再执行查询操作时，是直接从数据库查询的数据，并未使用一级缓存，即在一个会话中，对数据库的**增**，**删**，**改**操作，均会使一级缓存失效。

现在在执行代码中创建两个会话，先让会话1执行一次查询操作，然后让会话2执行一次更新操作并提交事务，最后让会话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));
        }
    
    }
    复制代码

执行结果如下所示。

![format_png 3][]

上述结果表明，会话1的第一次查询是直接查询的数据库，然后会话2执行了一次更新操作并提交了事务，此时数据库中**id**为1的图书的价格已经变更为了22.5，紧接着会话1又做了一次查询，但查询结果中的图书价格为20.5，说明会话1的第二次查询是从缓存获取的查询结果。所以在这里可以知道，**MyBatis**中每个会话均会维护一份一级缓存，不同会话之间的一级缓存各不影响。

在本小节最后，对**MyBatis**的一级缓存机制做一个总结，如下所示。

*  **MyBatis**的一级缓存默认开启，且默认作用范围为**SESSION**，即一级缓存在一个会话中生效，也可以通过配置将作用范围设置为**STATEMENT**，让一级缓存仅针对当前执行的**SQL**语句生效；
 *  在同一个会话中，执行**增**，**删**，**改**操作会使本会话中的一级缓存失效；
 *  不同会话持有不同的一级缓存，本会话内的操作不会影响其它会话内的一级缓存。

#### 二. 一级缓存源码分析 ####

本小节将对一级缓存对应的**MyBatis**源码进行讨论。

已知，禁用二级缓存的情况下，执行查询操作时，调用链如下所示。

![format_png 4][]

在**BaseExecutor**中有两个重载的**query()** 方法，下面先看第一个**query()** 方法的实现，如下所示。

@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);
        // 调用重载的query()方法
        return query(ms, parameter, rowBounds, resultHandler, key, boundSql);
    }
    复制代码

在上述**query()** 方法中，先会在**MappedStatement**中获取**SQL**语句，然后生成**CacheKey**，这个**CacheKey**实际就是本会话一级缓存中缓存的唯一标识，**CacheKey**类图如下所示。

![format_png 5][]

**CacheKey**中的**multiplier**，**hashcode**，**checksum**，**count**和**updateList**字段用于判断**CacheKey**之间是否相等，这些字段会在**CacheKey**的构造函数中进行初始化，如下所示。

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

同时**hashcode**，**checksum**，**count**和**updateList**字段会在**CacheKey**的**update()** 方法中被更新，如下所示。

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);
    }
    复制代码

主要逻辑就是基于**update()** 方法的入参计算并更新**hashcode**，**checksum**和**count**的值，然后再将入参添加到**updateList**集合中。同时，在**CacheKey**重写的**equals()** 方法中，只有当**hashcode**相等，**checksum**相等，**count**相等，以及**updateList**集合中的元素也全都相等时，才算做两个**CacheKey**是相等。

回到上述的**BaseExecutor**中的**query()** 方法，在其中会调用**createCacheKey()** 方法生成**CacheKey**，其部分源码如下所示。

public CacheKey createCacheKey(MappedStatement ms, Object parameterObject, 
                                   RowBounds rowBounds, BoundSql boundSql) {
        // ......
        
        // 创建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());
        
        // ......
        
        // 基于查询参数更新CacheKey
        cacheKey.update(value);
        
        // ......
        
        // 基于Environment的id更新CacheKey
        cacheKey.update(configuration.getEnvironment().getId());
        
        return cacheKey; 
    }
    复制代码

所以可以得出结论，判断**CacheKey**是否相等的依据就是**MappedStatement id + RowBounds offset + RowBounds limit + SQL + Parameter + Environment id**相等。

获取到**CacheKey**后，会调用**BaseExecutor**中重载的**query()** 方法，如下所示。

@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主要用于递归调用query()方法时防止一级缓存被清空
        if (queryStack == 0 && ms.isFlushCacheRequired()) {
            clearLocalCache();
        }
        List<E> list;
        try {
            queryStack++;
            // 先从一级缓存中根据CacheKey命中查询结果
            list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
            if (list != null) {
                // 处理存储过程相关逻辑
                handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
            } else {
                // 未命中，则直接查数据库
                list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
            }
        } finally {
            queryStack--;
        }
        if (queryStack == 0) {
            for (BaseExecutor.DeferredLoad deferredLoad : deferredLoads) {
                deferredLoad.load();
            }
            deferredLoads.clear();
            // 如果一级缓存作用范围是STATEMENT时，每次query()执行完毕就需要清空一级缓存
            if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
                clearLocalCache();
            }
        }
        return list;
    }
    复制代码

上述**query()** 方法中，会先根据**CacheKey**去缓存中命中查询结果，如果命中到查询结果并且映射文件中**CURD**标签上的**statementType**为**CALLABLE**，则会先在**handleLocallyCachedOutputParameters()** 方法中处理存储过程相关逻辑然后再将命中的查询结果返回，如果未命中到查询结果，则会直接查询数据库。

上述**query()** 方法中还使用到了**BaseExecutor**的**queryStack**字段，主要防止一级缓存作用范围是**STATEMENT**并且还存在递归调用**query()** 方法时，在递归尚未终止时就将一级缓存删除，如果不存在递归调用，那么一级缓存作用范围是**STATEMENT**时，每次查询结束后，都会清空缓存。

下面看一下**BaseExecutor**中的一级缓存**localCache**，其实际是**PerpetualCache**，类图如下所示。

![format_png 6][]

所以**PerpetualCache**的内部主要是基于一个**Map**（实际为**HashMap**）用于数据存储。

现在回到上面的**BaseExecutor**的**query()** 方法中，如果没有在一级缓存中命中查询结果，则会直接查询数据库，**queryFromDatabase()** 方法如下所示。

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 {
            // 调用doQuery()进行查询操作
            list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
        } finally {
            localCache.removeObject(key);
        }
        // 将查询结果添加到一级缓存中
        localCache.putObject(key, list);
        if (ms.getStatementType() == StatementType.CALLABLE) {
            localOutputParameterCache.putObject(key, parameter);
        }
        // 返回查询结果
        return list;
    }
    复制代码

**queryFromDatabase()** 方法中和一级缓存相关的逻辑就是在查询完数据库后，会将查询结果以**CacheKey**作为唯一标识缓存到一级缓存中。

**MyBatis**中如果是执行**增**，**改**和**删**操作，并且在禁用二级缓存的情况下，均会调用到**BaseExecutor**的**update()** 方法，如下所示。

@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.");
        }
        // 执行操作前先清空缓存
        clearLocalCache();
        return doUpdate(ms, parameter);
    }
    复制代码

所以**MyBatis**中的一级缓存在执行了**增**，**改**和**删**操作后，会被清空即失效。

最后，一级缓存的使用流程可以用下图进行概括。

![format_png 7][]

#### 三. 二级缓存机制展示 ####

**MyBatis**的一级缓存仅在一个会话中被共享，会话之间的一级缓存互不影响，而**MyBatis**的二级缓存可以被多个会话共享，本小节将结合例子，对**MyBatis**中的二级缓存的使用机制进行分析。要使用二级缓存，需要对**MyBatis**配置文件进行更改以开启二级缓存，如下所示。

<settings>
        <setting name="logImpl" value="STDOUT_LOGGING" />
        <setting name="cacheEnabled" value="true"/>
        <setting name="localCacheScope" value="STATEMENT"/>
    </settings>
    复制代码

上述配置文件中还将一级缓存的作用范围设置为了**STATEMENT**，目的是为了在例子中屏蔽一级缓存对查询结果的干扰。映射接口如下所示。

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

要使用二级缓存，还需要在映射文件中加入二级缓存相关的设置，如下所示。

二级缓存相关设置的每一项的含义，会在本小节末尾进行说明。

1. 场景一

**场景一**：创建两个会话，会话1以相同**SQL**语句连续执行两次查询，会话2以相同**SQL**语句执行一次查询。执行代码如下所示。

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));
        }
    
    }
    复制代码

执行结果如下所示。

![format_png 8][]

**MyBatis**中的二级缓存开启时，每次查询会先去二级缓存中命中查询结果，未命中时才会使用一级缓存以及直接去查询数据库。上述结果截图表明，场景一中，**SQL**语句相同时，无论是同一会话的连续两次查询还是另一会话的一次查询，均是查询的数据库，仿佛二级缓存没有生效，实际上，将查询结果缓存到二级缓存中需要事务提交，场景一中并没有事务提交，所以二级缓存中是没有内容的，最终导致三次查询均是直接查询的数据库。此外，如果是增删改操作，只要没有事务提交，那么就不会影响二级缓存。

2. 场景二

**场景二**：创建两个会话，会话1执行一次查询并提交事务，然后会话1以相同**SQL**语句再执行一次查询，接着会话2以相同**SQL**语句执行一次查询。执行代码如下所示。

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));
        }
    
    }
    复制代码

执行结果如下所示。

![format_png 9][]

场景二中第一次查询后提交了事务，此时将查询结果缓存到了二级缓存，所以后续的查询全部在二级缓存中命中了查询结果。

3. 场景三

**场景三**：创建两个会话，会话1执行一次查询并提交事务，然后会话2执行一次更新并提交事务，接着会话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(
    			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));
        }
    
    }
    复制代码

执行结果如下所示。

![format_png 10][]

场景三的执行结果表明，执行更新操作并且提交事务后，会清空二级缓存，执行新增和删除操作也是同理。

4. 场景四

**场景四**：创建两个会话，创建两张表，会话1首先执行一次多表查询并提交事务，然后会话2执行一次更新操作以更新表2的数据并提交事务，接着会话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
    )
    复制代码

往**book**表和**bookstore**表中添加如下数据。

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")
    复制代码

创建**BookStore**类，如下所示。

@Data
    public class BookStore {
    
        private String id;
        private String bookStoreName;
    
    }
    复制代码

创建**BookDetail**类，如下所示。

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

**BookMapper**映射接口添加**selectBookDetailById()** 方法，如下所示。

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

**BookMapper.xml**映射文件如下所示。

<?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>
    复制代码

还需要添加**BookStoreMapper**映射接口，如下所示。

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

还需要添加**BookStoreMapper.xml**映射文件，如下所示。

进行完上述更改之后，进行场景四的测试，执行代码如下所示。

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(
                    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));
        }
    
    }
    复制代码

执行结果如下所示。

![format_png 11][]

会话1第一次执行多表查询并提交事务时，将查询结果缓存到了二级缓存中，然后会话2对**bookstore**表执行了更新操作并提交了事务，但是最后会话1第二次执行相同的多表查询时，却从二级缓存中命中了查询结果，最终导致查询出来了脏数据。

实际上，二级缓存的作用范围是同一命名空间下的多个会话共享，这里的命名空间就是映射文件的**namespace**，可以理解为每一个映射文件持有一份二级缓存，所有会话在这个映射文件中的所有操作，都会共享这个二级缓存。所以场景四的例子中，会话2对**bookstore**表执行更新操作并提交事务时，清空的是**BookStoreMapper.xml**持有的二级缓存，**BookMapper.xml**持有的二级缓存没有感知到**bookstore**表的数据发生了变化，最终导致会话1第二次执行相同的多表查询时从二级缓存中命中了脏数据。

5. 场景五

**场景五**：执行的操作和**场景四**一致，但是在**BookStoreMapper.xml**文件中进行如下更改。

<?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));
    	// 将事务隔离级别设置为读已提交
            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));
        }
    
    }
    复制代码

执行结果如下所示。

![format_png 12][]

在**BookStoreMapper.xml**中使用<**cache-ref**>标签引用了命名空间为**com.mybatis.learn.dao.BookMapper**的映射文件使用的二级缓存，因此相当于**BookMapper.xml**映射文件与**BookStoreMapper.xml**映射文件持有同一份二级缓存，会话2在**BookStoreMapper.xml**映射文件中执行更新操作并提交事务后，会导致二级缓存被清空，从而会话1第二次执行相同的多表查询时会从数据库查询数据。

现在对**MyBatis**的二级缓存机制进行一个总结，如下所示。

*  **MyBatis**中的二级缓存默认开启，可以在**MyBatis**配置文件中的<**settings**>中添加<**setting name="cacheEnabled" value="false"/**>将二级缓存关闭；
 *  **MyBatis**中的二级缓存作用范围是同一命名空间下的多个会话共享，这里的命名空间就是映射文件的**namespace**，即不同会话使用同一映射文件中的**SQL**语句对数据库执行操作并提交事务后，均会影响这个映射文件持有的二级缓存；
 *  **MyBatis**中执行查询操作后，需要提交事务才能将查询结果缓存到二级缓存中；
 *  **MyBatis**中执行增，删或改操作并提交事务后，会清空对应的二级缓存；
 *  **MyBatis**中需要在映射文件中添加<**cache**>标签来为映射文件配置二级缓存，也可以在映射文件中添加<**cache-ref**>标签来引用其它映射文件的二级缓存以达到多个映射文件持有同一份二级缓存的效果。

最后，对<**cache**>标签和<**cache-ref**>标签进行说明。

<**cache**>标签如下所示。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>含义</th> 
   <th>默认值</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>eviction</strong></td> 
   <td>缓存淘汰策略。<strong>LRU</strong>表示最近使用频次最少的优先被淘汰；<strong>FIFO</strong>表示先被缓存的会先被淘汰；<strong>SOFT</strong>表示基于软引用规则来淘汰；<strong>WEAK</strong>表示基于弱引用规则来淘汰</td> 
   <td><strong>LRU</strong></td> 
  </tr> 
  <tr> 
   <td><strong>flushInterval</strong></td> 
   <td>缓存刷新间隔。单位毫秒</td> 
   <td>空，表示永不过期</td> 
  </tr> 
  <tr> 
   <td><strong>type</strong></td> 
   <td>缓存的类型</td> 
   <td><strong>PerpetualCache</strong></td> 
  </tr> 
  <tr> 
   <td><strong>size</strong></td> 
   <td>最多缓存的对象个数</td> 
   <td>1024</td> 
  </tr> 
  <tr> 
   <td><strong>blocking</strong></td> 
   <td>缓存未命中时是否阻塞</td> 
   <td><strong>false</strong></td> 
  </tr> 
  <tr> 
   <td><strong>readOnly</strong></td> 
   <td>缓存中的对象是否只读。配置为<strong>true</strong>时，表示缓存对象只读，命中缓存时会直接将缓存的对象返回，性能更快，但是线程不安全；配置为<strong>false</strong>时，表示缓存对象可读写，命中缓存时会将缓存的对象克隆然后返回克隆的对象，性能更慢，但是线程安全</td> 
   <td><strong>false</strong></td> 
  </tr> 
 </tbody> 
</table>

<**cache-ref**>标签如下所示。

<table> 
 <thead> 
  <tr> 
   <th>属性</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>namespace</strong></td> 
   <td>其它映射文件的命名空间，设置之后则当前映射文件将和其它映射文件将持有同一份二级缓存</td> 
  </tr> 
 </tbody> 
</table>

#### 四. 二级缓存的创建 ####

在[详解MyBatis加载映射文件和动态代理][MyBatis]中已经知道，**XMLMapperBuilder**的**configurationElement()** 方法会解析映射文件的内容并丰富到**Configuration**中，但在[详解MyBatis加载映射文件和动态代理][MyBatis]中并未对解析映射文件的<**cache**>标签和<**cache-ref**>标签进行说明，因此本小节将对这部分内容进行补充。

**configurationElement()** 方法如下所示。

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>标签
            cacheRefElement(context.evalNode("cache-ref"));
    	// 解析<cache>标签
            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);
        }
    }
    复制代码

在**configurationElement()** 方法中会先解析<**cache-ref**>标签，然后再解析<**cache**>标签，因此在这里先进行一个推测：如果映射文件中同时存在<**cache-ref**>和<**cache**>标签，那么<**cache**>标签配置的二级缓存会覆盖<**cache-ref**>引用的二级缓存。

下面先分析<**cache**>标签的解析，**cacheElement()** 方法如下所示。

private void cacheElement(XNode context) {
        if (context != null) {
            // 获取<cache>标签的type属性值
            String type = context.getStringAttribute("type", "PERPETUAL");
            Class<? extends Cache> typeClass = typeAliasRegistry.resolveAlias(type);
            // 获取<cache>标签的eviction属性值
            String eviction = context.getStringAttribute("eviction", "LRU");
            Class<? extends Cache> evictionClass = typeAliasRegistry.resolveAlias(eviction);
            // 获取<cache>标签的flushInterval属性值
            Long flushInterval = context.getLongAttribute("flushInterval");
            // 获取<cache>标签的size属性值
            Integer size = context.getIntAttribute("size");
            // 获取<cache>标签的readOnly属性值并取反
            boolean readWrite = !context.getBooleanAttribute("readOnly", false);
            // 获取<cache>标签的blocking属性值
            boolean blocking = context.getBooleanAttribute("blocking", false);
            Properties props = context.getChildrenAsProperties();
            builderAssistant.useNewCache(typeClass, evictionClass, flushInterval, size, readWrite, blocking, props);
        }
    }
    复制代码

单步跟踪**cacheElement()** 方法，每个属性解析出来的内容可以参照下图。

![format_png 13][]

**Cache**的实际创建是在**MapperBuilderAssistant**的**useNewCache()** 方法中，实现如下所示。

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;
    }
    复制代码

在**MapperBuilderAssistant**的**useNewCache()** 方法中会先创建**CacheBuilder**，然后调用**CacheBuilder**的**build()** 方法构建**Cache**。**CacheBuilder**类图如下所示。

![format_png 14][]

**CacheBuilder**的构造函数如下所示。

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

所以可以知道，**CacheBuilder**的**id**字段实际就是当前映射文件的**namespace**，其实到这里已经大致可以猜到，**CacheBuilder**构建出来的二级缓存**Cache**在**Configuration**中的唯一标识就是映射文件的**namespace**。此外，**CacheBuilder**中的**implementation**是**PerpetualCache**的**Class**对象，**decorators**集合中包含有**LruCache**的**Class**对象。下面看一下**CacheBuilder**的**build()** 方法，如下所示。

public Cache build() {
        setDefaultImplementations();
        // 创建PerpetualCache，作为基础Cache对象
        Cache cache = newBaseCacheInstance(implementation, id);
        setCacheProperties(cache);
        if (PerpetualCache.class.equals(cache.getClass())) {
            // 为基础Cache对象添加缓存淘汰策略相关的装饰器
            for (Class<? extends Cache> decorator : decorators) {
                cache = newCacheDecoratorInstance(decorator, cache);
                setCacheProperties(cache);
            }
            // 继续添加装饰器
            cache = setStandardDecorators(cache);
        } else if (!LoggingCache.class.isAssignableFrom(cache.getClass())) {
            cache = new LoggingCache(cache);
        }
        return cache;
    }
    复制代码

**CacheBuilder**的**build()** 方法首先会创建**PerpetualCache**对象，作为基础缓存对象，然后还会为基础缓存对象根据缓存淘汰策略添加对应的装饰器，比如<**cache**>标签中**eviction**属性值为**LRU**，那么对应的装饰器为**LruCache**，根据**eviction**属性值的不同，对应的装饰器就不同，下图是**MyBatis**为缓存淘汰策略提供的所有装饰器。

![format_png 15][]

**CacheBuilder**的**build()** 方法中，为**PerpetualCache**添加完缓存淘汰策略添装饰器后，还会继续添加标准装饰器，**MyBatis**中定义的标准装饰器有**ScheduledCache**，**SerializedCache**，**LoggingCache**，**SynchronizedCache**和**BlockingCache**，含义如下表所示。

<table> 
 <thead> 
  <tr> 
   <th>装饰器</th> 
   <th>含义</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <td><strong>ScheduledCache</strong></td> 
   <td>提供缓存定时刷新功能，&lt;<strong>cache</strong>&gt;标签设置了<strong>flushInterval</strong>属性值时会添加该装饰器</td> 
  </tr> 
  <tr> 
   <td><strong>SerializedCache</strong></td> 
   <td>提供缓存序列化功能，&lt;<strong>cache</strong>&gt;标签的<strong>readOnly</strong>属性设置为<strong>false</strong>时会添加该装饰器</td> 
  </tr> 
  <tr> 
   <td><strong>LoggingCache</strong></td> 
   <td>提供日志功能，默认会添加该装饰器</td> 
  </tr> 
  <tr> 
   <td><strong>SynchronizedCache</strong></td> 
   <td>提供同步功能，默认会添加该装饰器</td> 
  </tr> 
  <tr> 
   <td><strong>BlockingCache</strong></td> 
   <td>提供阻塞功能，&lt;<strong>cache</strong>&gt;标签的<strong>blocking</strong>属性设置为<strong>true</strong>时会添加该装饰器</td> 
  </tr> 
 </tbody> 
</table>

如下是一个<**cache**>标签的示例。

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

那么生成的二级缓存对象如下所示。

![format_png 16][]

整个装饰链如下图所示。

![format_png 17][]

现在回到**MapperBuilderAssistant**的**useNewCache()** 方法，构建好二级缓存对象之后，会将其添加到**Configuration**中，**Configuration**的**addCache()** 方法如下所示。

public void addCache(Cache cache) {
        caches.put(cache.getId(), cache);
    }
    复制代码

这里就印证了前面的猜想，即二级缓存**Cache**在**Configuration**中的唯一标识就是映射文件的**namespace**。

现在再分析一下**XMLMapperBuilder**中的**configurationElement()** 方法对<**cache-ref**>标签的解析。**cacheRefElement()** 方法如下所示。

private void cacheRefElement(XNode context) {
        if (context != null) {
            // 在Configuration的cacheRefMap中将当前映射文件命名空间与引用的映射文件命名空间建立映射关系
            configuration.addCacheRef(builderAssistant.getCurrentNamespace(), context.getStringAttribute("namespace"));
            CacheRefResolver cacheRefResolver = new CacheRefResolver(builderAssistant, context.getStringAttribute("namespace"));
            try {
                // CacheRefResolver会将引用的映射文件的二级缓存从Configuration中获取出来并赋值给MapperBuilderAssistant的currentCache
                cacheRefResolver.resolveCacheRef();
            } catch (IncompleteElementException e) {
                configuration.addIncompleteCacheRef(cacheRefResolver);
            }
        }
    }
    复制代码

**cacheRefElement()** 方法会首先在**Configuration**的**cacheRefMap**中将当前映射文件命名空间与引用的映射文件命名空间建立映射关系，然后会通过**CacheRefResolver**将引用的映射文件的二级缓存从**Configuration**中获取出来并赋值给**MapperBuilderAssistant**的**currentCache**，**currentCache**这个字段后续会在**MapperBuilderAssistant**构建**MappedStatement**时传递给**MappedStatement**，以及如果映射文件中还存在<**cache**>标签，那么**MapperBuilderAssistant**会将<**cache**>标签配置的二级缓存重新赋值给**currentCache**以覆盖<**cache-ref**>标签引用的二级缓存，**所以映射文件中同时有`<cache-ref>`标签和`<cache>`标签时，只有`<cache>`标签配置的二级缓存会生效**。

#### 五. 二级缓存的源码分析 ####

本小节将对二级缓存对应的**MyBatis**源码进行讨论。**MyBatis**中开启二级缓存之后，执行查询操作时，调用链如下所示。

![format_png 18][]

在**CachingExecutor**中有两个重载的**query()** 方法，下面先看第一个**query()** 方法，如下所示。

@Override
    public <E> List<E> query(MappedStatement ms, Object parameterObject, 
            RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
        // 获取Sql语句
        BoundSql boundSql = ms.getBoundSql(parameterObject);
        // 创建CacheKey
        CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
        return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }
    复制代码

继续看重载的**query()** 方法，如下所示。

@Override
    public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, 
                  ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
        // 从MappedStatement中将二级缓存获取出来
        Cache cache = ms.getCache();
        if (cache != null) {
            // 清空二级缓存（如果需要的话）
            flushCacheIfRequired(ms);
            if (ms.isUseCache() && resultHandler == null) {
                // 处理存储过程相关逻辑
                ensureNoOutParams(ms, boundSql);
                // 从二级缓存中根据CacheKey命中查询结果
                List<E> list = (List<E>) tcm.getObject(cache, key);
                if (list == null) {
                    // 未命中缓存，则查数据库
                    list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
                    // 将从数据库查询到的结果缓存到二级缓存中
                    tcm.putObject(cache, key, list);
                }
                // 返回查询结果
                return list;
            }
        }
        return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
    }
    复制代码

上述**query()** 方法整体执行流程比较简单，概括下来就是：

1.  先从缓存中命中查询结果；
2.  命中到查询结果则返回；
3.  未命中到查询结果则直接查询数据库并把查询结果缓存到二级缓存中。

但是从二级缓存中根据**CacheKey**命中查询结果时，并没有直接通过**Cache**的**getObject()** 方法，而是通过**tcm**的**getObject()** 方法，合理进行推测的话，应该就是**tcm**持有二级缓存的引用，当需要从二级缓存中命中查询结果时，由**tcm**将请求转发给二级缓存。

实际上，**tcm**为**CachingExecutor**持有的**TransactionalCacheManager**对象，从二级缓存中命中查询结果这一请求之所以需要通过**TransactionalCacheManager**转发给二级缓存，是因为需要借助**TransactionalCacheManager**实现**只有当事务提交时，二级缓存才会被更新**这一功能。联想到第三小节中的场景一和场景二的示例，将查询结果缓存到二级缓存中需要事务提交这一功能，其实就是借助**TransactionalCacheManager**实现的，所以下面对**TransactionalCacheManager**进行一个说明。首先**TransactionalCacheManager**的类图如下所示。

![format_png 19][]

**TransactionalCacheManager**中持有一个**Map**，该**Map**的键为**Cache**，值为**TransactionalCache**，即一个二级缓存对应一个**TransactionalCache**。继续看**TransactionalCacheManager**的**getObject()** 方法，如下所示。

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

通过上述代码可以知道，一个二级缓存对应一个**TransactionalCache**，且**TransactionalCache**中持有这个二级缓存的引用，当调用**TransactionalCacheManager**的**getObject()** 方法时，**TransactionalCacheManager**会将调用请求转发给**TransactionalCache**，下面分析一下**TransactionalCache**，类图如下所示。

![format_png 20][]

继续看**TransactionalCache**的**getObject()** 方法，如下所示。

@Override
    public Object getObject(Object key) {
        // 在二级缓存中命中查询结果
        Object object = delegate.getObject(key);
        if (object == null) {
            // 未命中则将CacheKey添加到entriesMissedInCache中
            // 用于统计命中率
            entriesMissedInCache.add(key);
        }
        if (clearOnCommit) {
            return null;
        } else {
            return object;
        }
    }
    复制代码

到这里就可以知道了，在**CachingExecutor**中通过**CacheKey**命中查询结果时，步骤如下。

1.  **CachingExecutor**将请求发送给**TransactionalCacheManager**；
2.  **TransactionalCacheManager**将请求转发给二级缓存对应的**TransactionalCache**；
3.  最后再由**TransactionalCache**将请求最终传递到二级缓存。

在上述**getObject()** 方法中，如果**clearOnCommit**为**true**，则无论是否在二级缓存中命中查询结果，均返回**null**，那么**clearOnCommit**在什么地方会被置为**true**呢，其实就是在**CachingExecutor**的**flushCacheIfRequired()** 方法中，这个方法在上面分析的**query()** 方法中会被调用到，看一下**flushCacheIfRequired()** 的实现，如下所示。

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

调用**TransactionalCacheManager**的**clear()** 方法时，最终会调用到**TransactionalCache**的**clear()** 方法，如下所示。

@Override
    public void clear() {
        clearOnCommit = true;
        entriesToAddOnCommit.clear();
    }
    复制代码

现在继续分析为什么将查询结果缓存到二级缓存中需要事务提交。从数据库中查询出来结果后，**CachingExecutor**会调用**TransactionalCacheManager**的**putObject()** 方法试图将查询结果缓存到二级缓存中，我们已经知道，如果事务不提交，那么查询结果是无法被缓存到二级缓存中，那么在事务提交之前，查询结果肯定被**暂存**到了某个地方，为了搞清楚这部分逻辑，先看一下**TransactionalCacheManager**的**putObject()** 方法，如下所示。

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

继续看**TransactionalCache**的**putObject()** 方法，如下所示。

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

到这里就搞明白了，在事务提交之前，查询结果会被**暂存**到**TransactionalCache**的**entriesToAddOnCommit**中。

下面继续分析事务提交时如何将**entriesToAddOnCommit**中**暂存**的查询结果刷新到二级缓存中，**DefaultSqlSession**的**commit()** 方法如下所示。

@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();
        }
    }
    复制代码

在**DefaultSqlSession**的**commit()** 方法中会调用到**CachingExecutor**的**commit()** 方法，如下所示。

@Override
    public void commit(boolean required) throws SQLException {
        delegate.commit(required);
        // 调用TransactionalCacheManager的commit()方法
        tcm.commit();
    }
    复制代码

在**CachingExecutor**的**commit()** 方法中，会调用**TransactionalCacheManager**的**commit()** 方法，如下所示。

public void commit() {
        for (TransactionalCache txCache : transactionalCaches.values()) {
            // 调用TransactionalCache的commit()方法
            txCache.commit();
        }
    }
    复制代码

继续看**TransactionalCache**的**commit()** 方法，如下所示。

public void commit() {
        if (clearOnCommit) {
            delegate.clear();
        }
        flushPendingEntries();
        reset();
    }
    
    private void flushPendingEntries() {
        // 将entriesToAddOnCommit中暂存的查询结果全部缓存到二级缓存中
        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);
            }
        }
    }
    复制代码

至此可以知道，当调用**SqlSession**的**commit()** 方法时，会一路传递到**TransactionalCache**的**commit()** 方法，最终调用**TransactionalCache**的**flushPendingEntries()** 方法将**暂存**的查询结果全部刷到二级缓存中。

当执行**增**，**删**，**改**操作并提交事务时，二级缓存会被清空，这是因为**增**，**删**，**改**操作最终会调用到**CachingExecutor**的**update()** 方法，而**update()** 方法中又会调用**flushCacheIfRequired()** 方法，已经知道在**flushCacheIfRequired()** 方法中如果所执行的方法对应的**MappedStatement**的**flushCacheRequired**字段为**true**的话，则会最终将**TransactionalCache**中的**clearOnCommit**字段置为**true**，随即在事务提交的时候，会将二级缓存清空。而加载映射文件时，解析**CURD**标签为**MappedStatement**时有如下一行代码。

boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    复制代码

即如果没有在**CURD**标签中显式的设置**flushCache**属性，则会给**flushCache**字段一个默认值，且默认值为非查询标签下默认为**true**，所以到这里就可以知道，如果是**增**，**删**，**改**操作，那么**TransactionalCache**中的**clearOnCommit**字段会被置为**true**，从而在提交事务时会在**TransactionalCache**的**commit()** 方法中将二级缓存清空。

到这里，二级缓存的源码分析结束。二级缓存的使用流程可以用下图进行概括，如下所示。

![format_png 21][]

### 总结 ###

关于**MyBatis**的一级缓存，总结如下。

关于**MyBatis**的二级缓存，总结如下。

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/db06420045f64f819b44b1d7276842b9.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/8317c26504da4bc2a2a4ad895691cff3.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/c958a07da33141fba8debb1603ef03b8.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/39e98d6b2c5e400aa1fb5097cbd6316c.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/db61275f957945379c66253deb060cbd.png
[format_png 5]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/7b79c8535c8442c0bb3029f55af4250d.png
[format_png 6]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/fe52e253732d416499a1c2b5eb15528c.png
[format_png 7]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/66d704e4daf146688adb2c4099cd8f9d.png
[format_png 8]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/fa9f3eef77c64a1cb57fcf0217a439a9.png
[format_png 9]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/b1308a84ced74798b8f0946c925d082a.png
[format_png 10]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/eb4c02533b444f1b8d7a9b3c60192f49.png
[format_png 11]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/b2ff7cabbf634be58553ec8e78695544.png
[format_png 12]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/086d987b63f742989165a00496c32a91.png
[MyBatis]: https://juejin.cn/post/7203925850398883896
[format_png 13]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/1f9c66696b8a4c469b2ff42b856f8fa2.png
[format_png 14]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/a0a9622aafcc4157b5f3b0a9c5ff0a81.png
[format_png 15]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/82d9c94ac8254cc5b439dfa3eaf0d0fa.png
[format_png 16]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/797dfd713a084e1ab8ce8aff3db51d90.png
[format_png 17]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/52a8a2203a284b0d9161621d2ae0b7c8.png
[format_png 18]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/5bffa0d7dd6b45b0b0d67acfeaa54d2b.png
[format_png 19]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/f21ba0c67847464f96ef1171d7ed4221.png
[format_png 20]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/3ca6dc749f894f77b4062faf118bf421.png
[format_png 21]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/23/dfeaa7503fbf44a99c9904f5d731cf48.png