一篇搞定多级缓存：Redis分布式缓存+Caffeine本地缓存

已于 2025-01-14 17:12:47 修改
阅读量1.5k 收藏 29
点赞数 16
文章标签： 缓存 redis 分布式
于 2025-01-03 18:16:07 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_73904503/article/details/144915769
版权

缓存是一种优化技术，它通过存储数据的副本以减少对原始数据源（如数据库、远程服务等）的访问次数，从而提高应用程序的性能和响应速度。

什么时候情况下适合使用缓存？

读多写少 的场景下适合缓存。

当某些数据被大量用户频繁请求，而这些数据又很少发生变化时，缓存可以大大减轻后端系统的压力。

例如：

  • 网站上的图片加载
  • 外部服务调用：与第三方API或其他微服务交互通常会带来网络延迟和不可控的服务可用性问题
  • 会话管理和认证信息

缓存的实现首先可以想到用Redis。

Redis分布式缓存

什么是Redis？

看看官方介绍：

Redis is often referred to as a data structures server. What this means is that Redis provides access to mutable data structures via a set of commands, which are sent using a server-client model with TCP sockets and a simple protocol. So different processes can query and modify the same data structures in a shared way.

Redis的重要特性

  • Redis cares to store them on disk, even if they are always served and modified into the server memory. This means that Redis is fast, but that it is also non-volatile.
  • The implementation of data structures emphasizes memory efficiency, so data structures inside Redis will likely use less memory compared to the same data structure modelled using a high-level programming language.
  • Redis offers a number of features that are natural to find in a database, like replication, tunable levels of durability, clustering, and high availability.

总结

  1. 存储在内存
  2. 更高效的数据结构（用c语言编写，足够底层O(∩_∩)O）
  3. 支持复制，集群；高可用！

面试题：Redis为什么这么快？

可以从官方给出的这几个方面回答。

在这里插入图片描述

Redis 缓存key设计

1.设计key

假设要给存储图片设计一个key

String queryCondition = JSONUtil.toJsonStr(pictureQueryRequest); // 用json串存储，让key的可读性高
String hashKey = DigestUtils.md5DigestAsHex(queryCondition.getBytes());
String cacheKey = String.format("haodePicture:listPictureVOByPage:%s", hashKey);

原则：要保证key的长度适中，可读性要高，唯一性**。**

可以让redis存储的缓存格式用json串表示：

String queryCondition = JSONUtil.toJsonStr(pictureQueryRequest);

缺点就是一定程度上造成存储空间的浪费。但是更好看(ゝ∀･)b

为避免前端传来的查询条件使key过大，用md5哈希算法压缩key。

操作Redis缓存

步骤0：引入spring-boot-starter-data-redis（对Redis的操作的高级封装）

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-data-redis</artifactId>
</dependency>

包含如下：

步骤1：设计redis key

步骤2：先从redis 查缓存，命中缓存则返回结果，不然则直接查询数据库

    // 操作redis 从缓存中查询
    ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
    String cachedValueFromRedis = opsForValue.get(cacheKey);

    if (cachedValueFromRedis != null) {
        // 如果缓存命中，缓存结果
        Page<PictureVO> pictureVOPage = JSONUtil.toBean(cachedValueFromRedis, Page.class);
        return ResultUtils.success(pictureVOPage);
    }

步骤3：如果没有命中缓存，查完数据库后将返回结果写进redis

  // 设置缓存 value 给redis 
    String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
    // 设置过期时间 , 为了防止缓存雪崩，设置随机过期时间
    int cachedExpiredTime = 300 + RandomUtil.randomInt(0 , 300);
    // 设置缓存
    opsForValue.set(cacheKey, cacheValueFetchedFromDB, cachedExpiredTime, TimeUnit.SECONDS);

注意一定要设置过期时间：

int cachedExpiredTime = 300 + RandomUtil.randomInt(0 , 300);

为了防止缓存雪崩（同一时间内大量key同时过期），设置随机过期时间！

示例代码如下

@PostMapping("/cache")
public BaseResponse<Page<PictureVO>> listPictureVOByPageWithCache(@RequestBody PictureQueryRequest pictureQueryRequest , HttpServletRequest request) {
    // 查询缓存，缓存中没有再查询数据库
    // 构建缓存的key
    String queryCondition = JSONUtil.toJsonStr(pictureQueryRequest);
    String hashKey = DigestUtils.md5DigestAsHex(queryCondition.getBytes());
    String cacheKey = String.format("haodePicture:listPictureVOByPage:%s", hashKey);

    // 操作redis 从缓存中查询
    ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
    String cachedValueFromRedis = opsForValue.get(cacheKey);

    if (cachedValueFromRedis != null) {
        // 如果缓存命中，缓存结果
        Page<PictureVO> pictureVOPage = JSONUtil.toBean(cachedValueFromRedis, Page.class);
        return ResultUtils.success(pictureVOPage);
    }
    // 数据库操作
    Page<Picture> picturePage = pictureService.page(new Page<>(current, pageSize), pictureService.getQueryWrapper(pictureQueryRequest));
    Page<PictureVO> pictureVOPage = pictureService.getPictureVOPage(picturePage, request);

    // 设置缓存 value 给redis 
    String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
    // 设置过期时间 , 为了防止缓存雪崩，设置随机过期时间
    int cachedExpiredTime = 300 + RandomUtil.randomInt(0 , 300);
    // 设置缓存
    opsForValue.set(cacheKey, cacheValueFetchedFromDB, cachedExpiredTime, TimeUnit.SECONDS);

    // 获取封装类
    return ResultUtils.success(pictureVOPage);
}

到此，Redis缓存的部分结束！◝(　ﾟ∀ ﾟ )◟。

面试题：什么是缓存雪崩？缓存雪崩的解决方案？

到此，方案1：设置key的随机过期时间，避免大量key在同一时间间隔内大量失效！

思考

引入了Redis缓存就万事大吉了吗？毕竟它这么快！

问题如下：

1.缓存穿透如果请求的数据在数据库中不存在，并且每次查询都尝试从缓存获取，这将导致对数据库的频繁访问，增加负载。

2.缓存击穿高并发情况下，大量请求同时访问一个即将过期的缓存项，在它过期后瞬间涌入数据库，造成瞬时压力。

3.远程调用开销如果你的应用程序和 Redis 位于不同的机器上，那么每次访问缓存都会产生网络延迟，特别是在跨数据中心的情况下。

4.redis宕机：redis突然死了，不就没有缓存了吗？当然，可以通过充值使用第三方服务的Redis来解决(๑´ㅁ`)

本地缓存Caffeine

Caffeine is a high performance, near optimal caching library.

在这里插入图片描述

优势

相比直接操作redis ， 本地缓存缓存优势如下：

  • 低延迟：由于数据存储在应用程序的内存中，因此访问速度极快，几乎没有网络延迟。
  • 减少远程调用：可以显著降低对外部服务（如 Redis、数据库）的请求次数，减轻系统负担。
  • 简化架构：引入一个redis就多引入一个中间件，这样系统的稳定性一定会收到影响。而本地缓存Caffeine没有这个烦恼。

本地缓存Caffeine的应用

0.引入依赖

<dependency>
    <groupId>com.github.ben-manes.caffeine</groupId>
    <artifactId>caffeine</artifactId>
    <version>2.9.3</version>
</dependency>

注意：JDK 11 版本及以上用3.X版本，否则用2.X版本

  1. 构造本地缓存LOCAL_CACHE（相当于RedisTemplate）
/**
 * 本地缓存caffine
 */
private final Cache<String, String> LOCAL_CACHE = Caffeine.newBuilder()
        .initialCapacity(1024)
        .maximumSize(10_000L) // 最大10000条
        .expireAfterWrite(Duration.ofMinutes(5)) // 5分钟过期
        .build();

2.设计缓存Key

// 查询缓存，缓存中没有再查询数据库
// 构建缓存的key
String queryCondition = JSONUtil.toJsonStr(pictureQueryRequest);
String hashKey = DigestUtils.md5DigestAsHex(queryCondition.getBytes());
String cacheKey = String.format("haodePicture:listPictureVOByPage:%s", hashKey);

3.先查询本地缓存，如果命中缓存，则返回结果

// 先查本地缓存
String localCache = LOCAL_CACHE.getIfPresent(cacheKey);
if (localCache != null){
    Page<PictureVO> cachePage = JSONUtil.toBean(localCache, Page.class);
    return ResultUtils.success(cachePage);
}

4.如果没缓存，就查询数据库，并写入缓存

// 设置缓存 value  caffine 用
String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
LOCAL_CACHE.put(cacheKey, cacheValueFetchedFromDB);

完整示例代码：

@PostMapping("/cache")
public BaseResponse<Page<PictureVO>> listPictureVOByPageWithCache(@RequestBody PictureQueryRequest pictureQueryRequest , HttpServletRequest request) {

    
    // 查询缓存，缓存中没有再查询数据库
    // 构建缓存的key
    String queryCondition = JSONUtil.toJsonStr(pictureQueryRequest);
    String hashKey = DigestUtils.md5DigestAsHex(queryCondition.getBytes());
    String cacheKey = String.format("haodePicture:listPictureVOByPage:%s", hashKey);

    // 先查本地缓存
    String localCache = LOCAL_CACHE.getIfPresent(cacheKey);
    if (localCache != null){
        Page<PictureVO> cachePage = JSONUtil.toBean(localCache, Page.class);
        return ResultUtils.success(cachePage);
    }
    
    Page<Picture> picturePage = pictureService.page(new Page<>(current, pageSize), pictureService.getQueryWrapper(pictureQueryRequest));
    Page<PictureVO> pictureVOPage = pictureService.getPictureVOPage(picturePage, request);

    // 设置缓存 value   caffine 用
    String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
   
    LOCAL_CACHE.put(cacheKey, cacheValueFetchedFromDB);

    // 获取封装类
    return ResultUtils.success(pictureVOPage);
}

可以看到，操作本地缓存相比Redis更简单了，只需要引入一个pom文件，就能开始编写。不用引入一个额外的中间件！O(∩_∩)O。

所以只引入一级缓存的情况下，首先考虑Caffeine本地缓存！

多级缓存

在这里插入图片描述

为什么要引入多级缓存？

引入 Redis + Caffeine 多级缓存架构的主要目的是为了结合两者的优势，以解决单一缓存解决方案可能带来的局限性。

  • 分担压力：不是所有的请求都会直接打到 Redis 上，只有当本地缓存未命中时才会查询 Redis，从而分散了流量，避免 Redis 成为瓶颈。
  • 本地缓存加速：Caffeine 作为本地缓存，位于应用程序内存中，能够以极低的延迟提供数据访问，极大提高了热数据的获取速度。
  • 减少远程调用：通过将频繁访问的数据存储在本地，减少了对 Redis 或数据库等远程服务的请求次数，降低了网络延迟的影响。
  • 增加容错性： 即使 Redis 出现问题（如网络分区、实例崩溃），由于存在本地缓存层，应用程序仍然可以从 Caffeine 中获取部分常用数据，保持基本功能不受影响。
  • 优化持久化策略：对于那些不需要长期保存的数据，可以直接存放在本地缓存中，而不必写入 Redis，减少了持久化的开销。

多级缓存实现步骤

1.先查本地缓存，如果本地缓存命中，则直接返回

    // 先查本地缓存
    String localCache = LOCAL_CACHE.getIfPresent(cacheKey);
    if (localCache != null){
        Page<PictureVO> cachePage = JSONUtil.toBean(localCache, Page.class);
        return ResultUtils.success(cachePage);
    }

2.如果本地缓存没有命中，查redis缓存，如果命中Redis缓存，则先将从redis查到的数据设置给Caffeine

    // 操作redis 从缓存中查询
    ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
    String cachedValueFromRedis = opsForValue.get(cacheKey);

    if (cachedValueFromRedis != null) {
        // 设置本地缓存

        LOCAL_CACHE.put(cacheKey, cachedValueFromRedis);
        // 如果缓存命中，缓存结果
        Page<PictureVO> pictureVOPage = JSONUtil.toBean(cachedValueFromRedis, Page.class);
        return ResultUtils.success(pictureVOPage);
    }

3.如果两个缓存都没有命中，则直接查询数据库，并设置缓存。

 // 设置缓存 value 给redis 和 caffine 用
    String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
    // 设置过期时间 , 为了防止缓存雪崩，设置随机过期时间
    int cachedExpiredTime = 300 + RandomUtil.randomInt(0 , 300);
    // 设置缓存
    LOCAL_CACHE.put(cacheKey, cacheValueFetchedFromDB);
    opsForValue.set(cacheKey, cacheValueFetchedFromDB, cachedExpiredTime, TimeUnit.SECONDS);

完整代码示例：

@PostMapping("/cache")
public BaseResponse<Page<PictureVO>> listPictureVOByPageWithCache(@RequestBody PictureQueryRequest pictureQueryRequest , HttpServletRequest request) {
    // 查询缓存，缓存中没有再查询数据库
    // 构建缓存的key
    String queryCondition = JSONUtil.toJsonStr(pictureQueryRequest);
    String hashKey = DigestUtils.md5DigestAsHex(queryCondition.getBytes());
    String cacheKey = String.format("haodePicture:listPictureVOByPage:%s", hashKey);

    // 先查本地缓存
    String localCache = LOCAL_CACHE.getIfPresent(cacheKey);
    if (localCache != null){
        Page<PictureVO> cachePage = JSONUtil.toBean(localCache, Page.class);
        return ResultUtils.success(cachePage);
    }
    
    // 操作redis 从缓存中查询
    ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
    String cachedValueFromRedis = opsForValue.get(cacheKey);

    if (cachedValueFromRedis != null) {
        // 设置本地缓存

        LOCAL_CACHE.put(cacheKey, cachedValueFromRedis);
        // 如果缓存命中，缓存结果
        Page<PictureVO> pictureVOPage = JSONUtil.toBean(cachedValueFromRedis, Page.class);
        return ResultUtils.success(pictureVOPage);
    }
    
    Page<Picture> picturePage = pictureService.page(new Page<>(current, pageSize), pictureService.getQueryWrapper(pictureQueryRequest));
    Page<PictureVO> pictureVOPage = pictureService.getPictureVOPage(picturePage, request);

    // 设置缓存 value 给redis 和 caffine 用
    String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
    // 设置过期时间 , 为了防止缓存雪崩，设置随机过期时间
    int cachedExpiredTime = 300 + RandomUtil.randomInt(0 , 300);
    // 设置缓存
    LOCAL_CACHE.put(cacheKey, cacheValueFetchedFromDB);
    opsForValue.set(cacheKey, cacheValueFetchedFromDB, cachedExpiredTime, TimeUnit.SECONDS);


    // 获取封装类
    return ResultUtils.success(pictureVOPage);
}

注意：先查本地缓存，在查Redis。

面试题：引入多级缓存可以解决redis的什么问题？

  1. 缓存雪崩：除了设置随机过期时间，还能设置本地缓存解决redis缓存雪崩的问题。即便大量的key同时在redis里过期了，也能让本地缓存扛一会。◝(　ﾟ∀ ﾟ )◟
  2. 缓存穿透：即便请求的数据在数据库中不存在，也能把它放在本地缓存中。这样不存在的请求就不会一直打到数据库。（todo）
  3. 缓存击穿：高并发情况下，大量请求同时访问一个即将过期的缓存项，在它过期后瞬间涌入数据库，造成瞬时压力。有了本地缓存，即便出现上述现象，也能靠本地缓存顶一会，不至于直接让数据库宕机。✧◝(⁰▿⁰)◜✧
  4. 减少远程调用开销：如果你的应用程序和 Redis 位于不同的机器上，那么每次访问缓存都会产生网络延迟，而caffeine本地缓存则不用考虑网络传输的问题，减少开销。O(∩_∩)O

扩展

如何利用本地缓存解决缓存穿透？

当前代码仍然会面临缓存穿透的问题，如果用户频繁请求一个不存在的资源，这些请求还是会传递给 Redis 和数据库，造成不必要的负载。

优化点：

对于确实不存在的数据（如 null 或者自定义的空对象），可以在本地 Caffeine 缓存中短暂地存储这些值，并设置较短的 TTL。这样，在接下来的一段时间内，相同的请求将直接返回这个特殊值而不是再次查询 Redis 或数据库。

完整代码改进如下：

    @PostMapping("/cache")
    public BaseResponse<Page<PictureVO>> listPictureVOByPageWithCache(@RequestBody PictureQueryRequest pictureQueryRequest, HttpServletRequest request) {

        // 构建缓存的key
        String queryCondition = JSONUtil.toJsonStr(pictureQueryRequest);
        String hashKey = DigestUtils.md5DigestAsHex(queryCondition.getBytes());
        String cacheKey = String.format("haodePicture:listPictureVOByPage:%s", hashKey);

        // 先查本地缓存
        String localCache = LOCAL_CACHE.getIfPresent(cacheKey);
        if ("NULL".equals(localCache)) {
            return ResultUtils.error(ErrorCode.SYSTEM_ERROR, "查询结果为空");
        } else if (localCache != null) {
            Page<PictureVO> cachePage = JSONUtil.toBean(localCache, Page.class);
            return ResultUtils.success(cachePage);
        }

        // 操作redis 从缓存中查询
        ValueOperations<String, String> opsForValue = stringRedisTemplate.opsForValue();
        String cachedValueFromRedis = opsForValue.get(cacheKey);

        if (cachedValueFromRedis != null) {
            // 设置本地缓存
            LOCAL_CACHE.put(cacheKey, cachedValueFromRedis);
            // 如果缓存命中，缓存结果
            Page<PictureVO> pictureVOPage = JSONUtil.toBean(cachedValueFromRedis, Page.class);
            return ResultUtils.success(pictureVOPage);
        }

        // 查询数据库
        Page<Picture> picturePage = pictureService.page(new Page<>(current, pageSize), pictureService.getQueryWrapper(pictureQueryRequest));
        if (picturePage.getRecords().isEmpty()) {
            // 如果查询结果为空，缓存空结果并返回失败
            LOCAL_CACHE.put(cacheKey, "NULL");
            return ResultUtils.error(ErrorCode.NOT_FOUND_ERROR, "No data found");
        }

        // 脱敏
        Page<PictureVO> pictureVOPage = pictureService.getPictureVOPage(picturePage, request);

        // 设置缓存 value 给redis 和 caffine 用
        String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
        // 设置过期时间 , 为了防止缓存雪崩，设置随机过期时间
        int cachedExpiredTime = 300 + RandomUtil.randomInt(0, 300);
        // 设置缓存
        LOCAL_CACHE.put(cacheKey, cacheValueFetchedFromDB);
        opsForValue.set(cacheKey, cacheValueFetchedFromDB, cachedExpiredTime, TimeUnit.SECONDS);

        // 获取封装类
        return ResultUtils.success(pictureVOPage);
    }

在数据库查询失败的时候，写入一个NULL值进本地缓存，这样，下次再有查询不存在数据的请求时，就能够直接走本地缓存，而不用在打爆数据库了O(∩_∩)O！

异步化执行写缓存

// 异步设置缓存
    CompletableFuture.runAsync(() -> {
        try {
            String cacheValueFetchedFromDB = JSONUtil.toJsonStr(pictureVOPage);
            int cachedExpiredTime = 300 + RandomUtil.randomInt(0, 300);
            LOCAL_CACHE.put(cacheKey, cacheValueFetchedFromDB);
            opsForValue.set(cacheKey, cacheValueFetchedFromDB, cachedExpiredTime, TimeUnit.SECONDS);
        } catch (Exception e) {
            // 记录异常信息
            log.error("Failed to set cache for key: {}", cacheKey, e);
            // 可选：根据具体需求决定是否重试或采取其他行动
        }
    }, customThreadPool); // 使用自定义线程池
Redis与Caffeine的结合使用详解（高效的二级缓存解决方案）
C_V_Better的博客
04-11 530
通过结合 Redis 和 Caffeine，可以构建一个高效的二级缓存解决方案。Caffeine 作为一级缓存，提供快速的本地访问；Redis 作为二级缓存，提供数据的持久化和分布式共享。这种架构在提高数据访问速度、减少数据库压力方面具有显著优势。希望本文的示例和讲解对您有所帮助，如果您在实现二级缓存时有任何疑问，欢迎随时交流探讨！
【Caffeine进阶】Redis+Caffeine 两级缓存实战，性能爆缸
You’re a wanderer just like me
03-31 5187
往期回顾 博主前面发过一篇【缓存框架Caffeine】初级篇，主要介绍了Caffeine的入门级使用！地址https://blog.csdn.net/Number_oneEngineer/article/details/123328014?spm=1001.2014.3001.5501 本文主要介绍 Caffeine以注解的方式来操作缓存,将原本全手动操作方式，改进为本地缓存交给spring管理 Caffeine基于切面操作，自定义注解的方式来操作缓存 前面两种方式搭配Redis实现两级缓存实战 .
Spring Boot 多级缓存实战：基于 Redis+Redisson 构建高并发解决方案
留夕的博客
02-19 827
维度单一本地缓存单一Redis缓存多级缓存方案响应速度快(10ns)一般(1ms)极快（热点数据10ns）数据一致节点间不一致强一致最终一致（毫秒级）扩展能力受限于单机水平扩展容易弹性扩展容错能力单点故障集群容灾多级容错。
spring boot+spring cache实现两级缓存(redis+caffeine)
08-27
主要介绍了spring boot+spring cache实现两级缓存(redis+caffeine)，小编觉得挺不错的，现在分享给大家，也给大家做个参考。一起跟随小编过来看看吧
Caffeine+Redis两级缓存架构
qq_22772699的博客
10-07 2784
/支持springEl表达式l2TimeOut 为可以设置的二级缓存 Redis 的过期时间CacheType 是一个枚举类型的变量，表示操作缓存的类型FULL, //存取PUT, //只存DELETE //删除//创建表达式解析器//通过evaluationContext.setVariable可以在上下文中设定变量。//解析表达式//使用Expression.getValue()获取表达式的值，这里传入了Evaluation上下文。
实现多级缓存（Redis+Caffeine）
刘皇叔说Java的博客
01-07 2542
在高性能的服务架构设计中，缓存是一个不可或缺的环节。在实际的项目中，我们通常会将一些热点数据存储到Redis或MemCache这类缓存中间件中，只有当缓存的访问没有命中时再查询数据库。在提升访问速度的同时，也能降低数据库的压力。随着不断的发展，这一架构也产生了改进，在一些场景下可能单纯使用Redis类的远程缓存已经不够了，还需要进一步配合本地缓存使用，例如Guava cache或Caffeine，从而再次提升程序的响应速度与服务性能。
代码优化-Redis + Caffeine的多级缓存使用
qq_25341829的博客
03-11 683
本文按照对业务入侵的递减程度，依次介绍了三种管理两级缓存的方法。至于在项目中是否需要使用二级缓存，需要考虑自身业务情况，如果Redis这种远程缓存已经能够满足你的业务需求，那么就没有必要再使用本地缓存了。毕竟实际使用起来远没有那么简单，本文中只是介绍了最基础的使用，实际中的并发问题、事务的回滚问题都需要考虑，还需要思考什么数据适合放在一级缓存、什么数据适合放在二级缓存等等的其他问题。
多级缓存架构实战：Caffeine+Redis
weixin_46619605的博客
03-12 519
多级缓存架构实战：Caffeine+Redis
分布式二级缓存组件实战（Redis+Caffeine实现）
Cr1556648487的博客
08-28 949
核心是get方法与put方法。@Getter/*** 默认key超时时间 3600s*/{}}}@Override}@Override}@Override= null) {}//key在redis和缓存中均不存在}try {= null) {}//执行原方法获得value}}@Overrideif (!return;}
【Redis 开发】多级缓存，本地进程缓存Caffeine
weixin_62513677的博客
04-29 617
默认情况下，当一个元素过期的时候，Caffeine不会立即将其清理或删除，而是当再一次读或写操作后，或者在空闲时间完成对失效数据的驱逐。Redis处理并发的能力是非常强大的，但是tomcat的支持并发的能力跟不上Redis的性能，导致整体性能的下降。为了应对上述问题，我们采用多级缓存，就是在请求处理的每个环节分别添加缓存，减轻tomcat的压力，提升性能。Caffeine是一个基于java8开发的，提供了近乎最佳命中率的高性能本地缓存库。缺点：存储容量有限，可靠性较低，无法共享。
Java本地缓存：Caffeine与Redis的多级缓存同步.pdf
最新发布
04-27
文档支持目录章节跳转同时还支持阅读器左侧大纲显示和...作为一种广泛应用于企业级开发、移动应用、大数据等众多领域的编程语言，Java 以其跨平台性、高性能和丰富的类库，为开发者提供了一个稳定而高效的开发环境。
Redis + Caffeine实现多级缓存
qq_48649411的博客
07-11 1711
一个关于Redis + Caffeine实现多级缓存的demon，结合spring-cache和Aop实现
Redis+Caffeine两级缓存，让访问速度纵享丝滑
03-28 640
原创：微信公众号 码农参上，欢迎分享，转载请保留出处。 在高性能的服务架构设计中，缓存是一个不可或缺的环节。在实际的项目中，我们通常会将一些热点数据存储到Redis或MemCache这类缓存中间件中，只有当缓存的访问没有命中时再查询数据库。在提升访问速度的同时，也能降低数据库的压力。 随着不断的发展，这一架构也产生了改进，在一些场景下可能单纯使用Redis类的远程缓存已经不够了，还需要进一步配合本地缓存使用，例如Guava cache或Caffeine，从而再次提升程序的响应速度与服务性能。于是，就产生.
Caffeine 和 Redis 整合二级缓存
weixin_49648855的博客
10-08 510
/ 在缓存中实际执行查找的操作，父类的get()方法会调用这个方法// 通过key获取缓存值，如果没有找到，会调用valueLoader的call()方法// 将数据放入缓存中// 删除缓存// 清空缓存中所有数据// 获取缓存名称，一般在CacheManager创建时指定// 获取实际使用的缓存。
使用 Caffeine 和 Redis 实现高效的二级缓存架构
fastboot
12-02 1742
在现代应用开发中，缓存是提升系统性能的关键手段。为了兼顾本地缓存的高性能和分布式缓存的扩展能力，常见的实现方式是结合使用 Caffeine 和 Redis 实现二级缓存架构。本文将详细介绍如何通过 Spring Boot 实现一个Caffeine + Redis 二级缓存，并通过合理的架构设计和代码实现，确保缓存的一致性、性能和容错性。一、 需求与挑战1.多级缓存的需求：•一级缓存（Caffein...
Redis+Caffeine缓存实战：应用性能瞬间提升
资料免费分享，点击名片
10-12 389
核心是get方法与put方法。/** * 默认key超时时间 3600s */ private long defaultExpiration = 3600;if (value!} //key在redis和缓存中均不存在 ReentrantLock lock = keyLockMap.get(key.toString());if (value!
Redis+Caffeine 实现两级缓存实战
Y_eatMeat的博客
07-10 2125
本文介绍Redis+Caffeine实现两级缓存的方式。一种是常规的方式，一种的基于注解的方式。具体的实现可根据自己项目中的业务场景。至于为什么要用Redis+Caffeine的方式，文章也提到了，目前我们Redis集群压力还算挺大的，而且接口对RT的要求也是比较高的。有一点好的就是我们的数据是每天全量推一边，总量也不大，实时性要求也不强。所以就很适合本地缓存的方式。使用本地缓存也要注意设置容量的大小和过期时间，否则容易出现内存溢出。
redis caffeine 二级缓存
05-12
Redis和Caffeine都是常用的缓存方案，而将它们结合起来使用，可以形成二级缓存方案。 二级缓存的核心思想是将数据存储在两个不同的缓存中，通常是一个内存缓存和一个持久化缓存，以提高缓存的效率和可靠性。在这种情况下，Caffeine可以用作内存缓存，而Redis可以用作持久化缓存。 使用Caffeine作为内存缓存可以提供非常快速的访问速度，并且数据可以在内存中保持最新状态。但是，Caffeine缓存是有限制的，如果缓存过多数据，可能导致内存使用过高，从而影响系统的性能。因此，我们需要一个持久化缓存来保存一些不常用的数据或者缓存数据的备份。 Redis是一个高效的键值存储系统，可以将数据保存在磁盘上，因此即使系统重启也不会丢失数据。Redis还提供了一些高级功能，如发布/订阅模式、事务和 Lua脚本执行。通过将Redis用作持久化缓存，我们可以使系统更可靠，并且可以存储更多的数据。 在实际应用中，我们可以使用Caffeine作为一级缓存，Redis作为二级缓存。当需要获取数据时，首先在Caffeine中查找，如果没有找到，则从Redis中获取，如果还没有找到，则从数据库中获取。在更新数据时，我们可以将数据先更新到数据库中，然后再更新到Caffeine和Redis中，以保持数据的一致性。 综上所述，结合Redis和Caffeine使用可以提高缓存的效率和可靠性，但是具体实现需要根据实际情况进行调整。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值