Redis缓存踩坑覆盖设置List缓存对象

使用JSON字符串实现列表接口缓存替换
最新推荐文章于 2024-12-10 15:00:52 发布
原创 最新推荐文章于 2024-12-10 15:00:52 发布 · 839 阅读 · 11 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#缓存 #redis #spring

本文介绍了如何在需要更新缓存列表时，通过将List对象转换为JSON字符串并利用Redis的缓存机制，如Util.setCacheObject方法，实现全量覆盖缓存的过程。

有时候想缓存列表接口，有新的list对象产生就覆盖原来的list对象。现成的redis操作集合的方法没有这个全部覆盖的方法，要转换思想，把lsit对象转换成一个josn字符串，进行缓存。

//将list对象转换成 json字符串，然后设置对应的缓存
Util.setCacheObject(xxxxx_key,JSONObject.toJSONString(listObject),6l,TimeUnit.HOURS);
  /**
     * 缓存基本的对象，Integer、String、实体类等
     *
     * @param key      缓存的键值
     * @param value    缓存的值
     * @param timeout  时间
     * @param timeUnit 时间颗粒度
     */
    public <T> void setCacheObject(final String key, final T value, final Long timeout, final TimeUnit timeUnit) {
        redisTemplate.opsForValue().set(key, value, timeout, timeUnit);
    }

【Redis缓存机制】缓存更新、缓存穿透、缓存雪崩、缓存击穿
acm_pn的博客
12-05 2380
当缓存区缓存了用户信息后，客户端就都会从redis中访问读取数据了。而如果这时候用户更新了数据库中的值，就会导致数据库存储的数据与redis存储数据不一致，在这之后进行读写操作就会发生各种意想不到的错误了因此，当我们要对数据库数据进行更新时，也要尽可能让edis中的数据也能跟着变化，避免用户读到错误的信息缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样每次查询缓存都不会命中，最后都会对数据库进行查询。就像是缓存被穿透了一样，每次请求都会直接到达数据库。
解决Redis缓存穿透（缓存空对象、布隆过滤器）
后端
10-25 1523
这里选择使用布隆过滤器存储存在于数据库中的 id，原因在于，如果存储了不存在于数据库中的 id，首先由于 id 的取值范围很大，那么不存在的 id 有很多，因此更占用空间；相反，如果存储的是数据库中存在的 id，那么即使少数不存在的 id 被判为了存在，由于数据库中确实没有对应的 id，那么也会返回空，最终结果还是正确的。由于布隆过滤器有一定的误判率，所以这里可以进一步优化，如果出现误判情况，即原本不存在于数据库中的 id 被判为了存在，就用缓存空对象的方式将其缓存到 redis 中。
redis存储List集合
06-16
用C#Winform做的一个上传excel，读取excel内容然后将其存储到redis的一个小demo,一个好用的地方就是读取excel的方法，公用的~
opsforlist 存在贼覆盖_RedisTemplate常用集合使用说明-opsForList(三)
weixin_28928727的博客
12-24 1199
基础配置介绍已经在前面的《RedisTemplate常用集合使用说明(一)》中已经介绍了，现在我们直接介绍opsForList()方法的使用：1、leftPush(Kkey,Vvalue)在变量左边添加元素值。Java代码redisTemplate.opsForList().leftPush("list","a");redisTemplate.opsForList().leftPush("l...
redis基础和原理全覆盖
栋幺栋幺-的博客
11-13 1055
Redis 是什么 Redis: REmote DIctionary Server(远程字典服务器) 完全开源免费，C语言编写遵守BSD协议，一个高性能的（key/value)分布式内存数据库。基于内存运行并支持持久化的NOSQL数据库被称为数据结构服务器。 与其他key-value缓存产品区别？ - 性能优秀，数据在内存中，读写速度非常快，支持并发- 10W QPS； - 单进程单线程，是线程安全的，采用IO多路复用机制；
在Java程序中运用 Redis 缓存对象的方法
振峰的博客
03-21 757
原文：https://blog.youkuaiyun.com/dange_h/article/details/88661936 这段时间一直有人问如何在Redis中缓存Java中的List 集合数据，其实很简单，常用的方式有两种： 1. 利用序列化，把对象序列化成二进制格式，Redis 提供了 相关API方法存储二进制，取数据时再反序列化回来，转换成对象。 2. 利用 Json与java对象...
Redis 存储List对象
u011007180的博客
09-18 3305
如果需要用到Redis存储List对象，而list又不需要进行操作，可以按照MC的方式进行存储，不过Jedis之类的客户端没有提供API，可以有两种思路实现： 1.      分别序列化 elements ,然后 set存储 2.    序列化List对象，set存储 这两种方法都类似MC的 Object方法存储，运用这种方式意味着放弃Redis对List提供的操作方法。 [jav
精选资源
使用.Net 技术操作Redis缓存技术，对Redis缓存进行存储增删改查等相关操作
03-24
Redis是一种高性能的键值数据库，常用于数据缓存、消息队列、主从复制等多种场景。在.NET开发环境中，我们通常使用StackExchange.Redis库来与Redis进行交互。本篇文章将详细探讨如何使用.NET技术，尤其是C#语言，来...
redis缓存服务器
12-28
Redis 是一个高性能的键值对数据存储系统，常被用作数据库、缓存和消息中间件。它支持多种数据结构，如字符串、哈希、列表、集合、有序集合，这使得 Redis 在各种场景下有着广泛的应用。Redis 以其内存高速读写性能...
redis 缓存jwt令牌设置更新时间 BUG修复
2202_75352238的博客
06-16 754
就是 我 redis中存储的键 名 为token 值 是jwt令牌 ，但是如果 用户a 登录 之后 创建一个 键 为token的 键值对，如果用户b登录，创建的的键名也是 token ，这样用户b的 jwt 会覆盖 用户a的，就会导致 用户a 的token 会失效呀，这真是一个大大的bug ， 按照我目前的水平，我想到了一下 的解决方案 ，既然 token 的键会覆盖，那么我们给 token的键 加上一个唯一标识不就好了。我们apifox进行登录接口的依次登录 ，然后观察 redis中的缓存数据。
redis存list对象_JavaWeb——redis【综合案例】使用redis缓存商品分类
weixin_42163404的博客
01-21 2157
JavaWeb——redis【综合案例】使用redis缓存商品分类思路分析：查询redis，没有json数据，就调用CategoryDao，去获取集合List<Category>先返回给CategorySrvice，再转成json存进redis第二次起，直接获取redis中的json，将json转成List<Category>我这边使用测试驱动开发，所以，我先写一个测试类，...
将list对象存储进redis中去
m0_67403076的博客
08-28 4454
Redis存储支持的类型没有object，虽然有支持list，但是它只支持list。所以我们可以将list对象转换成json字符串,然后再将字符串传入到redis中去。
Redis对象——列表(list)
Oh~Why not!
06-09 4702
提示：写完文章后，目录可以自动生成，如何生成可参考右边的帮助文档 文章目录 系列文章目录 前言 一、pandas是什么？ 二、使用步骤 1.引入库 2.读入数据 总结 前言 提示：这里可以添加本文要记录的大概内容： 例如：随着人工智能的不断发展，机器学习这门技术也越来越重要，很多人都开启了学习机器学习，本文就介绍了机器学习的基础内容。 提示：以下是本篇文章正文内容，下面案例可供参考 一、pandas是什么？ 示例：pandas 是基于NumPy 的一种工具...
List【Redis对象篇】
席万里的博客
12-10 1614
Redis对象篇【List】
Redis_List_基本用法
Jimmy Huang's Blog
04-08 530
单值多value 零、性能总结 它是一个字符串链表，Ieft、rght 都可以插入添加 如果键不存在，创建新的链表 如果键已存在，新增内容；如果值全移除，对应的键也就消失了 链表的操作无论是头和尾效率都极高，但假如是对中间元素进行操作，效率就很惨淡了 一、List（列表） ​ Redis 列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素导列表的头部（左边）或者尾部（右边）。它的底层实际...
「Redis数据结构」列表对象（List）
frozenpenguin的博客
12-07 2390
Redis列表是简单的字符串列表，按照插入顺序排序。你可以添加一个元素到列表的头部（左边）或者尾部（右边）。一个列表最多可以包含 232 - 1 个元素 (4294967295, 每个列表超过40亿个元素)。列表对象的编码可以是ziplist或者linkedlist。ziplist编码的列表对象使用压缩列表作为底层实现，每个压缩列表节点(entry)保存了一个列表元素。
通过 Java 操作 redis -- list 列表基本命令
q322359的博客
05-08 1768
关于 redis list 列表类型的相关命令要想通过 Java 操作 redis，首先要连接上 redis 服务器，本博客只介绍了一小部分常用的命令，其他的命令根据上面推荐的博客也能很简单的使用出来（推荐先看上面推荐的博客，有 redis 的原生命令）
Redis类型之lists类型
人生不设限前进向梦想
05-30 393
Redis类型之lists类型 1、lpush 在key对应list的头部添加字符串元素 2、rpush 在key对应list 的尾部添加字符串元素 3、linsert 在key对应list的特定位置之前或之后添加字符串元素 4、lset 设置list中指定下标的元素值(下标从0开始) 5、lrem ...
java redis缓存list覆盖更新
最新发布
07-12
<think>我们正在讨论Java中使用Redis缓存，特别是如何覆盖更新一个List。根据之前引用的内容，我们知道Redis的数据结构存储在redisDb中，其中dict *dict指向键空间（keyspace）。对于List类型，Redis内部使用quicklist实现（在较新版本中），但用户操作时通常使用列表命令。 用户需求：在Java中更新Redis缓存的List，要求覆盖更新（即完全替换旧列表）。 实现思路： 1. 使用RedisTemplate（Spring Data Redis）操作Redis。 2. 由于是覆盖更新，我们可以先删除旧的key，再重新设置一个新的列表。或者直接使用set操作覆盖（但Redis的列表没有直接的覆盖命令，通常使用删除后重新添加的方式）。 具体步骤： a. 删除现有的key（如果存在） b. 将新的List整个添加到这个key中 注意：Redis的列表操作命令中，没有直接替换整个列表的命令。但是，我们可以通过事务或管道来保证原子性。 然而，考虑到覆盖更新，我们可以使用以下两种方式： 方式1：使用事务（multi）或管道（pipeline）组合DEL和RPUSH（或LPUSH）命令。 方式2：使用序列化方式存储整个List（比如使用String结构存储序列化的List），然后直接覆盖写。但这样就不能使用列表的命令了（如LPOP, RPUSH等）。 根据用户需求，如果后续需要操作列表（如按索引获取元素，弹出元素等），那么应该使用Redis的List结构。如果只是整体存储和读取，也可以考虑使用String结构。 但问题中明确要求更新的是List，所以我们假设用户希望使用Redis的List结构。 因此，我们采用： 1. 删除旧的key（使用DEL命令） 2. 将新的List元素全部添加到key中（使用RPUSH或LPUSH） 在Java中，使用Spring Data Redis的RedisTemplate，我们可以这样做： 步骤： 1. 获取RedisTemplate实例 2. 使用delete方法删除key 3. 使用leftPushAll或rightPushAll方法添加整个列表 但是，注意：删除和添加两个操作不是原子的。在并发环境下，可能会出现问题。因此，我们可以使用Redis的事务支持，或者使用Lua脚本来保证原子性。 考虑到性能，使用Lua脚本是最佳选择，但这里我们先给出一个简单的事务方式。 示例代码（使用事务）： ```java redisTemplate.execute(new SessionCallback<Object>() { @Override public Object execute(RedisOperations operations) throws DataAccessException { operations.multi(); // 开启事务 operations.delete(key); // 删除旧列表 operations.opsForList().rightPushAll(key, newList); // 添加新列表 operations.exec(); // 执行事务 return null; } }); ``` 或者使用管道（pipeline）来提高性能（特别是在列表很大时）： ```java redisTemplate.executePipelined(new SessionCallback<Object>() { @Override public Object execute(RedisOperations operations) throws DataAccessException { operations.delete(key); operations.opsForList().rightPushAll(key, newList); return null; } }); ``` 注意：管道不是原子的，但可以批量发送命令，减少网络开销。而事务是原子的。根据需求选择。 另外，如果用户不需要事务，也可以直接执行两个命令（因为覆盖更新本身就是先删后加，如果中间没有其他操作，在非并发情况下也可以）。 但是，在并发环境下，多个客户端可能同时更新同一个key，因此需要根据业务场景决定是否使用事务或乐观锁（watch）等机制。 然而，覆盖更新通常意味着该key对应的数据完全由当前更新决定，所以一般情况下，先删除再添加是安全的（即使并发，最终结果也是最后一次更新的数据，但中间状态可能不一致）。如果要求强一致性，则需要使用事务或分布式锁。 因此，我们给出两种方案： 方案1（非原子，但简单）： ```java redisTemplate.delete(key); redisTemplate.opsForList().rightPushAll(key, newList); ``` 方案2（使用事务保证原子性）： 如上所示的事务代码。 方案3（使用Lua脚本，原子性）： 编写Lua脚本： ```lua -- 参数：key, 新的列表元素（用数组传递） -- 先删除key，然后重新创建列表 redis.call('DEL', KEYS[1]) for i, v in ipairs(ARGV) do redis.call('RPUSH', KEYS[1], v) end ``` 在Java中执行Lua脚本： ```java // 定义脚本 String script = "local key = KEYS[1]\n" + "redis.call('DEL', key)\n" + "for i, v in ipairs(ARGV) do\n" + " redis.call('RPUSH', key, v)\n" + "end"; DefaultRedisScript<Long> redisScript = new DefaultRedisScript<>(script, Long.class); // 执行脚本，参数：key, 其他参数（列表元素） // 注意：将列表元素转换为数组，作为ARGV传递 List<String> keys = new ArrayList<>(); keys.add(key); // 将newList转换为字符串数组（根据序列化器，这里假设元素是字符串） String[] args = newList.toArray(new String[0]); redisTemplate.execute(redisScript, keys, args); ``` 注意：Lua脚本中的元素传递需要根据实际情况调整，如果列表元素不是字符串，需要序列化。这里假设列表元素是字符串。 另外，使用Lua脚本时，要注意脚本不能太大（因为ARGV有长度限制），如果列表元素非常多，可能会导致问题。此时，建议使用管道批量添加。 总结： 根据列表大小和并发要求选择合适的方式： - 小列表且并发要求不高：方案1（简单删除再添加） - 需要事务保证：方案2（事务） - 需要原子性且列表不是特别大：方案3（Lua脚本） 另外，引用[2]中提到Redis的渐进式Rehash，但这里我们操作的是单个key，不会触发Rehash（除非整个Redis正在扩容），所以不用考虑。 但是，注意：如果列表非常大，一次性添加可能会阻塞Redis（因为Redis是单线程）。所以，对于大列表，建议分批次更新（比如使用管道分批添加），或者考虑使用其他数据结构（如分片存储）。 不过，覆盖更新通常要求整体替换，所以如果列表非常大，可以考虑使用String结构存储序列化后的整个列表，然后使用set命令覆盖。这样只需要一次操作，但无法使用列表命令。 因此，如果用户需要频繁操作列表中的元素，则使用List结构；如果只是整体存取，则使用String结构。 针对String结构的覆盖更新： ```java // 假设使用StringRedisTemplate stringRedisTemplate.opsForValue().set(key, objectMapper.writeValueAsString(newList)); ``` 这里需要将List序列化为字符串（如JSON）。 所以，最终需要根据实际业务场景选择数据结构。 建议：如果业务中需要操作列表中的单个元素（如通过索引获取、修改某个元素），则使用List结构；如果总是整体读取和更新，则使用String结构。 因此，在回答中，我们应该先询问用户的具体使用场景，或者根据问题描述（更新List）假设用户需要List结构。 根据问题“update cached list with overwrite”，我们假设用户需要List结构，所以我们提供List结构的覆盖更新方法。 最后，我们给出一个完整的示例（使用事务方式）： ```java @Autowired private RedisTemplate<String, Object> redisTemplate; public void overwriteList(String key, List<Object> newList) { redisTemplate.execute(new SessionCallback<Object>() { @Override public Object execute(RedisOperations operations) throws DataAccessException { operations.multi(); operations.delete(key); operations.opsForList().rightPushAll(key, newList); operations.exec(); return null; } }); } ``` 注意：这里RedisTemplate的value序列化器需要能够序列化List中的元素类型。 如果使用StringRedisTemplate，则List中的元素必须是字符串，或者需要手动序列化。 因此，我们假设用户已经配置好了合适的RedisTemplate。 相关问题： 1. 在覆盖更新Redis列表时，如何保证原子性？ 2. 如果列表非常大，如何优化覆盖更新的性能？ 3. 使用List结构和String结构存储列表各自的优缺点是什么？</think>### Java中Redis缓存List的覆盖更新方法 在Java中使用Redis覆盖更新List缓存时，核心思路是**先删除旧列表再创建新列表**。Redis的List数据结构不支持直接覆盖更新，需要通过组合操作实现原子性替换。以下是具体实现方法： #### 方法1：事务操作（推荐） 使用Redis事务保证删除和重建的原子性： ```java // 使用Spring Data Redis的RedisTemplate public void overwriteList(String key, List<String> newList) { redisTemplate.execute(new SessionCallback<>() { public Object execute(RedisOperations operations) { operations.multi(); // 开启事务 operations.delete(key); // 删除旧列表 operations.opsForList().rightPushAll(key, newList); // 添加新列表 operations.exec(); // 提交事务 return null; } }); } ``` #### 方法2：Lua脚本 通过Lua脚本实现原子操作（性能更优）： ```java // 定义Lua脚本 String script = "redis.call('DEL', KEYS[1])\n" + "for i, v in ipairs(ARGV) do\n" + " redis.call('RPUSH', KEYS[1], v)\n" + "end"; // 执行脚本 public void overwriteList(String key, List<String> newList) { RedisScript<Void> redisScript = new DefaultRedisScript<>(script, Void.class); redisTemplate.execute(redisScript, Collections.singletonList(key), newList.toArray()); } ``` #### 方法3：管道操作 适用于大数据量场景，减少网络开销： ```java public void overwriteList(String key, List<String> newList) { redisTemplate.executePipelined((RedisCallback<Object>) connection -> { connection.del(key.getBytes()); // 删除旧数据 for (String item : newList) { connection.rPush(key.getBytes(), item.getBytes()); // 批量添加新数据 } return null; }); } ``` ### 关键注意事项 1. **原子性保障** 事务或Lua脚本可防止删除后重建过程中出现其他操作干扰[^2]。 2. **性能优化** - 大数据量时使用管道(pipeline)减少网络往返次数 - 考虑使用渐进式更新（部分替换）替代全量覆盖[^2] 3. **序列化一致性** 确保RedisTemplate的序列化配置与数据类型匹配： ```java // 配置示例 redisTemplate.setKeySerializer(new StringRedisSerializer()); redisTemplate.setValueSerializer(new Jackson2JsonRedisSerializer<>(List.class)); ``` 4. **异常处理** 添加重试机制应对网络波动： ```java @Retryable(maxAttempts = 3, backoff = @Backoff(delay = 100)) public void safeOverwrite(...) { ... } ``` ### 不同场景选择建议 | **场景** | **推荐方案** | **优势** | |------------------------|--------------------|------------------------------| | 小数据量+强一致性要求 | Lua脚本 | 原子性保证 | | 大数据量(>1000元素) | 管道操作 | 网络开销最小化 | | 需要事务管理 | Redis事务 | 与Spring事务体系集成 | > 注：Redis的List底层采用quicklist结构（压缩列表+链表组合），全量替换时需评估内存开销[^1]。
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

JB091

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

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

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

打赏作者

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

抵扣说明：

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

余额充值