MyBatis中三级缓存的理解

已于 2023-06-15 13:46:38 修改
阅读量1.9k 收藏 12
点赞数
分类专栏： mybatis 文章标签： mybatis 缓存 java
于 2023-05-21 12:53:27 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_37400096/article/details/130788822
版权

文章目录

前言

缓存的作用：不加缓存 1。查询的效率降低 2。增大了数据库的压力

  • 一级缓存：会话级别的
  • 二级缓存：进程级别的
  • 三级缓存：自定义缓存

项目中要使用缓存 全局配置文件中 settings 我们需要打开， 在对应的映射文件中 <cache>，一级缓存是默认使用的。二级缓存我们需要自己开启：一级和二级缓存的执行的先后顺序：先查二级缓存。二级缓存没有进行一级缓存。一级缓存如果还是没有那么走数据库查询
作用域：一级缓存的作用域是session级别的，命中率很低。

1. 环境搭建

1.1 依赖引入

 <!--引入mybatis依赖-->
    <dependency>
      <groupId>org.mybatis</groupId>
      <artifactId>mybatis</artifactId>
      <version>3.5.13</version>
    </dependency>
    <!--mysql-->
    <dependency>
      <groupId>mysql</groupId>
      <artifactId>mysql-connector-java</artifactId>
      <version>8.0.22</version>
    </dependency>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>4.12</version>
      <scope>test</scope>
    </dependency>

1.2 mybatis-config.xml配置

配置db.properties

driver=com.mysql.cj.jdbc.Driver
url=jdbc:mysql://ip:3306/mybatisplus?useSSL=false&autoReconnect=true&useUnicode=true&characterEncoding=utf8&zeroDateTimeBehavior=convertToNull&serverTimezone=Asia/Shanghai
username=root
password=123456

在mybatis-config.xml引入db.properties

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE configuration
        PUBLIC "-//mybatis.org//DTD Config 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-config.dtd">
<configuration>
    <!---导入配置文件-->
    <properties resource="db.properties"></properties>
    <environments default="development">
        <environment id="development">
              <transactionManager type="JDBC"/>
            <dataSource type="POOLED">
                <property name="driver" value="${driver}"/>
                <property name="url" value="${url}"/>
                <property name="username" value="${username}"/>
                <property name="password" value="${password}"/>
            </dataSource>
        </environment>
    </environments>
    <mappers>
        <mapper resource="mapper/PersonMapper.xml"/>
    </mappers>
</configuration>

1.3 实体类

省略set get方法

/**
 * person实体类
 */
public class Person {
    private Long id;
    private String name;
    private Integer age;
    private String email;
}

1.4 mapper

mapper接口

/**
 * 查询患者
 */
public interface PersonMapper {
    /**
     * 根据id查询人员信息
     * @param id
     * @return
     */
    Person selectPerson(long id);
}

mapper映射文件

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.elite.mybatis.mapper.PersonMapper">
    <!--查询人员信息-->
    <select id="selectPerson" resultType="com.elite.mybatis.entity.Person">
        select * from person where id = #{id}
    </select>
</mapper>

1.5 测试

 /**
     * 查询人员信息
     */
    @Test
    public void testSelect() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        Person person = sqlSession.selectOne("com.elite.mybatis.mapper.PersonMapper.selectPerson", 1L);
        System.out.println(person.toString());
        ///Person{id=1, name='elite', age=22, email='elite@qq.com'}
    }

项目结构：
项目结构

2.缓存

2.1 一级缓存

一级缓存默认是开启的，作用域是SqlSession 级别的，所以命中率极低。相同SqlSession ，多次调用同一个Mapper和同一个方法的同一个参数，只会进行一次数据库查询，然后把数据缓存到缓冲中，以后直接先从缓存中取出数据，不会直接去查数据库。

mybatis-config.xml 配置日志

 <!--设置日志实现-->
    <settings>
        <setting name="logImpl" value="STDOUT_LOGGING"/>
    </settings>

开启日志

    <!--加入日志-->
    <dependency>
      <groupId>ch.qos.logback</groupId>
      <artifactId>logback-classic</artifactId>
      <version>1.4.2</version>

配置日志文件logback.xml

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE configuration>
<configuration>
   <appender name="stdout" class="ch.qos.logback.core.ConsoleAppender">
        <encoder>
            <pattern>%5level [%thread] - %msg%n</pattern>
        </encoder>
    </appender>

    <logger name="com.elite.mybatis.mapper.PersonMapper">
        <level value="trace"/>
        <Root level="info" >
            <AppenderRef ref="stdout"/>
        </Root>
    </logger>
</configuration>

测试

    /**
     * 查询人员信息
     */
    @Test
    public void testSelect() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession();
        System.out.println("==========第一次调用========================");
        Person person = sqlSession.selectOne("com.elite.mybatis.mapper.PersonMapper.selectPerson", 1L);
        System.out.println(person.toString());
        System.out.println("==========第二次调用========================");
        Person person1 = sqlSession.selectOne("com.elite.mybatis.mapper.PersonMapper.selectPerson", 1L);
        System.out.println(person1.toString());
    }

相同mapper,相同参数

相同参数

相同mapper,不同参数

不同参数

2.2 二级缓存

二级缓存:
是多个 SqlSession 共享的，其作用域是 mapper 的同一个 namespace，不同 的 sqlSession 两次执行相同 namespace 下的 sql 语句且向 sql 中传递参数也相同即最终执行 相同的 sql 语句，第一次执行完毕会将数据库中查询的数据写到缓存（内存），第二次会从 缓存中获取数据将不再从数据库查询，从而提高查询效率。Mybatis 默认没有开启二级缓存 需要在 setting 全局参数中配置开启二级缓存。

mybatis-config.xml配置文件开启缓存配置

  <settings>
        <!--设置日志实现-->
        <setting name="logImpl" value="STDOUT_LOGGING"/>
        <!--开启二级缓存-->
        <setting name="cacheEnabled" value="true"/>
    </settings>

实体类实现序列化

public class Person implements Serializable {
}

mapper的xml配置缓存

<?xml version="1.0" encoding="UTF-8" ?>
<!DOCTYPE mapper
        PUBLIC "-//mybatis.org//DTD Mapper 3.0//EN"
        "https://mybatis.org/dtd/mybatis-3-mapper.dtd">
<mapper namespace="com.elite.mybatis.mapper.PersonMapper">

      <!--eviction: 清空缓存的策略
        readOnly: 是否只读
        flushInterval: 每个60秒刷新一次缓存
        size: 内存大小，最多存储结果对象或者列表的512个引用 -->
    <cache readOnly="true" eviction="FIFO" flushInterval="60000" size="512"/>
   
    <!--查询人员信息-->
    <select id="selectPerson" resultType="com.elite.mybatis.entity.Person" flushCache="false" useCache="true" >
        select * from person where id = #{id}
    </select>
</mapper>

测试代码

    /**
     * 查询人员信息
     */
    @Test
    public void testSelect1() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        System.out.println("==========第一个sqlSession="+sqlSession.hashCode()+"========================");
        PersonMapper personMapper = sqlSession.getMapper(PersonMapper.class);
        System.out.println( personMapper.selectPerson(1L).toString());
        sqlSession.close();
        SqlSession sqlSession1 = sqlSessionFactory.openSession(true);
        System.out.println("==========第二个sqlSession="+sqlSession1.hashCode()+"========================");
        PersonMapper personMapper1 = sqlSession1.getMapper(PersonMapper.class);
        System.out.println(personMapper1.selectPerson(1L).toString());
        sqlSession1.close();
    }

测试，缓存命中率只有0.5

==========第一个sqlSession=236230========================
Cache Hit Ratio [com.elite.mybatis.mapper.PersonMapper]: 0.0
Opening JDBC Connection
Created connection 17500244.
==>  Preparing: select * from person where id = ?
==> Parameters: 1(Long)
<==    Columns: id, name, age, email
<==        Row: 1, elite, 22, elite@qq.com
<==      Total: 1
Person{id=1, name='elite', age=22, email='elite@qq.com'}
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@10b0854]
Returned connection 17500244 to pool.
==========第二个sqlSession=29457283========================
Cache Hit Ratio [com.elite.mybatis.mapper.PersonMapper]: 0.5
Opening JDBC Connection
Checked out connection 17500244 from pool.
==>  Preparing: select * from person where id = ?
==> Parameters: 1(Long)
<==    Columns: id, name, age, email
<==        Row: 1, elite, 22, elite@qq.com
<==      Total: 1
Person{id=1, name='elite', age=22, email='elite@qq.com'}
Closing JDBC Connection [com.mysql.cj.jdbc.ConnectionImpl@10b0854]
Returned connection 17500244 to pool.

2.3 三级缓存

由于一级缓存二级缓存的命中率极低，都是在单个进程之类进行缓存，多进程缓存就不好使，mybatis默认提供了接口可以自定义缓存。
此处我们整合redis进行缓存。

引入缓存的依赖

  <!--mybatis-redis缓存依赖-->
    <dependency>
      <groupId>org.mybatis.caches</groupId>
      <artifactId>mybatis-redis</artifactId>
      <version>1.0.0-beta2</version>
    </dependency>

配置文件redis.properties

host=redis ip
port=6379
connectionTimeout=500000
password=
database=0

自定义缓存实现cache接口

package com.elite.mybatis.cache;

import org.apache.ibatis.cache.Cache;
import org.mybatis.caches.redis.*;
import redis.clients.jedis.Jedis;
import redis.clients.jedis.JedisPool;

import java.io.IOException;
import java.io.InputStream;
import java.util.Map;
import java.util.Properties;
import java.util.concurrent.locks.ReadWriteLock;
import java.util.concurrent.locks.ReentrantReadWriteLock;

/**
 * 自定义com.elite.mybatis.cache.MyRedisCache;
 */
public class MyRedisCache implements Cache {
    private final ReadWriteLock readWriteLock = new ReentrantReadWriteLock();
    private String id;
    private static JedisPool pool;

    public MyRedisCache(String id) throws IOException {
        if (id == null) {
            throw new IllegalArgumentException("Cache instances require an ID");
        } else {
            this.id = id;
            Properties properties = new Properties();
            // 使用ClassLoader加载properties配置文件生成对应的输入流
            InputStream in = MyRedisCache.class.getClassLoader().getResourceAsStream("redis.properties");
            // 使用properties对象加载输入流
            properties.load(in);
             //获取key对应的value值
            String host = properties.getProperty("host");
            String port = properties.getProperty("port");
            in.close();
            RedisConfig redisConfig =new RedisConfig();
            pool = new JedisPool(redisConfig,host,Integer.valueOf(port), 5000, 5000,null,0,"mybatis-redis" );
        }
    }

    private Object execute(RedisCallback callback) {
        Jedis jedis = pool.getResource();

        Object var3;
        try {
            var3 = callback.doWithRedis(jedis);
        } finally {
            jedis.close();
        }

        return var3;
    }

    public String getId() {
        return this.id;
    }

    public int getSize() {
        return (Integer)this.execute(new RedisCallback() {
            public Object doWithRedis(Jedis jedis) {
                Map<byte[], byte[]> result = jedis.hgetAll(MyRedisCache.this.id.toString().getBytes());
                return result.size();
            }
        });
    }

    public void putObject(final Object key, final Object value) {
        this.execute(new RedisCallback() {
            public Object doWithRedis(Jedis jedis) {
                jedis.hset(MyRedisCache.this.id.toString().getBytes(), key.toString().getBytes(), SerializeUtil.serialize(value));
                return null;
            }
        });
    }

    public Object getObject(final Object key) {
        return this.execute(new RedisCallback() {
            public Object doWithRedis(Jedis jedis) {
                return SerializeUtil.unserialize(jedis.hget(MyRedisCache.this.id.toString().getBytes(), key.toString().getBytes()));
            }
        });
    }

    public Object removeObject(final Object key) {
        return this.execute(new RedisCallback() {
            public Object doWithRedis(Jedis jedis) {
                return jedis.hdel(MyRedisCache.this.id.toString(), new String[]{key.toString()});
            }
        });
    }

    public void clear() {
        this.execute(new RedisCallback() {
            public Object doWithRedis(Jedis jedis) {
                jedis.del(MyRedisCache.this.id.toString());
                return null;
            }
        });
    }

    public ReadWriteLock getReadWriteLock() {
        return this.readWriteLock;
    }

    public String toString() {
        return "Redis {" + this.id + "}";
    }
}

配置mapper xml配置

<!--设置三级缓存类地址-->
<cache type="com.elite.mybatis.cache.MyRedisCache" />

测试

 /**
     * 查询人员信息
     */
    @Test
    public void testSelect3() throws IOException {
        InputStream resourceAsStream = Resources.getResourceAsStream("mybatis-config.xml");
        SqlSessionFactory sqlSessionFactory = new SqlSessionFactoryBuilder().build(resourceAsStream);
        SqlSession sqlSession = sqlSessionFactory.openSession(true);
        PersonMapper personMapper = sqlSession.getMapper(PersonMapper.class);
        System.out.println( personMapper.selectPerson(1L).toString());
        sqlSession.close();
    }

redis缓存数据

查询缓存

第二次再次执行查询命中率1.0

缓存

小刘同学要加油呀
关注
  • 0
    点赞
  • 踩
  • 12
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
SpringBoot入门教程：MyBatis二级缓存
人不风流枉少年
11-10 1095
一：一级缓存和二级缓存简介 ①、一级缓存是SqlSession级别的缓存。在操作数据库时需要构造sqlSession对象，在对象中有一个数据结构（HashMap）用于存储缓存数据。不同的sqlSession之间的缓存数据区域（HashMap）是互相不影响的。 ②、二级缓存是mapper级别的缓存，多个SqlSession去操作同一个Mapper的sql语句，多个SqlSession可以共用二级缓存，二级缓存是跨SqlSession的。 写这篇文章的初衷：MyBatis二级缓存在实际工作中一般都不会使用，但是
十分钟带你了解Mybatis一、二、三级缓存，赶紧用起来！
最新发布
零度念者的博客
11-29 239
-禁用某个查询使用缓存--> < select id = " findAll " resultType = " xxx " useCache = " false " > </ select > </ mapper >--禁用某个查询使用缓存--> < select id = " findAll " resultType = " xxx " useCache = " false " > </ select > </ mapper >
Mybatis缓存：一级缓存、二级缓存
weixin_43241706的博客
10-20 475
Mybatis 中有一级缓存和二级缓存，默认情况下一级缓存是开启的，而且是不能关闭的。一级缓存是指 SqlSession 级别的缓存，当在同一个 SqlSession 中进行相同的 SQL 语句查询时，第二次以后的查询不会从数据库查询，而是直接从缓存中获取，一级缓存最多缓存 1024 条 SQL。二级缓存是指可以跨 SqlSession 的缓存。是 mapper 级别的缓存，对于 mapper 级别的缓存不同的sqlsession 是可以共享的。 一级缓存原理（SqlSession级别） 第一次发出一个查询
SpringBoot+Mybatis+Redis缓存实战总结
FlyingFish868的博客
01-03 1965
Redis 是一个高性能的key-value内存数据库。它支持常用的5种数据结构：String字符串、Hash哈希表、List列表、Set集合、Zset有序集合 等数据类型。 Redis它解决了2个问题： 1）性能 通常数据库的读操作，一般都要几十毫秒，而redisd的读操作一般仅需不到1毫秒。通常只要把数据库的数据缓存进redis，就能得到几十倍甚至上百倍的性能提升。 2）并发 在大并发的情况下，所有的请求直接访问数据库，数据库会出现连接异常，甚至卡死在数据库中。
mybatis的缓存
qq_50896786的博客
06-06 832
目录1.什么是缓存2.mybatis的缓存2.1一级缓存 2.2 二级缓存2.2.1 开启二级缓存2.2.2 在映射文件中使用二级缓存2.2.3 实体一定要实现序列化接口 2.2.4 二级缓存测试 缓存就是数据交换的缓冲区，当某一硬件要读取数据时，会首先从缓存中查找需要的数据，如果找到了则直接执行，找不到的话则从内存中找。由于缓存的运行速度比内存快得多，故缓存的作用就是帮助硬件更快地运行。 例如 mysql数据库中的数据存在表内也就是在磁盘上。 查询时程序IO读取磁盘的数据，添加
MyBatis缓存机制要点解析以及如何与三方缓存组件Redis整合示例
写写平时的技术与感想
05-22 1262
如果是开启了二级缓存，在MyBatis先查询二级缓存，因为二级缓存中可能会有其他程序已经查出来的数据，可以拿来直接使用。如果二级缓存没有命中，再查询一级缓存如果一级缓存也没有命中，则查询数据库SqlSession关闭之后，一级缓存中的数据会写入二级缓存。有关于二级缓存和一级缓存的架构位置,是先走的是查看是否有二级缓存信息，之后在走一级缓存。
深入理解Mybatis二级缓存
08-31
MyBatis二级缓存是其缓存机制中的一个重要组成部分，它的设计目的是为了提高数据库操作的效率，通过存储已经查询过的结果，在后续相同查询时避免重复访问数据库。一级缓存是SqlSession级别的，而二级缓存则是在整个...
mybatis+redis实现二级缓存
05-24
开发者可以通过阅读和运行这个项目，来理解和学习如何在实际项目中实现MyBatis和Redis的二级缓存功能。 总结来说，"mybatis+redis实现二级缓存"项目展示了如何利用Redis的高性能缓存特性增强MyBatis的二级缓存，...
MyBatis3开启二级缓存
08-07
MyBatis的二级缓存实现主要涉及`Cache`接口及其实现类，如`PerpetualCache`，通过源码阅读，可以更深入理解缓存的工作流程，以及如何自定义缓存策略。 通过以上步骤，我们可以成功地在MyBatis3中启用二级缓存，...
mybatis二级缓存学习
12-05
MyBatis二级缓存是MyBatis框架中的一个重要特性，它允许我们在多个SqlSession之间共享数据，从而提高应用性能。本文将深入探讨MyBatis二级缓存的工作原理、配置方式以及如何在实际开发中有效利用。 一、MyBatis二级...
数据库三级体系
11-26
PPT数据库 三级体系 理论学习是学习数据库的前提
ImageLoaderDemo图片三级缓存
07-09
分成三级对图片进行缓存，第一级采用LinkedHashMap(LRU算法)，第二季采用ConcurrentHashMap线程安全控制
三,MyBatis动态SQL,缓存和分页插件, Lombok工具
01-05
MyBatis提供了两级缓存：一级缓存默认存在于SqlSession级别，同一个SqlSession内的多次相同查询会直接从缓存获取结果；二级缓存则可跨SqlSession，它是基于namespace的，需要在配置文件中开启，并在Mapper接口或XML...
mysql 3级缓存_MySql数据库3【优化3】缓存设置的优化
weixin_35551554的博客
01-27 283
1、表缓存相关参数：table_open_cache指定表缓存的大小。每当MySQL访问一个表时，如果在表缓冲区中还有空间，该表就被打开并放入其中，这样可以更快地访问表内容。通过检查峰值时间的状态值，如果发现open_tables等于table_cache，并且opened_tables在不断增长，那么就需要增加table_open_cache的值了。注意，不能盲目地把这个参数设置得很大，如果设...
Spring Cache 集成 Caffeine实现项目缓存
Simon's Blog
10-30 3490
一、前言 Spring Cache本身是Spring框架中一个缓存体系的抽象实现，本身不具备缓存能力，需要配合具体的缓存实现来完成，如Ehcache、Caffeine、Guava、Redis等。 二、缓存注解 @EnableCaching：开启缓存功能 @Cacheable：定义缓存，用于触发缓存 @CachePut：定义更新缓存，触发缓存更新 @CacheEvict：定义清楚缓存，触发缓存清除 @Caching：组合定义多种缓存功能 @CacheConfig：定义公共设置，位于class之上 三、实战
MyBatis的缓存机制，一级缓存、二级缓存、第三方缓存
qq_44840230的博客
04-13 2085
MyBatis的缓存机制 缓存机制： 就是将用户经常查询的数据的结果的一个保存，保存到一个内存中，用户在查询的时候就不用到数据库文件中查询，从而减少与数据库的交付次数提高了响应速度，解决了并发系统的西能问题。 分类 MyBatis提供了一级缓存和二级缓存 默认情况下，只有一级缓存（SqlSession级别的缓存，也称为本地缓存）开启。 二级缓存（全局缓存）需要手动开启和配置，他是基于mapper...
mybatis 三级缓存查询循序_MyBatis手把手跟我做系列(五) --- 一级缓存与二级缓存
weixin_39564527的博客
11-20 136
一.什么是缓存要理解MyBatis的一级缓存,至少,你需要先直接什么是缓存的这个概念,其实我们一直都在用直接来看下面的图:对于我们之前的JDBC操作,如果需要连续请求id=1的用户数据,那么就需要进行两次的数据库连接,获取数据库中的数据.相同的数据,却需要两次数据库连接,这肯定会造成资源的浪费,相信你肯定不会这么做,只要你稍微有面向对象的知识,你肯定会把第一次获取的数据保存到一个对象中,下一次再直...
MyBatis 缓存你真的会了吗？
GitChat
07-13 332
mybatis 占据 ORM 框架的半壁江山，我们是不仅要做到会使用，还得做到知其然更知其所以然。 MyBatis 缓存分为一级缓存和二级缓存，那这两级缓存是怎么实现的呢？他们的存储结构，作用范围，失效场景你都了解吗？这里带领大家一起探索 MyBatis 缓存实现的奥秘。 学习本场 Chat 您将了解到： MyBatis 一级缓存,二级缓存的概念 MyBatis 一级缓存源码剖实现以及特点 ...
MySQL服务器设置优化之三-缓冲区调优
itas109的专栏
01-15 4013
MySQL服务器设置优化之三-缓冲区调优 如需转载请标明出处：http://blog.csdn.net/itas109 QQ技术交流群：12951803 环境： MySQL版本：5.5.15 操作系统：windows 1.读入缓冲区的大小 优化参数：read_buffer_size 参数作用：read_buffer_size是MySQL读入缓冲区的大小，将对表进行顺序扫描
mybatis的三级缓存
03-01
MyBatis的三级缓存指的是在MyBatis框架中，数据缓存被划分为三个层次的缓存：一级缓存（本地缓存）、二级缓存（全局缓存）和三级缓存（分布式缓存）。 1. 一级缓存：即本地缓存。MyBatis默认开启一级缓存，是针对同一个SqlSession的缓存，当同一个SqlSession中执行多次相同的查询时，第一次查询后的结果会缓存到该SqlSession中，并在之后的查询中直接从缓存中获取结果，避免了重复查询。 2. 二级缓存：即全局缓存。在不同的SqlSession之间共享数据，可使用第三方缓存如Ehcache、Redis等。需要在MyBatis的配置文件中配置开启，可以通过namespace级别的cache配置实现，其底层实现是通过序列化和反序列化实现对象的存取。 3. 三级缓存：即分布式缓存。它是建立在二级缓存的基础上，用于多个应用或服务之间共享数据。通过将数据存储在分布式缓存中，可以实现多个应用或服务之间的数据共享和高并发处理，提升系统的性能。 需要注意的是，虽然使用缓存可以提升系统性能，但也会带来一些潜在的问题，比如缓存的过期策略、缓存的一致性问题等。在实际应用中需要根据具体情况来选择是否开启缓存，以及选择合适的缓存策略。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

小刘同学要加油呀

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值