栏目分类:
子分类:
返回
名师互学网用户登录
快速导航关闭
当前搜索
当前分类
子分类
实用工具
热门搜索
名师互学网 > IT > 软件开发 > 后端开发 > Java

mybatis一级缓存

Java 更新时间: 发布时间: IT归档 最新发布 模块sitemap 名妆网 法律咨询 聚返吧 英语巴士网 伯小乐 网商动力

mybatis一级缓存

一、现象

1、在同一个session里面调用两次查询

    @Resource
    private SqlSessionFactory sqlSessionFactory;

    @Test
    public void test1() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
        List list = orderDao.selectList("77");
        System.out.println(String.format("第一次查询:%s", JSON.toJSON(list)));

        List list2 = orderDao.selectList("77");
        System.out.println(String.format("第二次查询:%s", JSON.toJSON(list2)));
        sqlSession.close();
    }

开启mybatis打印日志:

mybatis.configuration.log-impl=org.apache.ibatis.logging.stdout.StdOutImpl


2、在同一个session里面调用两次查询并在中间插入一个insert

@Test
    public void test1() {
        SqlSession sqlSession = sqlSessionFactory.openSession();
        OrderDao orderDao = sqlSession.getMapper(OrderDao.class);
        List list = orderDao.selectList("77");
        System.out.println(String.format("第一次查询:%s", JSON.toJSON(list)));
        
        insert(orderDao);
        
        List list2 = orderDao.selectList("77");
        System.out.println(String.format("第二次查询:%s", JSON.toJSON(list2)));
        sqlSession.close();
    }

    private void insert(OrderDao orderDao) {
        Order order = new Order();
        order.setOrderNo("123");
        order.setUserId("1");
        order.setCommodityCode("123");
        order.setCount(1);
        order.setAmount(new BigDecimal("100"));
        orderDao.insertOrder(order);
    }


3、在1的基础上关闭mybatis一级缓存,连着执行两次查询

mybatis.configuration.local-cache-scope=statement

二、一级缓存的本质

1、从org.apache.ibatis.binding.MapperProxy.PlainMethodInvoker#invoke一路debug进来,发现执行query的是CachingExecutor

2、CachingExecutor

  @Override
  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler) throws SQLException {
    BoundSql boundSql = ms.getBoundSql(parameterObject);
    // 创建缓存key,实际由BaseExecutor#createCacheKey创建
    CacheKey key = createCacheKey(ms, parameterObject, rowBounds, boundSql);
    return query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

  @Override
  public  List query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    // 二级缓存,默认未开启
    Cache cache = ms.getCache();
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        List list = (List) tcm.getObject(cache, key);
        if (list == null) {
          list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
          tcm.putObject(cache, key, list); // issue #578 and #116
        }
        return list;
      }
    }
    // 执行到BaseExecutor.query
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

cacheKey结构:

3、BaseExecutor

  @Override
  public  List 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.");
    }
    if (queryStack == 0 && ms.isFlushCacheRequired()) {
      clearLocalCache();
    }
    List list;
    try {
      queryStack++;
      // 从一级缓存中获取结果集,可见loaclCache就是一级缓存
      // 点进去发现,cache其实就是private Map cache = newHashMap();
      list = resultHandler == null ? (List) 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 (DeferredLoad deferredLoad : deferredLoads) {
        deferredLoad.load();
      }
      deferredLoads.clear();
      // 若关闭一级缓存,则清除掉一级缓存,其实就是map.clear()
      if (configuration.getLocalCacheScope() == LocalCacheScope.STATEMENT) {
        clearLocalCache();
      }
    }
    return list;
  }
  
  // 查询数据库
  private  List queryFromDatabase(MappedStatement ms, Object parameter, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql) throws SQLException {
    List list;
    // 先把计算出来的key缓存放入一个占位符
    localCache.putObject(key, EXECUTION_PLACEHOLDER);
    try {
      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;
  }

3、一级缓存的清理,在会话结束时,最终BaseExecutor执行clear

  // sqlSession执行close
  @Override
  public void close(boolean forceRollback) {
    try {
      try {
        rollback(forceRollback);
      } finally {
        if (transaction != null) {
          transaction.close();
        }
      }
    } catch (SQLException e) {
      // Ignore. There's nothing that can be done at this point.
      log.warn("Unexpected exception on closing transaction.  Cause: " + e);
    } finally {
      transaction = null;
      deferredLoads = null;
      localCache = null;
      localOutputParameterCache = null;
      closed = true;
    }
  } 
  // 当前事务被提交,清理一级缓存
  @Override
  public void commit(boolean required) throws SQLException {
    if (closed) {
      throw new ExecutorException("Cannot commit, transaction is already closed");
    }
    clearLocalCache();
    flushStatements();
    if (required) {
      transaction.commit();
    }
  }

  // 当前事务被rollback,清理一级缓存
  @Override
  public void rollback(boolean required) throws SQLException {
    if (!closed) {
      try {
        clearLocalCache();
        flushStatements(true);
      } finally {
        if (required) {
          transaction.rollback();
        }
      }
    }
  }

  @Override
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }

4、当修改表数据时,也会触发清理一级缓存 == BaseExecutor

  @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);
  }
  
  @Override
  public void clearLocalCache() {
    if (!closed) {
      localCache.clear();
      localOutputParameterCache.clear();
    }
  }
三、总结

1、一级缓存是SqlSession级别的缓存;
2、当SqlSession提交、关闭以及其他的更新数据库的操作发生后,一级缓存就会清空;
3、分布式系统中,会有读取脏数据的可能,A服务更新数据,B服务查到了旧缓存,可配置 mybatis.configuration.local-cache-scope=statement 关闭一级缓存 或者 在SQL语句上设置 flushCache=“true” 。

转载请注明:文章转载自 www.mshxw.com
本文地址:https://www.mshxw.com/it/985903.html
我们一直用心在做
关于我们 文章归档 网站地图 联系我们

版权所有 (c)2021-2022 MSHXW.COM

ICP备案号:晋ICP备2021003244-6号