关于MyBatis的一级缓存和二级缓存的深度解析

墨蓝 2024-03-25 23:08 40阅读 0赞

### 前言 ###

在本篇文章中，将结合示例与源码，**对`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**的执行代码如下所示。

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

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

![format_png][]

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

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

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

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

执行结果如下所示。

![format_png 1][]

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

现在在执行代码中创建两个会话，先让会话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 2][]

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

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

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

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

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

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

![format_png 3][]

在**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 4][]

**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(

[format_png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/a07941e36dd843c0939a8f685fc83169.png
[format_png 1]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/87d896478f4d425dab719a0a7c375d08.png
[format_png 2]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/0af172febe034f54a03baf43631542e7.png
[format_png 3]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/dc5c262a3e2b436b8d6f8f5fdb0df539.png
[format_png 4]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/25/b4ca4617111346b09c39a64c3ef73aa8.png