『手撕 Mybatis 源码』10 - 一级缓存

最新推荐文章于 2024-09-29 10:01:27 发布
最新推荐文章于 2024-09-29 10:01:27 发布
阅读量201 收藏
点赞数
分类专栏： 『数据库』 文章标签： mybatis 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/zzz805/article/details/131485374
版权

一级缓存

概述

在这里插入图片描述

  1. 一级缓存是 SqlSession 级别的缓存。在操作数据库时需要构造 SqlSession 对象，在对象中有一个数据结构（HashMap）用于存储缓存数据。不同的 SqlSession 之间的缓存数据区域（HashMap）是互相不影响的
  2. 二级缓存是 Mapper 级别的缓存，多个 SqlSession 去操作同一个 Mapper 的sql语句，多个 SqlSession 可以共用二级缓存，二级缓存是跨 SqlSession 的
  3. 首先新增测试用例 firstLevelCacheTest，然后同时会发现如果使用（增删改）操作，不管是否已经 commit()，都会清理一级缓存
public class CacheTest {

  /**
   * 测试一级缓存
   */
  @Test
  public void firstLevelCacheTest() throws IOException {

    InputStream resourceAsStream = Resources.getResourceAsStream("sqlMapConfig.xml");

    // 2. (1)解析了配置文件，封装configuration对象 （2）创建了DefaultSqlSessionFactory工厂对象
    SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);

    // 3.问题：openSession()执行逻辑是什么？
    // 3. (1)创建事务对象 （2）创建了执行器对象cachingExecutor (3)创建了DefaultSqlSession对象
    SqlSession sqlSession = sqlSessionFactory.openSession();

    // 发起第一次查询，查询ID为1的用户
    User user1 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

    // 更新操作（通过增删改执行操作，会清除缓存）
    User user = new User();
    user.setId(1L);
    user.setName("tom");
    sqlSession.update("com.itheima.mapper.UserMapper.updateUser",user);
    sqlSession.commit();

    // 发起第二次查询，查询ID为1的用户
    User user2 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

    System.out.println(user1 == user2);
    System.out.println(user1);
    System.out.println(user2);

    sqlSession.close();
  }
}

源码分析

  1. 首先我们主要关注下面的的流程，看看一级缓存的行为，首先执行一次 sqlSession.selectOne() 查询，然后执行一次更新语句，再次执行一次查询
public class CacheTest {

  /**
   * 测试一级缓存
   */
  @Test
  public void firstLevelCacheTest() throws IOException {
    ...
    // 发起第一次查询，查询ID为1的用户  
    User user1 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);

    // 更新操作（通过增删改执行操作，会清除缓存）
    User user = new User();
    user.setId(1L);
    user.setName("tom");
    sqlSession.update("com.itheima.mapper.UserMapper.updateUser",user);
    sqlSession.commit();

    // 发起第二次查询，查询ID为1的用户
    User user2 = sqlSession.selectOne("com.itheima.mapper.UserMapper.findByCondition", 1);
   ...
  }
}
  1. 第一次调用 sqlSession.selectOne() 时，将会嵌套调用 selectList() 方法，得到 MappedStatement 后，使用 Executor 来执行查询
public class DefaultSqlSession implements SqlSession {

  private final Configuration configuration;
  private final Executor executor;
  ...
  private <E> List<E> selectList(String statement, Object parameter, RowBounds rowBounds, ResultHandler handler) {
    try {
      // 1. 根据传入的 statementId 即 user.findUserById，获取 MappedStatement 对象
      MappedStatement ms = configuration.getMappedStatement(statement);
      // 2. 调用执行器的查询方法
      // wrapCollection(parameter)是用来装饰集合或者数组参数
      return executor.query(ms, wrapCollection(parameter), rowBounds, handler);
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error querying database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }
}
  1. Executor 实际使用的是 CachingExecutor，执行前，先生成 CacheKey，然后委托 SimpleExecutor 进行查询
public class CachingExecutor implements Executor {

  private final Executor delegate;
  ...
  //第一步
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    // 获取绑定的 SQL 语句，比如 "SELECT * FROM user WHERE id = ? "
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    // 1. 生成缓存Key
    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 {
    ...
    // 2. 委托给 BaseExecutor 执行
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
}
  1. SimpleExecutor 首先从一级缓存 localCache（就是 PerpetualCache，一个 Map）拿取数据，如果获取不了数据就会从数据库查询结果
public abstract class BaseExecutor implements Executor {
  ...
  protected PerpetualCache localCache;
  ...
  @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.");
    }
    // 如果配置了 flushCacheRequired为 true，则会在执行器执行之前就清空本地一级缓存
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      // 清空缓存
      clearLocalCache();
    }
    List<E> list;
    try {
      // 查询堆栈 + 1
      queryStack++;
      // 1. 从一级缓存中获取数据
      list = resultHandler == null ? (List<E>) localCache.getObject(key) : null;
      if (list != null) {
        // 已有缓存结果，则处理本地缓存结果输出参数（只有存储过程会走）
        handleLocallyCachedOutputParameters(ms, key, parameter, boundSql);
      } else {
        // 2. 没有缓存结果，则从数据库查询结果
        list = queryFromDatabase(ms, parameter, rowBounds, resultHandler, key, boundSql);
      }
    } finally {
      // 查询堆栈数 -1
      queryStack--;
    }
    ...
    return list;
  }
}
  1. 查询数据的时候，首先会在一级缓存 localCache 插入占位符，然后从数据库查出数据后，将查询数据存入缓存中
public abstract class BaseExecutor implements Executor {
  ...
  protected PerpetualCache localCache;
  ...
  private <E> List<E> queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List<E> list; // key：1463130193:-1799038108:com.itheima.mapper.UserMapper.findByCondition:0:2147483647:SELECT id, name FROM  user WHERE id = ?:1:development
    // 1. 首先向本地缓存中存入一个 ExecutionPlaceholder 的枚举类占位 value
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      // 2. 执行doQuery方法
      list = doQuery(ms, parameter, rowBounds, resultHandler, boundSql);
    } finally {
      // 3. 执行完成移除这个key
      localCache.removeObject(key);
    }
    // 4. 查询结果存入缓存中
    localCache.putObject(key, list);
    // 如果 MappedStatement 的类型为CALLABLE，则向 localOutputParameterCache 缓存中存入 value 为 parameter 的缓存
    if (ms.getStatementType() == StatementType.CALLABLE) {
      localOutputParameterCache.putObject(key, parameter);
    }
    return list;
  }
}
  1. 查询到数据后，轮到执行更新语句
public class CacheTest {

  /**
   * 测试一级缓存
   */
  @Test
  public void firstLevelCacheTest() throws IOException {
    ...
    // 更新操作（通过增删改执行操作，会清除缓存）
    User user = new User();
    user.setId(1L);
    user.setName("tom");
    sqlSession.update("com.itheima.mapper.UserMapper.updateUser",user);
    sqlSession.commit();
   ...
  }
}
  1. 更新语句的执行同样创建好 MappedStatement 后，由 DefaultSqlSession 交由 CachingExecutor 执行更新操作
public class DefaultSqlSession implements SqlSession {
  ...
  private final Executor executor;
  ...
  @Override
  public int update(String statement, Object parameter) {
    try {
      dirty = true;
      MappedStatement ms = configuration.getMappedStatement(statement);
      // 1. 执行更新
      return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }
}
  1. CachingExecutor 再委派 SimpleExecutor 执行更新
public class CachingExecutor implements Executor {
  ...
  private final Executor delegate;
  ...
  @Override
  public int update(MappedStatement ms, Object parameterObject) throws SQLException {
    flushCacheIfRequired(ms);
    // 1. 执行更新
    return delegate.update(ms, parameterObject);
  }
}
  1. 在 SimpleExecutor 执行更新前，就会先去清除一级缓存，不管是否需要 commit()，然后再执行更新操作
public abstract class BaseExecutor implements Executor {
  ...
  protected PerpetualCache localCache;
  ...
  @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.");
    }
    // 1. 先清理一级缓存
    clearLocalCache();
    // 2. 再执行更新操作
    return doUpdate(ms, parameter);
  }
  
  @Override
  public void clearLocalCache() {
    if (!closed) {
      // 1.1 清理一级缓存
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }
}
  1. 从一级缓存 PerpetualCache 的清理，就完全可以看到，一级缓存就是个 Map 对象保存
public class PerpetualCache implements Cache {

  private final String id;
  private final Map<Object, Object> cache = new HashMap<>();
  ...
  @Override
  public void clear() {
    cache.clear();
  }
}
  1. 更新完数据后，然后执行 commit() 操作
public class CacheTest {

  /**
   * 测试一级缓存
   */
  @Test
  public void firstLevelCacheTest() throws IOException {
    ...
    sqlSession.commit();
   ...
  }
}
  1. DefaultSqlSession 再次委托 CachingExecutor 执行 commit() 方法
public class DefaultSqlSession implements SqlSession {

  private final Executor executor;
  ...
  @Override
  public void commit() {
    commit(false);
  }
  @Override
  public void commit(boolean force) {
    try {
      // 1. 执行 commit() 方法
      executor.commit(isCommitOrRollbackRequired(force));
      dirty = false;
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error committing transaction.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }
}
  1. CachingExecutor 则委派 SimpleExecutor 来执行 commit() 方法
public class CachingExecutor implements Executor {
  
  private final Executor delegate;
  ...
  @Override
  public void commit(boolean required) throws SQLException {
    // 1. 执行提交操作
    delegate.commit(required);
    tcm.commit();
  }
}
  1. SimpleExecutor 又会再次清理一级缓存，最后才会执行 commit() 方法
public class CachingExecutor implements Executor {

  private final Executor delegate;
  ...
  @Override
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    // 1. 一级缓存清理
    clearLocalCache();
    flushStatements();
    if (required) {
      transaction.commit();
    }
  }
  
  @Override
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }
}
  1. 更新操作后，再一次执行查询 selectOne() 的流程，但由于一级缓存清空了，所以就没办法从一级缓存获取数据，又会再次从数据库中查询，然后存入一级缓存中。具体流程看回上面的查询流程
  2. 总结
    在这里插入图片描述
Gavinjou大笨象
关注
专栏目录
【手撕MyBatis源码】动态代理、执行器与缓存
十八岁讨厌编程的博客
04-20 808
本文涉及MyBatis中的执行器与缓存方面的原理与源码解析。
『手撕 Mybatis 源码』11 - 二级缓存
Gavinjou大笨象的博客
07-03 125
/</</
手撕MyBatis源码
helloworld工程师的博客
07-20 297
简介 什么是 MyBatis？ MyBatis 是一款优秀的持久层框架，它支持自定义 SQL、存储过程以及高级映射。MyBatis 免除了几乎所有的 JDBC 代码以及设置参数和获取结果集的工作。MyBatis 可以通过简单的 XML 或注解来配置和映射原始类型、接口和 Java POJO（Plain Old Java Objects，普通老式 Java 对象）为数据库中的记录。 摘自mybatis官网 官网地址https://mybatis.org/mybatis-3/zh/index.html.
思维导图手撕MyBatis源码
十八岁讨厌编程的博客
04-11 1338
使用思维导图理解MyBatis源码
一行行手撕mybatis源码
weixin_44162368的博客
01-30 235
一、 首先介绍几个类。 1、SqlSessionFactoryBuilder 用来构建SqlSessionFactory (默认为DefaultSqlSessionFactory) 2、SqlSessionFactory sqlsession的创建工厂接口。 3、XMLConfigBuilder 用来构建生成Configuration类（全局配置类，也就是mybatis的配置文件对用的java类）。 4、XPathParser 位于XMLConfigBuilder ，用来读取xml文件流，解析的各个标签，
『手撕 Mybatis 源码』05 - SqlSession 执行主流程
Gavinjou大笨象的博客
06-10 662
SqlSession 执行主流程 获取 BoundSql 经过加载完所有配置之后，继续梳理执行 sql 的过程 public class MybatisTest { @Test public void test1() throws IOException { ... // 4. 委派给 Executor 来执行，Executor 执行时又会调用很多其他组件（参数设置、解析 sql 的获取，sql 的执行、结果集的封装） User user = sqlSession.selectOne("u
【手撕MyBatis源码】MyBatis启动流程、Configuration配置体系
十八岁讨厌编程的博客
06-13 1197
本文涉及Configuration概述、Configuration的核心作用与配置来源、配置元素、元素承载、配置文件解析等内容。
【手撕MyBatis源码】JDBC处理器StatementHandler
十八岁讨厌编程的博客
05-25 1383
本文涉及StatemenHandler的定义与结构、PreparedStatemenHandler的执行流程、参数处理、结果集处理等内容。
『手撕 Mybatis 源码』01 - 基本原理与搭建
Gavinjou大笨象的博客
05-14 290
【代码】『手撕 Mybatis 源码』01 - 基本原理与搭建。
Java教程：手撕MybatisPlus分页原理
CZ-001的博客
08-05 982
构建分页构造器(需要传递分页条件 current,size)构建条件构造器(支持条件分页查询)执行查询方法,完成查询解析查询后结果MybatisPlus核心插件 MybatisPlusInterceptor,基于该插件mp实现了丰富的特性,该插件是核心插件,目前代理了和和方法.也就是说该插件可以对查询的执行,增删改的执行以及预处理对象进行功能性的增强.那么是如何对sql实现拦截增强的呢,我们就要研究一下该分页插件的拦截器集合属性.我们提供的插件都将基于此接口来实现功能目前已有的功能:s。...
MyBatis逆向生成 快速生成JavaBean、Mapper接口和xml映射文件
weixin_45184159的博客
07-14 422
提示：这是MyBatis的第六篇，有兴趣的话可以看下： 一： MyBatis复习笔记整理 二： MyBatis的resultMap标签 自定义封装返回值类型 三： MyBatis动态SQL官方文档 四： MyBatis动态SQL学习笔记 五：MyBatis缓存的使用和配置 文章目录MyBatis逆向工程1、引入依赖2、编写配置文件3、编写main方法开始生成4、测试 MyBatis逆向工程 1、引入依赖 mybatis-generator-core：mybatis逆向工程核心jar包 <de
教你手撕MybatisPlus分页原理
weixin_62421895的博客
08-08 473
构建分页构造器(需要传递分页条件 current,size)构建条件构造器(支持条件分页查询)执行查询方法,完成查询解析查询后结果MybatisPlus核心插件 MybatisPlusInterceptor,基于该插件mp实现了丰富的特性,该插件是核心插件,目前代理了和和方法.也就是说该插件可以对查询的执行,增删改的执行以及预处理对象进行功能性的增强.那么是如何对sql实现拦截增强的呢,我们就要研究一下该分页插件的拦截器集合属性.widows: 2;...
剑指大厂，手撕 Java 八股文
热门推荐
激流丶的博客
05-30 1万+
java 知识的汇总贴，包含八股文。知识讲解详细。 tip: 此贴为目录贴，定期更新toNew: 时间是最好的答案，它能解决所有问题。坚持！！！
强烈推荐！史上最有深度的Java学习视频，Mybatis、Javaweb、SSM框架项目
Moonxiyue的博客
07-26 607
主讲课程为Mybatis框架。这门课程有两门前驱的课JavaSE和Javaweb，后继还有Spring框架和SpringMVC框架，微服务框架和互联网分布式技术。
MybatisPlus的LambdaQueryWrapper用法
2301_79693537的博客
08-21 5364
【代码】MybatisPlus的LambdaQueryWrapper用法。
减少重复的请求之promise缓存池（构造器版） —— 缓存promise，多次promise等待并返回第一个promise的结果
最新发布
weixin_45549481的博客
09-29 274
2、构造器实例，必须在初始化调用接口的组件外部使用，才能起到缓存promise的作用；放在组件内，每次都会创建一个全新的缓存池。当一个业务组件初始化调用了接口，统一个页面多吃使用同一个组件，将会请求大量重复的接口。1、promise一旦新建就会立即执行，所以 要将promise保成函数传入；3、记得要处理promise rejected的场景。公共的地方设置异步缓存池的构造器以及公共的构造器实例。
java：缓存 json格式
hongyuxiongji的博客
09-28 555
在这段代码中，将实体类转换为 JSON 格式字符串进行存储。当需要获取数据时，可以从缓存中取出 JSON 字符串，再转换回实体类对象进行使用。这样可以方便地存储和组装数据。// 如果数据不同或者未缓存，更新缓存并记录日志。// 使用 MyBatis 查询数据库数据并获取列表。// 假设你已经正确配置了连接工厂。// 假设的数据库实体类。
javaScript中如何实现函数缓存，案例解析
misstianyun的博客
09-29 1078
在 JavaScript 中，函数缓存（也称为 memoization）是一种通过存储函数的调用结果来避免重复计算的技术。当函数多次被调用时，如果传入的参数是相同的，则可以直接返回之前计算的结果，而不必重复计算，提升了性能。本篇通过一个案例详细讲解了什么是函数缓存以及如何实现。
MyBatis源码深度解析：一二级缓存机制揭秘
"本文将深入解析MyBatis的一二级缓存机制，帮助理解其工作原理，提升数据库操作效率。" 在数据库交互中，缓存是一种重要的性能优化手段，它能够减少对数据库的直接访问，从而提高应用程序的响应速度。MyBatis作为一...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值