4.二级缓存解析

已于 2023-01-26 21:04:17 修改
阅读量4k 收藏 5
点赞数
分类专栏： Mybatis源码 文章标签： mybatis 二级缓存 缓存事务管理器 暂存区
于 2023-01-16 19:06:56 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/u010502101/article/details/128622875
版权

文章目录


二级缓存也称作是应用级缓存，与一级缓存不同的，是它的作用范围是整个应用，而且可以跨线程使用。所以二级缓存有更高的命中率，适合缓存一些修改较少的数据。在流程上是先访问二级缓存，在访问一级缓存。

1. 二级缓存配置

mybatis要使二级缓存生效可采用下面两种方式：配置文件方式和注解方式。
第一种配置文件方式，首先在mybatis的全局配置文件添加如下配置，负责总开启二级缓存的开关，当然如不设置，也是默认开启的。

<settings>
    <!--开启二级缓存-->
    <setting name="cacheEnabled" value="true"/>
</settings>

总开关打开后，若要使哪个mapper文件的二级缓存生效，还需要在各自的mapper中添加<cache></cache>标签，如下所示

<?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">

<!--namespace为UserDao接口的全类名-->
<mapper namespace="com.lzj.dao.UserDao">
    <cache></cache>
    <!--selectOne要与UserDao接口中的接口方法名一致-->
    <!--parameterType和resultType指定的类型除了基本类型外，自定义的类要用全类名-->
    <select id="selectOne" parameterType="int" resultType="com.lzj.bean.User">
        select * from user where id=#{id}
    </select>

    <select id="selectById" parameterType="int" resultType="com.lzj.bean.User">
        select * from user where id=#{id}
    </select>

    <update id="updAge" parameterType="com.lzj.bean.User">
        update user set age=#{age} where id=#{id}
    </update>

    <insert id="insert" parameterType="com.lzj.bean.User">
        insert into user values (#{id},#{name},#{age})
    </insert>
</mapper>

第二种方式是注解方式，需要在对应的Mapper接口类上添加@CacheNamespace 注解。

2. 二级缓存结构

二级缓存包括存储、溢出淘汰、过期清理、线程安全、命中率统计、序列化等功能。

其中二级缓存最基本的存储功能K-V形式实现的。

二级缓存的溢出淘汰功能用到的溢出算法包括下述4种：

  • FIFO：先进先出；
  • LRU：最近最少使用；
  • WeakReference: 弱引用，将缓存对象进行弱引用包装，当Java进行gc的时候，不论当前的内存空间是否足够，这个对象都会被回收；
  • SoftReference：软件引用，基机与弱引用类似，不同在于只有当空间不足时GC才才回收软引用对象。

过期清理功能指清理存放数据过久的数据。

线程安全可以保证缓存可以被多个线程同时使用。

mybatis实现这些功能是通过责任链设计模式+装饰器模式实现的。

下面看下mybatis是如何通过责任链设计模式+装饰器模式实现二级缓存各个功能的。如下图所示
在这里插入图片描述

首先Myatis定义了Cache接口，只定义了Cache基本功能，每一个实现类只执行一种功能，遵守责任单一原则。从上图最左边看，BlockingCache装饰了SynchronizedCache，SynchronizedCache又装饰了LoggingCache，每一个缓存类一次向右进行装饰，当代码执行时先从最右边的被装饰类开始执行，然后依次向左执行装饰类，就像在一个链条上依次执行各个功能一样。

具体的可以通过断点方式查看mybatis二级缓存依次执行的缓存类

public void test1(){
    SqlSessionFactory factory = mybatisUtil.getFactory();
    SqlSession sqlSession = factory.openSession(false);  //true表示自动提交
    List<Object> list = sqlSession.selectList("com.lzj.dao.UserDao.selectOne", 2);
    sqlSession.commit();
    list = sqlSession.selectList("com.lzj.dao.UserDao.selectOne", 2);
    Configuration configuration = mybatisUtil.getConfiguration();
    Cache cache = configuration.getCache("com.lzj.dao.UserDao");
    System.out.println(list);
}

断点后可以查看Cache的默认缓存执行顺序如下所示，先执行delegate被装饰的缓存类，当然还可以设置其他缓存类到责任链上。
在这里插入图片描述

3. 二级缓存命中条件

命中二级缓存还需要满足下面4个条件：

  • 必须会话提交后才生效；
  • SQL的语句和参数必须相同；
  • StatementID必须相同；
  • RowBounds分页条件必须相同；

3.1 必须会话提交后才生效
首先看下面的测试案例

    public void test1(){
        SqlSessionFactory factory = mybatisUtil.getFactory();
        SqlSession sqlSession = factory.openSession(false);  //true表示自动提交
        List<Object> list = sqlSession.selectList("com.lzj.dao.UserDao.selectOne", 2);
        list = sqlSession.selectList("com.lzj.dao.UserDao.selectOne", 2);
        System.out.println(list);
    }

执行该案例，输出结果如下所示，两次SQL日志显示Cache Hit Ratio [com.lzj.dao.UserDao]: 0.0，说明两次查询都未命中缓存。因为二级缓存是跨线程级别的，假设一个线程A正在修改缓存空间中的一条SQL，此时有另外一个线程B需要读这个缓存空间的SQL，如果A线程修改未提交就生效的话，B线程就立即读到缓存中修改的数据，而如果线程B后续操作失败了需要回滚，那么B线程就是读到的脏数据了，所以会话必须提交后缓存才生效。

2023-01-11 22:39:16.991  INFO 2764 --- [nio-8004-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2023-01-11 22:39:16.991  INFO 2764 --- [nio-8004-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-01-11 22:39:17.024  INFO 2764 --- [nio-8004-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 33 ms
2023-01-11 22:39:17.099 DEBUG 2764 --- [nio-8004-exec-1] com.lzj.dao.UserDao                      : Cache Hit Ratio [com.lzj.dao.UserDao]: 0.0
2023-01-11 22:39:17.190 DEBUG 2764 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : ==>  Preparing: select * from user where id=? 
2023-01-11 22:39:17.291 DEBUG 2764 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : ==> Parameters: 2(Integer)
2023-01-11 22:39:17.419 DEBUG 2764 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : <==      Total: 1
2023-01-11 22:39:17.426 DEBUG 2764 --- [nio-8004-exec-1] com.lzj.dao.UserDao                      : Cache Hit Ratio [com.lzj.dao.UserDao]: 0.0
[User{id=2, name='xiaoli', age=26}]

3.2. SQL的语句和参数必须相同

public void test1(){
    SqlSessionFactory factory = mybatisUtil.getFactory();
    SqlSession sqlSession = factory.openSession(false);  //true表示自动提交
    List<Object> list = sqlSession.selectList("com.lzj.dao.UserDao.selectOne", 2);
    sqlSession.commit();
    list = sqlSession.selectList("com.lzj.dao.UserDao.selectOne", 2);
    System.out.println(list);
}

运行上面测试案例，输出结果如下所示第一次执行selectOne时，参数为2，日志显示Cache Hit Ratio为0.0，未命中二级缓存。当commit后再次查询selectOne，参数还是2时，Cache Hit Ratio显示为0.5，表示命中了二级缓存。如果第二次查询的SQL不是selectOne或者参数不是2时，也不会命中二级缓存。

2023-01-11 22:50:53.498  INFO 14000 --- [nio-8004-exec-1] o.a.c.c.C.[Tomcat].[localhost].[/]       : Initializing Spring DispatcherServlet 'dispatcherServlet'
2023-01-11 22:50:53.506  INFO 14000 --- [nio-8004-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-01-11 22:50:53.539  INFO 14000 --- [nio-8004-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 33 ms
2023-01-11 22:50:53.645 DEBUG 14000 --- [nio-8004-exec-1] com.lzj.dao.UserDao                      : Cache Hit Ratio [com.lzj.dao.UserDao]: 0.0
2023-01-11 22:50:53.721 DEBUG 14000 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : ==>  Preparing: select * from user where id=? 
2023-01-11 22:50:53.797 DEBUG 14000 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : ==> Parameters: 2(Integer)
2023-01-11 22:50:53.865 DEBUG 14000 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : <==      Total: 1
2023-01-11 22:50:53.897 DEBUG 14000 --- [nio-8004-exec-1] com.lzj.dao.UserDao                      : Cache Hit Ratio [com.lzj.dao.UserDao]: 0.5
[User{id=2, name='xiaoli', age=26}]

3.3. StatementID必须相同；
首先看下面测试案例

public void test2(){
    SqlSessionFactory factory = mybatisUtil.getFactory();
    SqlSession sqlSession = factory.openSession(false);  //true表示自动提交
    List<Object> list = sqlSession.selectList("com.lzj.dao.UserDao.selectOne", 2);
    sqlSession.commit();
    list = sqlSession.selectList("com.lzj.dao.UserDao.selectById", 2);
    System.out.println(list); 
}

两次查询对应的SQL如下所示

<select id="selectOne" parameterType="int" resultType="com.lzj.bean.User">
    select * from user where id=#{id}
</select>

<select id="selectById" parameterType="int" resultType="com.lzj.bean.User">
    select * from user where id=#{id}
</select>

发现两次查询额SQL是一样的，只是对应的StatementID不同，分别诶selectOne和selectById，测试结果如下所示，发现两次查询日志都显示Cache Hit Ration为0.0，表示未命中缓存。因此哪怕SQL相同，如果StatementID不同也无法命中二级缓存。

2023-01-11 23:05:48.278  INFO 3488 --- [nio-8004-exec-1] o.s.web.servlet.DispatcherServlet        : Initializing Servlet 'dispatcherServlet'
2023-01-11 23:05:48.297  INFO 3488 --- [nio-8004-exec-1] o.s.web.servlet.DispatcherServlet        : Completed initialization in 19 ms
2023-01-11 23:05:48.373 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao                      : Cache Hit Ratio [com.lzj.dao.UserDao]: 0.0
2023-01-11 23:05:48.455 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : ==>  Preparing: select * from user where id=? 
2023-01-11 23:05:48.546 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : ==> Parameters: 2(Integer)
2023-01-11 23:05:48.614 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectOne            : <==      Total: 1
2023-01-11 23:05:48.638 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao                      : Cache Hit Ratio [com.lzj.dao.UserDao]: 0.0
2023-01-11 23:05:48.638 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectById           : ==>  Preparing: select * from user where id=? 
2023-01-11 23:05:48.639 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectById           : ==> Parameters: 2(Integer)
2023-01-11 23:05:48.641 DEBUG 3488 --- [nio-8004-exec-1] com.lzj.dao.UserDao.selectById           : <==      Total: 1
[User{id=2, name='xiaoli', age=26}]

3.4 RowBounds分页条件必须相同
如果分页条件都不一致，查询的页数都不同，也必定不会命中缓存了。

4. 缓存空间的理解

在mybatis中并不是查询完SQL就就立即缓存到缓存空间中的，而是先缓存到暂存区中，会话提交后才会把暂存区的SQL缓存到缓存空间中，这样操作的好处就是当会话回滚的话，直接删除事务缓存管理器，当然暂存区也一并删除了，无须再回滚缓存空间了。
在执行中，每个会话都会维护一个事务缓存管理器，每个事务缓存管理器又会维护一个或者多个暂存区，这要取决于本次会话中共操作了几个缓存空间，也即共操作了几个Mapper文件，比如本次会话中即要用到UserMapper又要用到CustomerMapper，那么事务缓存管理器就要维护2个暂存区。
在这里插入图片描述
通过如下断点方式可以看出，二级缓存执行器CachingExecutor中维护了一个TransactionalCacheManager事务管理器，事务管理器内部维护了一个HashMap<Cache, TransactionalCache>类型的transactionalCaches变量，transactionalCaches就可以理解为暂存区，下面测试案例中由于只用到了UserMapp.xml，所以暂存区中缓存的数量为1。
在这里插入图片描述
暂存区的key为Cache，表示二级缓存的key，也可以理解为二级缓存责任链中的第一个Cache实现类的对象，此处案例默认的是SynchronizedCache的对象。暂存区的value为TrasactionalCache的对象，TrasactionalCache也是实现了Cache，并且内部也是维护了一个delegate变量，而delegate表示二级缓存空间，即上面介绍的二级缓存责任链方式，此处运用了装饰器模式+责任链模式维护了暂存区。由于暂存区与缓冲区结构一致，当会话提交时就可以比较方便的把暂存区内容同步到二级缓冲区中了。

public class TransactionalCache implements Cache {

  private static final Log log = LogFactory.getLog(TransactionalCache.class);

  private final Cache delegate;
  private boolean clearOnCommit;
  private final Map<Object, Object> entriesToAddOnCommit;
  private final Set<Object> entriesMissedInCache;

  public TransactionalCache(Cache delegate) {
    this.delegate = delegate;
    this.clearOnCommit = false;
    this.entriesToAddOnCommit = new HashMap<>();
    this.entriesMissedInCache = new HashSet<>();
  }
  ……
  ……
  ……

5. 二级缓存执行流程

二级缓存执行流程的核心方法是CachingExecutor下面的query方法，如下所示。

  @Override
  public <E> List<E> 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<E> 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;
      }
    }
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }

下面逐步进行分析，
1.首先执行Cache cache = ms.getCache();，表示通过MapStatement获取缓存，只有在Mapper文件中配置了<cache/>,<cache-ref/>或在Dao方法上添加了注解@CacheNamespace,@CacheNamespaceRef的，获取的cache才不为null。

2.如果配置的不开启二级缓存，执行return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);，就会通过代理的执行器，即如未特别指定，默认为SimpleExecutor，去数据库中去查找。

3.如果配置了二级缓存的话，执行flushCacheIfRequired(ms);，会根据sql上配置的<insert>,<select>,<update>,<delete>的flushCache属性来确定是否清空缓存。

  private void flushCacheIfRequired(MappedStatement ms) {
    Cache cache = ms.getCache();
    /*ms.isFlushCacheRequired()解析flushCache属性，insert/update/delete默认配置的清空缓存，select默认不清空，当然也可以配置清空，则查询也会清空二级缓存，就没什么意义了*/
    if (cache != null && ms.isFlushCacheRequired()) {
      tcm.clear(cache);
    }
  }

其中清空缓存的clear方法如下所示，是清空暂存区TransactionCache中的entriesToAddOnCommit，而entriesToAddOnCommit是HashMap类型的，key为缓存key，value则为缓存的数据，下面会看如何把数据缓存进去的。也就是说当清空缓存时会首先清空暂存区中的缓存。

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

4.下面继续判断Mapper是否配置二级缓存if (ms.isUseCache() && resultHandler == null)，就是有没有在Mapper文件中配置<cache/>,<cache-ref/>或在Dao方法上添加注解@CacheNamespace,@CacheNamespaceRef。一般resultHandler 默认都是null。

5.下面继续校验输入的参数是否合法，<insert>,<select>,<update>,<delete>中不能配置Out类型的参数，mybatis不支持存储过程的缓存，所以如果是存储过程，这里就会报错。

private void ensureNoOutParams(MappedStatement ms, BoundSql boundSql) {
    if (ms.getStatementType() == StatementType.CALLABLE) {
      for (ParameterMapping parameterMapping : boundSql.getParameterMappings()) {
        if (parameterMapping.getMode() != ParameterMode.IN) {
          throw new ExecutorException("Caching stored procedures with OUT params is not supported.  Please configure useCache=false in " + ms.getId() + " statement.");
        }
      }
    }
  }

6.下面最重要的一点就是从暂存区中获取暂存的数据 List<E> list = (List) tcm.getObject(cache, key);，如果暂存区没有就从数据库中查出来缓存到暂存区。
在从暂存区获取数据时首先获取暂存区，如果还未有暂存区就创建一个维护到缓存事务管理器中。

  public Object getObject(Cache cache, CacheKey key) {
    return getTransactionalCache(cache).getObject(key);
  }

获取到暂存区TrasactionalCache后，就可以调用getObject开始从缓存空间中查询数据了，注意下面当标签上属性flushCache配置成true清空缓存或者<insert>,<update>,<delete>标签时，clearOnCommit都会被赋值为true，清空本地暂存区，但还没有清空二级缓存，如果在此地就清空二级缓存，其它会话还是会继续从二级缓存中继续读数据的，只有当本会话commit后才会真正的清空二级缓存，防止事务回滚，误清空二级缓存。

  @Override
  public Object getObject(Object key) {
    // issue #116
    /*直接从缓存空间中获取数据，注意不是从暂存区中获取数据*/
    Object object = delegate.getObject(key);
    if (object == null) {
      /*如果缓存空间中没有，就把key缓存到entriesMissedInCache中*/
      entriesMissedInCache.add(key);
    }
    // issue #146
    /*判断是否被清空缓存，有标签上配置了flushCache属性，或者是增删改标签就会把缓存暂存区清空，此时即使二级缓存有数据，那么此时也是直接返回null，等commit后才会把二级缓存中的数据真正的清空*/
    if (clearOnCommit) {
      return null;
    } else {
      return object;
    }
  }

7.如果从缓存空间中获取数据了就直接返回了，如果未从缓存空间中获取到数据，还是要查询数据库，并把数据先缓存到暂存空间的

if (list == null) {
  list = delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  tcm.putObject(cache, key, list); // issue #578 and #116
}

CachingExecutor中，如未指定，默认delegate代理的是SimpleExecutor执行器，会直接先查一级缓存然后查数据库的，查到的数据再执行tcm.putObject(cache, key, list)，把数据先放到暂存区中，缓存到暂存区其实就是先存放到TransactionalCache暂存区中的HashMap类型的entriesToAddOnCommit变量中，等commit后再把暂存区中数据库同步到二级缓存中，防止事务回滚。

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

8.执行完上述query方法后，会话最后会调用CachingExecutor.commit方法进行事务提交，其实就是缓存事务管理器的提交。执行commit时会首先执行delegate.commit进行数据库的事务的提交，然后执行tcm.commi进行缓存事务管理器TransactionalCacheManager的提交。

  /*CachingExecutor*/
  @Override
  public void commit(boolean required) throws SQLException {
    delegate.commit(required);
    tcm.commit();
  }

在执行TransactionalCacheManager缓存事务管理器提交时，会对缓存事务管理器维护的暂存区分别进行提交，比如本案例只用了UserMapper一个Mapper文件，则只有一个暂存区。

  /*TransactionalCacheManager*/
  public void commit() {
    for (TransactionalCache txCache : transactionalCaches.values()) {
      txCache.commit();
    }
  }

在执行暂存区commit时，如果前面已经把清空标志设置成了true，则此时会清空二级缓存，增删改默认都会设置该标志位true的。前面分析过，暂存区中delegate是代理的二级缓存。

  /*TransactionalCache */
  public void commit() {
    /*如果清空标志位true，则清空二级缓存*/
    if (clearOnCommit) {
      delegate.clear();
    }
    /*如果清空标志位false，则把暂存区中数据同步到二级缓存中*/
    flushPendingEntries();
    reset();
  }

在暂存区中数据同步到二级缓存时entriesToAddOnCommit中的数据直接添加到二级缓存中，entriesMissedInCache中的key如果不是在entriesToAddOnCommit中的就会缓存一个null到二级缓存中，防止缓存穿透。

  private void flushPendingEntries() {
    /*entriesToAddOnCommit表示暂存在暂存区中的key-value数据*/
    for (Map.Entry<Object, Object> entry : entriesToAddOnCommit.entrySet()) {
      delegate.putObject(entry.getKey(), entry.getValue());
    }
    /*entriesMissedInCache表示查询数据库也会获取到数据，此时把null缓存到二级缓存中，防止缓存穿透*/
    for (Object entry : entriesMissedInCache) {
      if (!entriesToAddOnCommit.containsKey(entry)) {
        delegate.putObject(entry, null);
      }
    }
  }

执行完commit后，以上二级缓存流程执行完毕，借用源码阅读网上执行流程图如下所示。
在这里插入图片描述

参考文献：源码阅读网

苍鹰蛟龙
关注
专栏目录
二级缓存（L2 CACHE）
yanting_shi的专栏
01-16 3549
二级缓存　　二级缓存又叫L2 CACHE，它是处理器内部的一些缓冲存储器，其作用跟内存一样。 它是怎么出现的呢？ 要上溯到上个世纪80年代，由于处理器的运行速度越来越快，慢慢地，处理器需要从内存中读取数据的速度需求就越来越高了。然而内存的速度提升速度却很缓慢，而能高速读写数据的内存价格又非常高昂，不能大量采用。从性能价格比的角度出发，英特尔等处理器设计生产公司想到一个办法，就是用少量的高速内存和大
二级缓存
w649800415的博客
08-31 1417
一.一级缓存与二级缓存 一级缓存： Hibernate默认是开启一级缓存的，一级缓存存放在session上，属于事务级数据缓冲。 二级缓存： 二级缓存是在SessionFactory，所有的Session共享同一个二级Cache。二级Cache的内部如何实现并不重要，重要的是采用哪种正确的缓存策略，以及采用哪个Cache提供器。 二.二级缓存的配置 1.在hibernate.cfg.x...
11. MyBatis的一级缓存和二级缓存有什么区别？如何配置和使用二级缓存？
最新发布
zhzjn的博客
09-07 1094
在 MyBatis 中，缓存机制用于减少数据库访问次数，提高应用程序性能。MyBatis 提供了两级缓存：一级缓存和二级缓存。1. 一级缓存（Local Cache）：一级缓存作用于SqlSession级别。即在同一个SqlSession中执行相同的 SQL 查询，如果查询参数相同，MyBatis 会从缓存中直接返回结果，而不会再次查询数据库。：一级缓存是默认开启的，并且无法关闭。：一级缓存的生命周期与SqlSession的生命周期一致。当SqlSession关闭后，一级缓存也随之被清空。：在。
缓存机制（二级缓存）
WuHuaSen的博客
04-10 2239
二级缓存也称为sqlsessionFactory级缓存，通过同一个factory获取的sqlsession可以共享二级缓存，在应用服务器中sqlsessionfactory是单例的，因此二级缓存可以实现全局共享 特性： 1、二级缓存默认是没有开启的，需要在mybatis-config.xml文件中通过<Setting>标签进行手动开启 2、二级缓存只能缓存实现序列化接口的对象 使用步骤： 1、在mybatis-config.xml开启使用二级缓存 &l...
二级缓存的作用是什么
purpen
04-01 1360
先我们来简单了解一下一级缓存。目前所有主流处理器大都具有一级缓存和二级缓存，少数高端处理器还集成了三级缓存。其中，一级缓存可分为一级指令缓存和一级数据缓存。一级指令缓存用于暂时存储并向CPU递送各类运算指令；一级数据缓存用于暂时存储并向CPU递送运算所需数据，这就是一级缓存的作用 那么，二级缓存的作用又是什么呢？简单地说，二级缓存就是一级缓存的缓冲器：一级缓存制造成本很高因此它的容量有限，二级缓存...
Mybatis-plus基于redis实现二级缓存过程解析
08-18
Mybatis-plus基于Redis实现二级缓存过程解析 Mybatis-plus是一款基于Java语言的持久层框架，旨在简化数据库交互操作。然而，在高并发、高性能的应用场景中，数据库的查询操作可能会成为性能瓶颈。为了解决这个问题...
MyBatis开启二级缓存实现过程解析
08-18
MyBatis二级缓存实现过程解析 MyBatis是一款流行的持久层框架，它提供了强大的缓存机制来提高应用程序的性能。MyBatis的一级缓存是sqlSession作用域的，默认开启，执行DML(insert, update, delete)操作后自动删除。...
【MyBatis源码全面解析】MyBatis一二级缓存介绍
08-30
MyBatis一二级缓存介绍 MyBatis是一款流行的Java持久层框架，它提供了一种简洁的方式来访问和操作数据库。MyBatis中的缓存机制是为了提高数据库操作的性能，减少数据库查询的次数。下面将详细介绍MyBatis的一二级...
Hibernate4二级缓存实例（源码）
07-08
**标题解析：**“Hibernate4二级缓存实例（源码）” 这个标题表明我们将探讨一个具体的应用示例，即如何在Hibernate4框架中实现实现二级缓存，并且提供了源码供参考。Hibernate是一个流行的Java对象关系映射（ORM）...
深入了解MyBatis二级缓存
08-26
"深入了解MyBatis二级缓存" MyBatis是一种流行的Java持久层框架，它提供了强大的缓存机制以提高应用程序的性能。其中，二级缓存是MyBatis中的一种高级缓存机制，它可以将查询结果缓存在内存中，以便下次查询时直接...
6.二级缓存
wangbo199308的博客
09-05 1207
1.二级缓存概述 前一章节介绍了一级缓存即会话级别的缓存，同一个会话SqlSession才能共享缓存。如果多个 SqlSession 需要共享缓存，则需要开启二级缓存，开启二级缓存后，会使用 CachingExecutor 装饰 Executor，进入一级缓存的查询流程前，先在CachingExecutor 进行二级缓存的查询。 二级缓存也称作是应用级缓存，与一级缓存不同的，是它的作用范围是整个应用，而且可以跨线程使用。所以二级缓存有更高的命中率，适合缓存一些修改较少的数据。在流程上是先访问二级缓存，再访问
【hibernate框架】缓存机制之二级缓存
weixin_33958585的博客
03-08 130
二级缓存是sessionFactory级别的缓存，可以跨越session存在。 hibernate文档里关于二级缓存的说明： 二级缓存(The Second Level Cache) hibernate支持多种多样的二级缓存的实现，但hibernate本身并没有写二级缓存的实现(有一个是用来内部测试的，不要用于产品开发)，而是由其他的厂商来提供。 表 ...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值