Mybatis之缓存详细解析

最新推荐文章于 2024-07-25 23:40:47 发布
最新推荐文章于 2024-07-25 23:40:47 发布
阅读量1k 收藏
点赞数
分类专栏： MyBatis 文章标签： 缓存 java redis mybatis
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45538589/article/details/122317802
版权

Mybatis之缓存详细解析

文章目录

一、Cache 缓存

缓存的目的就是提升查询的效率和减少数据库的压力，在MyBatis中提供了一级缓存和二级缓存，并且预留了集成第三方缓存的接口。MyBatis中跟缓存相关的类都在cache包里面，其中有一个Cache接口，只有一个默认的实现类PerpetualCache，除此之外，还有很多的装饰器，通过这些装饰器可以额外实现很多的功能：回收策略，记录日志，定时刷新等
所有的缓存实现类总体上可分为三类：基本缓存、淘汰算法缓存、装饰器缓存

缓存实现类描述作用装饰条件
基本缓存缓存基本实现类默认是 PerpetualCache，也可以自定义比如 RedisCache、EhCache 等，具备基本功能的缓存类无
LruCacheLRU 策略的缓存当缓存到达上限时候，删除最近最少使用的缓存 （Least Recently Use）eviction=“LRU”（默 认）
FifoCacheFIFO 策略的缓存当缓存到达上限时候，删除最先入队的缓存eviction=“FIFO”
SoftCache带清理策略的缓存通过 JVM 的软引用和弱引用来实现缓存，当 JVM 内存不足时，会自动清理掉这些缓存，基于 SoftReference 和 WeakReferenceeviction=“SOFT”
WeakCache带清理策略的缓存通过 JVM 的软引用和弱引用来实现缓存，当 JVM 内存不足时，会自动清理掉这些缓存，基于 SoftReference 和 WeakReferenceeviction=“WEAK”
LoggingCache带日志功能的缓存比如：输出缓存命中率基本
SynchronizedCache同步缓存基于 synchronized 关键字实现，解决并发问题基本
BlockingCache阻塞缓存通过在 get/put 方式中加锁，保证只有一个线程操 作缓存，基于 Java 重入锁实现blocking=true
SerializedCache支持序列化的缓存将对象序列化以后存到缓存中，取出时反序列化readOnly=false（默 认）
ScheduledCache定时调度的缓存在进行 get/put/remove/getSize 等操作前，判断 缓存时间是否超过了设置的最长缓存时间（默认是 一小时），如果是则清空缓存–即每隔一段时间清 空一次缓存flushInterval 不为 空
TransactionalCache事务缓存在二级缓存中使用，可一次存入多个缓存，移除多 个缓存在TransactionalCach eManager 中用 Map 维护对应关系

二、数据准备

示例数据参考这

三、一级缓存（本地缓存）

一级缓存也叫本地缓存，MyBatis 的一级缓存是在会话（SqlSession）层面进行缓存的。MyBatis 的一级缓存是默认开启的，不需要任何的配置。我们先思考一个问题，既然一级缓存是会话级别的，那么缓存对象应该放在那个对象里面进行维护呢？默认的DefaultSqlSession 里面只有两个属性Configuration和Executor ，Configuration 是全局的，所以缓存只能放在Executor里面去维护，在Executor的抽象实现BaseExecutor中持有PerpetualCache。在同一个会话里面，多次执行相同的 SQL 语句，会直接从内存取到缓存的结果，不 会再发送 SQL 到数据库。但是不同的会话里面，即使执行的 SQL 一模一样（通过一个 Mapper 的同一个方法的相同参数调用），也不能使用到一级缓存。
接下来写一个demo来验证一级缓存,首先二级缓存默认是开启的，我们要先关闭二级缓存，然后将localCacheScope设置为SESSION,也可以不设置，默认就是SESSION，缓存一个会话执行的所有查询

    <settings>
        <!-- 打印查询语句 -->
        <setting name="logImpl" value="STDOUT_LOGGING" />
        <!-- 控制全局缓存（二级缓存）-->
        <setting name="cacheEnabled" value="false"/>
        <!-- 一级缓存 SEEION 缓存一个会话的所有查询-->
        <setting name="localCacheScope" value="SESSION"/>
    </settings>

 
1. 验证相同会话和跨会话的查询
 

    /**
     * @Description: 测试一级缓存是否缓存的是一个会话的查询
     * @Author zdp
     * @Date 2022-01-05 14:09
     */
    @Test
    public void testFirstLevelCache() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper0 = session1.getMapper(BlogMapper.class);
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            Blog blog = mapper0.selectBlogById(1);
            System.out.println("第一次查询====================================");
            System.out.println(blog);

            System.out.println("第二次查询，相同会话===========================");
            System.out.println(mapper1.selectBlogById(1));

            System.out.println("第三次查询，不同会话===========================");
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            System.out.println(mapper2.selectBlogById(1));

        } finally {
            session1.close();
            session2.close();
        }
    }

效果展示
在这里插入图片描述
从控制台打印的信息可以看到，第一次查询打印了执行Sql，在相同的会话内第二次执行相同Sql确实是从缓存中获取的，第三次跨会话之后重新从数据库查询了，以上验证可以说明在MyBatis中将一级缓存设置为SEEION的时候，确实是缓存一个会话的所有查询
 
2. 验证相同会话内将查询的数据进行更新会怎样
 

/**
     * @Description: 相同会话内将查询的数据进行更新操作
     * @Author zdp
     * @Date 2022-01-05 14:22
     */
    @Test
    public void testCacheInvalid() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper = session.getMapper(BlogMapper.class);
            System.out.println(mapper.selectBlogById(1));

            Blog blog = new Blog();
            blog.setBid(1);
            blog.setName("相同会话更新数据");
            mapper.updateByPrimaryKey(blog);
            session.commit();

            System.out.println("在执行更新操作之后，是否命中缓存？");
            System.out.println(mapper.selectBlogById(1));

        } finally {
            session.close();
        }
    }

效果展示
在这里插入图片描述
从控制台打印的信息可以看到，第一次查询后，执行更新操作，那么会导致一级缓存的失效，从而重新查询数据库
 
3. 验证跨会话内执行更新操作
 

/**
     * @Description: 跨会话更新数据
     * @Author zdp
     * @Date 2022-01-05 14:27
     */
    @Test
    public void testDirtyRead() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            System.out.println(mapper1.selectBlogById(1));

            // 会话2更新了数据，会话2的一级缓存更新
            Blog blog = new Blog();
            blog.setBid(1);
            blog.setName("after modified 112233445566");
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            mapper2.updateByPrimaryKey(blog);
            session2.commit();

            // 其他会话更新了数据，本会话的一级缓存还在么？
            System.out.println("会话1查到最新的数据了吗？");
            System.out.println(mapper1.selectBlogById(1));
        } finally {
            session1.close();
            session2.close();
        }
    }

效果展示
在这里插入图片描述
从控制台打印的信息可以看到，第一次查询后，在会话2执行更新操作，那么并不会导致一级缓存失效，导致查询出了错误的数据，在这里就看出了一级缓存的不足，在使用一级缓存的时候，因为缓存不能跨会话共享，不同的会话之间对于数据可能有不一样的缓存。在有多个会话或者分布式环境下，可能会存在脏数据的问题，接下来看看二级缓存是怎么解决这个问题的

四、二级缓存

        二级缓存是用来解决一级缓存不能跨会话共享的问题的，范围是 namespace 级别 的，可以被多个 SqlSession 共享（只要是同一个接口里面的相同方法，都可以共享）， 生命周期和应用同步。
        到这里，停下来思考一下二级缓存是工作在一级缓存之前还是在一级缓存之后呢？二级缓存是在哪里维护的呢？
        在一级缓存的时候是在SqlSession中的BaseExecutor之中去维护的，要实现跨会话之间的缓存共享，显然这个BaseExecutor已经不能满足需求了，而且这个二级缓存的维护应该放到SqlSession之外，所以二级缓存应该是工作在一级缓存之前的。在MyBatis中它用了一个装饰器的类CachingExecutor来对其进行维护，如果启用了二级缓存，MyBatis在创建Exectuor对象的时候会对Executor进行装饰。CachingExecutor 对于查询请求，会判断二级缓存是否有缓存结果，如果有就直接返回，如果没有委派交给真正的查询器 Executor 实现类，比如 SimpleExecutor 来执行查询，再走到一级缓存的流程。最后会把结果缓存起来，并且返回给用户。
在这里插入图片描述
开启二级缓存，将cacheEnable设置为true，也可以不设置，MyBatis中默认就是true

	<setting name="cacheEnabled" value="true"/>

MyBatis中对cacheEnabled的解析

  private void settingsElement(Properties props) {
    //如果没有设置，那么默认为true....
    configuration.setCacheEnabled(booleanValueOf(props.getProperty("cacheEnabled"), true));
    //....
  }

cacheEnabled 决定了是否创建 CachingExecutor

  public Executor newExecutor(Transaction transaction, ExecutorType executorType) {
    executorType = executorType == null ? defaultExecutorType : executorType;
    //......
    if (cacheEnabled) {
      executor = new CachingExecutor(executor);
    }
    //......
  }

在Mapper.xml中配置 <cache/> 标签

    <cache type="org.apache.ibatis.cache.impl.PerpetualCache"
           size="1024"
           eviction="LRU"
           flushInterval="120000"
           readOnly="false"/>

配置<cache/>标签与否决定了ms中是否有缓存Cache对象

public class CachingExecutor implements Executor {
  @Override
  public <E> List<E> query(MappedStatement ms, Object parameterObject, RowBounds rowBounds, ResultHandler resultHandler, CacheKey key, BoundSql boundSql)
      throws SQLException {
    Cache cache = ms.getCache();
    //如果配置了<cache/>标签，那么这里就不为null
    if (cache != null) {
      flushCacheIfRequired(ms);
      if (ms.isUseCache() && resultHandler == null) {
        ensureNoOutParams(ms, boundSql);
        @SuppressWarnings("unchecked")
        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); // issue #578 and #116
        }
        return list;
      }
    }
    return delegate.query(ms, parameterObject, rowBounds, resultHandler, key, boundSql);
  }
}

cache属性解释：

属性含义取值
type缓存实现类需要实现 Cache 接口，默认是 PerpetualCache
size最多缓存对象个数默认 1024
eviction回收策略（缓存淘汰算法）LRU – 最近最少使用的：移除最长时间不被使用的对象（默认）FIFO – 先进先出：按对象进入缓存的顺序来移除它们。 SOFT – 软引用：移除基于垃圾回收器状态和软引用规则的对象。 WEAK – 弱引用：更积极地移除基于垃圾收集器状态和弱引用规则的对象
flushInterval定时自动清空缓存间隔自动刷新时间，单位 ms，未配置时只有调用时刷新
readOnly是否只读true：只读缓存；会给所有调用者返回缓存对象的相同实例。因此这些对象 不能被修改。这提供了很重要的性能优势。 false：读写缓存；会返回缓存对象的拷贝（通过序列化），不会共享。这 会慢一些，但是安全，因此默认是 false。 改为 false 可读写时，对象必须支持序列化
blocking是否使用可重入锁实现 缓存的并发控制true，会使用 BlockingCache 对 Cache 进行装饰 默认 false

在Mapper.xml 配置了之后，select()会被缓存。update()、delete()、insert() 会刷新缓存。只要 cacheEnabled=true 基本执行器就会被装饰。有没有配置，决定了在 启动的时候会不会创建这个 mapper 的 Cache 对象，最终会影响到 CachingExecutor query 方法里面的判断，如果某些查询方法对数据的实时性要求很高，不需要二级缓存，我们可以在单个 Statement ID 上显式关闭二级缓存（默认是 true）：

<select id="selectBlog" resultMap="BaseResultMap" useCache="false">

1、二级缓存验证

基本了解二级缓存的使用后，接下来写一个二级缓存的测试demo：
(1). 验证跨会话查询是否缓存

/**
     * @Description: 测试二级缓存跨会话查询
     * @Author zdp
     * @Date 2022-01-06 10:44
     */
    @Test
    public void testSecondCache() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            System.err.println(mapper1.selectBlogById(1));
            //这里的事务提交很重要，如果不提交事务将导致二级缓存不生效
            session1.commit();

            System.err.println("跨会话第二次查询");
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            System.err.println(mapper2.selectBlogById(1));
        } finally {
            session1.close();
            session2.close();
        }
    }

效果展示
在这里插入图片描述
如果上面不提交事务，将无法使用二级缓存，这是因为二级缓存使用 TransactionalCacheManager（TCM）来管理，最后又调用了 TransactionalCache 的getObject()、putObject和 commit()方法。只有它的 commit()方法被调用的时候才会调用 flushPendingEntries()真正写入缓存。它就是在 DefaultSqlSession 调用 commit()的时候被调用的。

(2). 验证跨会话执行更新操作二级缓存是否失效

/**
     * @Description: 跨会话执行更新操作二级缓存是否失效
     * @Author zdp
     * @Date 2022-01-06 11:15
     */
    @Test
    public void testCacheInvalid() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        SqlSession session3 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            BlogMapper mapper3 = session3.getMapper(BlogMapper.class);
            System.out.println(mapper1.selectBlogById(1));
            session1.commit();

            // 是否命中二级缓存
            System.out.println("是否命中二级缓存？");
            System.out.println(mapper2.selectBlogById(1));

            Blog blog = new Blog();
            blog.setBid(1);
            blog.setName("二级缓存更新测试..............................");
            mapper3.updateByPrimaryKey(blog);
            session3.commit();

            System.out.println("更新后再次查询，是否命中二级缓存？");
            // 在其他会话中执行了更新操作，二级缓存是否被清空？
            System.out.println(mapper2.selectBlogById(1));

        } finally {
            session1.close();
            session2.close();
            session3.close();
        }
    }

效果展示
在这里插入图片描述
从上面可以看出，在session3执行更新操作之前，session2是从缓存里面取得数据，此时二级缓存是生效的，在执行了更新操作之后，session2再次查询，此时二级缓存已经失效，数据是从数据库里面查询出来的，这也验证了二级缓存解决了一级缓存的不足，解决了一级缓存中跨会话操作带来的脏数据问题

2、为什么增删改操作会导致二级缓存失效

开启了二级缓存之后，所有的增删改操作都会走到CachingExecutor中，这里我们直接从方法执行入口MapperProxy这个类的invoke方法看起，前面执行逻辑不清楚可以参考这

  @Override
  public Object invoke(Object proxy, Method method, Object[] args) throws Throwable {
    try {
      if (Object.class.equals(method.getDeclaringClass())) {
        return method.invoke(this, args);
      } else {
        return cachedInvoker(method).invoke(proxy, method, args, sqlSession);
      }
    } catch (Throwable t) {
      throw ExceptionUtil.unwrapThrowable(t);
    }
  }

这里先从缓存methodCache<K,V>中去根据 method (method就是缓存中的Key) 获取，如果没有获取到MapperMethodInvoker，则执行 m -> {}这个自定义的实现，返回自定义的MapperMethodInvoker

  private MapperMethodInvoker cachedInvoker(Method method) throws Throwable {
    try {
      return MapUtil.computeIfAbsent(methodCache, method, m -> {
        //判断是否是默认方法
        if (m.isDefault()) {
          try {
            if (privateLookupInMethod == null) {
              return new DefaultMethodInvoker(getMethodHandleJava8(method));
            } else {
              return new DefaultMethodInvoker(getMethodHandleJava9(method));
            }
          } catch (IllegalAccessException | InstantiationException | InvocationTargetException
              | NoSuchMethodException e) {
            throw new RuntimeException(e);
          }
        } else {
          //普通方法
          return new PlainMethodInvoker(new MapperMethod(mapperInterface, method, sqlSession.getConfiguration()));
        }
      });
    } catch (RuntimeException re) {
      Throwable cause = re.getCause();
      throw cause == null ? re : cause;
    }
  }

这里我们会走到 PlainMethodInvoker调用其invoke方法

  private static class PlainMethodInvoker implements MapperMethodInvoker {
    private final MapperMethod mapperMethod;

    public PlainMethodInvoker(MapperMethod mapperMethod) {
      super();
      this.mapperMethod = mapperMethod;
    }

    @Override
    public Object invoke(Object proxy, Method method, Object[] args, SqlSession sqlSession) throws Throwable {
      return mapperMethod.execute(sqlSession, args);
    }
  }

这里的execute方法只看INSERT、UPDATE、DELETE

public class MapperMethod {
  public Object execute(SqlSession sqlSession, Object[] args) {
    //....
    switch (command.getType()) {
      case INSERT: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.insert(command.getName(), param));
        break;
      }
      case UPDATE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.update(command.getName(), param));
        break;
      }
      case DELETE: {
        Object param = method.convertArgsToSqlCommandParam(args);
        result = rowCountResult(sqlSession.delete(command.getName(), param));
        break;
      }
       //....
    }
  }
}

我们接着看sqlSession.insert(command.getName(), param)、sqlSession.update(command.getName(), param)、sqlSession.delete(command.getName(), param)这三个方法,

  @Override
  public int insert(String statement, Object parameter) {
    return update(statement, parameter);
  }

  @Override
  public int delete(String statement, Object parameter) {
    return update(statement, parameter);
  }

  @Override
  public int update(String statement, Object parameter) {
    try {
      dirty = true;
      MappedStatement ms = configuration.getMappedStatement(statement);
      return executor.update(ms, wrapCollection(parameter));
    } catch (Exception e) {
      throw ExceptionFactory.wrapException("Error updating database.  Cause: " + e, e);
    } finally {
      ErrorContext.instance().reset();
    }
  }

到这里已经可以看出来，其实insert、delete、update都是调用的update(String statement, Object parameter)这个方法，executor.update这个方法里面最后会调用 flushCacheIfRequired(ms)这个方法

public class CachingExecutor implements Executor {
  //......
  @Override
  public int update(MappedStatement ms, Object parameterObject) throws SQLException {
    flushCacheIfRequired(ms);
    return delegate.update(ms, parameterObject);
  }
  //......
}

public class CachingExecutor implements Executor {

  private void flushCacheIfRequired(MappedStatement ms) {
    Cache cache = ms.getCache();
    //在这里获取了 isFlushCacheRequired() ，而这个方法就是获取 Mapper.xml映射文件中的 flushCache 属性的值，update、insert、delete的flushCache属性默认值就是true
    if (cache != null && ms.isFlushCacheRequired()) {
      tcm.clear(cache);
    }
  }
  }

  public boolean isFlushCacheRequired() {
    return flushCacheRequired;
  }

我们可以看下MappedStatement 这个ms对象在创建时候的flushCacheRequired 的值，

 public void parseStatementNode() {
    //......
    String nodeName = context.getNode().getNodeName();
    SqlCommandType sqlCommandType = SqlCommandType.valueOf(nodeName.toUpperCase(Locale.ENGLISH));
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    //非Select的操作都默认为true
    boolean flushCache = context.getBooleanAttribute("flushCache", !isSelect);
    //......
    builderAssistant.addMappedStatement(id, sqlSource, statementType, sqlCommandType,
        fetchSize, timeout, parameterMap, parameterTypeClass, resultMap, resultTypeClass,
        resultSetTypeEnum, flushCache, useCache, resultOrdered,
        keyGenerator, keyProperty, keyColumn, databaseId, langDriver, resultSets);
  }

  public MappedStatement addMappedStatement(/**...*/boolean flushCache/**...*/) {
    //.....
    boolean isSelect = sqlCommandType == SqlCommandType.SELECT;
    MappedStatement.Builder statementBuilder = new MappedStatement.Builder(configuration, id, sqlSource, sqlCommandType).resource(resource)
		//.....这里设置了flushCache的值，非Select 都是true
        .flushCacheRequired(valueOrDefault(flushCache, !isSelect))
		//.....
    MappedStatement statement = statementBuilder.build();
    configuration.addMappedStatement(statement);
    return statement;
  }

所以到这里我们可以看出在增删改操作会导致二级缓存失效是因为在Mapper.xml映射文件解析的时候，update、insert、delete元素中flushCache的属性默认值为true，在执行更新的时候会拿 flushCacheRequired的值(flushCache的值)来判断。为true就会去清空缓存

五、Redis做二级缓存

除了 MyBatis 自带的二级缓存之外，我们也可以通过实现 Cache 接口来自定义二级缓存，这里以Redis为例，将其作为二级缓存使用：

1. 引入mybatis-redis依赖

<dependency>
    <groupId>org.mybatis.caches</groupId>
    <artifactId>mybatis-redis</artifactId>
    <version>1.0.0-beta2</version>
</dependency>

2. 在Mapper.xml映射文件中配置RedisCache

<!-- 使用Redis作为二级缓存 -->
<cache type="org.mybatis.caches.redis.RedisCache"
       eviction="FIFO" 
       flushInterval="60000" 
       size="512" 
       readOnly="true"/>

3. 配置redis.properties配置文件
这里如果不配置redis.properties的配置文件则使用默认的地址localhost和默认端口6372，如果配置了reids，则配置文件名称必须为redis.properties并且文件要放到resources目录下面
4. 编写测试类

    @Test
    public void testRedisCache() throws IOException {
        String resource = "mybatis-config.xml";
        InputStream inputStream = Resources.getResourceAsStream(resource);
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(inputStream);

        SqlSession session1 = sqlSessionFactory.openSession();
        SqlSession session2 = sqlSessionFactory.openSession();
        try {
            BlogMapper mapper1 = session1.getMapper(BlogMapper.class);
            System.err.println(mapper1.selectBlogById(1));
            session1.commit();

            System.err.println("跨会话第二次查询");
            BlogMapper mapper2 = session2.getMapper(BlogMapper.class);
            System.err.println(mapper2.selectBlogById(1));
        } finally {
            session1.close();
            session2.close();
        }
    }

5. 效果展示
在这里插入图片描述
在这里插入图片描述
以上就是用Redis作为二级缓存的例子了，当然我们也可以实现MyBatis提供的Cache接口，自定义缓存实现。
以上就是MyBatis缓存的介绍了，如有错误希望你指正，希望能对你有点帮助！

扶我起来！我还能码！
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
MyBatis缓存功能原理及实例解析
08-19
MyBatis缓存功能原理及实例解析 MyBatis缓存功能原理及实例解析是MyBatis框架中非常重要的一部分，它可以极大的提升查询效率，解决高并发系统的性能问题。缓存机制可以将用户经常查询的数据放在缓存（内存）中，...
Mybatis 缓存原理及失效情况解析
08-25
Mybatis 缓存原理及失效情况解析 Mybatis 缓存是指将经常查询的数据存于内存中，以提高查询效率，解决高并发系统的性能问题。Mybatis 缓存分为一级缓存和二级缓存两种。 一级缓存，也称为本地缓存，指的是...
MyBatis 缓存详解-一级缓存验证
Leon_Jinhai_Sun的博客
12-08 416
（基于mybatis-standalone 工程，注意演示一级缓存需要先关闭二级缓存，localCacheScope 设置为SESSION） 判断是否命中缓存：如果再次发送SQL 到数据库执行，说明没有命中缓存；如果直接打印对象，说明是从内存缓存中取到了结果。 1、在同一个session 中共享 BlogMapper mapper = session.getMapper(BlogMapper.class); System.out.println(mapper.selectBlog(1)); Syst
MyBatis 中的缓存机制（一文带你搞懂）
Z99263的博客
05-30 596
MyBatis的缓存包括一级缓存和二级婚车。一级缓存是会话级别的缓存，二级缓存是全局级别的缓存。一个会话查询一条数据，这个数据就会被放在当前会话的一级缓存中，如果当前会话关闭了，该对应的一级缓存就关闭了，此时，一级缓存中的数据就被转到了二级缓存中，新的会话查询信息，就会在二级缓存中获取内容，不同的 mapper 查出的数据会放在自己对应的缓存中。）中，当用户再次查询相同数据时就不用从磁盘上（关系型数据库数据文件）查询了，而是从缓存中查询，从而提高查询效率，解决了高并发系统的性能问题。
Mybatis-缓存解析
qq_42861526的博客
01-04 612
一级缓存 在mybatis中一级缓存是默认开启的，它以sqlsession’为单位，多个sqlsession的缓存相互独立，互不干扰 一级缓存的生命周期 MyBatis 在开启一个数据库会话时，会创建一个新的 SqlSession 对象，SqlSession 对象中 会有一个新的 Executor 对象。Executor 对象中持有一个新的 PerpetualCache 对象；当会 话结束时，SqlSession 对象及其内部的 Executor 对象还有 PerpetualCache 对象也一并释
MyBatis 缓存原理解析
养歌的博客
04-14 2294
为什么 MyBatis 要缓存 缓存在互联网系统中是非常重要的， 其主要作用是将数据保存到内存中， 当用户查询数据时， 优先从缓存容器中获取数据，而不是频繁地从数据库中查询数据，从而提高查询性能。而在 ORM 框架中引入缓存的目的就是为了减少读取数据库的次数，从而提升查询的效率。 在 MyBatis 中存在两种缓存，一个在事务内部使用的一级缓存，另一个可以全局使用的二级缓存。 一级缓存 一级缓存也叫本地缓存，在MyBatis中，一级缓存是在会话(SqlSession)层面实现的，这就说明一级缓存作用范围只
Mybatis框架源码笔记(五)之Mybatis框架缓存机制原理解析
最爱嫣夜来
02-27 871
配置文件中缓存相关的配置参数解析Myabtis框架中一级缓存和二级缓存默认是开启的缓存默认的作用域是SessionConfiguration初始化的时候会为我们的各种Cache实现类完成别名注册三级缓存一般都是自定义缓存。分布式缓存框架：我们系统为了提高系统并发和性能，一般对系统进行分布式部署（集群部署方式）不适用分布缓存， 缓存的数据在各个服务单独存储，不方便系统开发。
Mybatis缓存
weixin_68027145的博客
08-28 587
练习
如何掌握MyBatis多级缓存机制？
2401_83062316的博客
05-30 815
但是，要注意由于一级缓存是独立存在于每个Session内部的，因此，如果我们创建了不同的Session，那么他们之间会使用不同的缓存。例如，完全一样的一个操作，如果在两个不同的Session中进行执行，那就意味着存在两份一样的缓存数据，但分别位于两个Session中，彼此之间不会共享。今天，我们就将讨论其中具有代表性的多级缓存技术。各类缓存实现工具，尽管其支持的数据结构以及数据在内存中的分配和查找方式有所不同，但基本结构模型都与上图类似，从该图中，我们也认识到缓存本质上是一种时间换空间的做法。
mybatis的缓存机制源码分析之一级缓存解析
lucasma的博客
09-29 259
文章目录引言正文 引言 本篇源码解析基于mybatis 3.5.8版本。 MyBatis 中的缓存指的是 MyBatis 在执行一次SQL查询时，在满足一定的条件下，会把这个sql和对应的查询结果缓存起来。当再次执行相同SQL语句的时候，就会直接从缓存中进行提取，而不是请求到数据库。当然如果中间有更新操作，缓存会失效。 MyBatis中的缓存分为一级缓存和二级缓存，一级缓存又被称为 SqlSession 级别的缓存，二级缓存又被称为表级缓存。通俗的说，一级缓存是本次会话有效，二级缓存可以跨越多个会话共享缓存
Mybatis的缓存机制 ----全网最详解析
m0_53856016的博客
11-25 427
Mybatis框架的一级缓存又称之为会话（Session）缓存，默认是开启的，且无法关闭！一级缓存必须满足：同一个SqlSession、同一个Mapper对象、执行相同的查询、且参数相同！
mybatis的二级缓存使用以及禁用
zlpzlpzyd的专栏
12-24 1631
一级缓存针对的是 SqlSession 层次，二级缓存针对的是 mapper 层次。最终的缓存类都是 PerpetualCache，只是二级缓存通过装饰器模式串联了多个 cache 实现，可以针对不同的功能串联不同的 cache 实现。一级缓存和二级缓存都有一个缺点，无法解决缓存共用的问题。所以，针对集群项目不建议使用一级缓存和二级缓存，最好禁用。
MyBatis缓存实现原理及代码实例解析
09-07
MyBatis提供了两种级别的缓存：一级缓存（本地缓存）和二级缓存（全局缓存）。 一级缓存是SqlSession级别的，它默认始终开启。当在一个SqlSession中执行SQL查询时，查询结果会被存储在本地缓存中。如果后续请求相同...
mybatis缓存源码解析
04-23
个人学习mybatis源码总结
mybatis中的缓存问题解析
08-30
配置二级缓存的详细属性可以通过`<cache>`标签内的子元素来实现，例如： ```xml ``` 在这个例子中，`eviction`设置了缓存的回收策略为LRU，`flushInterval`设定了60秒的刷新间隔，`size`指定了缓存的最大容量为...
springboot 缓存预热的几种方案
一个人的江湖
07-24 721
使用启动监听事件实现缓存预热优点：可以在应用完全启动之前执行，可以确保缓存预热在所有依赖初始化完成之后进行。缺点：处理复杂，需要对Spring的事件机制有一定了解。使用@PostConstruct注解实现缓存预热优点：简单易用，不需要额外的接口实现，适用于简单的预热逻辑。缺点：对于复杂的预热逻辑，可能会导致方法变得臃肿，不易于维护。使用CommandLineRunner或ApplicationRunner实现缓存预热。
前端性能优化：浏览器的2种缓存方式要弄清
weixin_71807218的博客
07-24 608
当我们第一次访问某个网站时，浏览器会把网站中的图片等资源存储在电脑中，以备后续使用，第二次访问该网站时，浏览器直接访问缓存中的数据，从而达到提高浏览器的响应效率，优化用户的体验。浏览器缓存的强缓存和协商缓存如下图：行动吧，在路上总比一直观望的要好，未来的你肯定会感 谢现在拼搏的自己！如果想学习提升找不到资料，没人答疑解惑时，，里面有各种软件测试+开发资料和技术可以一起交流学习哦。
KCache-go本地缓存，支持本地缓存过期、缓存过期自维护机制。
最新发布
kocor的博客
07-25 475
最近系统并发很高，近10W的QPS，对redis压力很大，大量的热KEY导致 redis 分片CPU资源经常告警。计划用 go 本地缓存缓解 redis 的压力。有多个系统需要使用本地缓存，写了 KCache 方便各个系统使用。本地压测达到 100W QPS。使用请参考。
MyBatis延迟加载与一级缓存解析
4. 缓存机制：MyBatis内置了一级缓存和二级缓存。一级缓存是SqlSession级别的，同一个SqlSession内的多次相同查询会被缓存，避免了重复的数据库访问；二级缓存则是在多个SqlSession之间共享的，可以通过配置开启和...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值