Redis缓存穿透+缓存击穿+缓存雪崩 案例及解决方案(代码实现)

于 2024-08-07 15:12:05 发布
阅读量362 收藏 4
点赞数 4
文章标签： 缓存 redis spring
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/CXY123654654321/article/details/140992675
版权

1、介绍

1.1、缓存穿透

什么是缓存穿透？

用户请求的数据在缓存和数据库中都不存在，用户每次请求数据都需要查询数据库，导致对后台数据库的频繁访问，数据库负载压力过大，这种现象就叫做缓存穿透。

产生原因

黑客大量访问不存在的key，导致数据库处理大量请求

解决方案

1、缓存空对象

2、布隆过滤器

1.2、缓存击穿

什么是缓存击穿？

redis中存在某些热点数据时，即有大量请求并发访问的key-value数据。当极热点key-value数据突然失效时，缓存未命中引起对后台数据库的频繁访问，这种现象叫缓存击穿。

产生原因

缓存上热点数据突然失效

解决方案

1、热点key设置永不过期，或者异步后台更新

2、采用互斥锁

1.3、缓存雪崩

什么是缓存雪崩？

缓存数据在同一时间点失效，导致大量的请求到数据库，从而使得是数据库崩溃。

产生原因

1、大量数据使用了同一过期时间

2、redis故障

解决方案

1、缓存数据的过期时间设置随机。防止同一时间大量缓存数据集体失效，导致数据库压力过大。

2、采用Redis高可用架构。可将热点数据分别存放到不同缓存数据库中，避免某一点由于压力过大而down掉。

3、请求限流、熔断机制、服务降级等手段。降低服务器负载。

2、缓存穿透

2.1、模拟缓存穿透

1、请求一个数据库中没有的key值，导致一直访问数据库，造成缓存穿透

2.2、解决方案

2.2.1、缓存空对象

2.2.2、布隆过滤器

3、缓存击穿

3.1、模拟缓存击穿

1、初始化缓存，把数据库中所有数据加入缓存中

2、多线程访问热点key 88，查询是否全部命中缓存

3、删除热点key为88的缓存，模拟热点key过期，多线程访问

4、多线程访问热点key 88

PixPin_2024-07-07_20-17-56

Snipaste_2024-07-07_11-07-07

Snipaste_2024-07-07_11-13-58

3.2、解决方案

3.2.1、互斥锁

缓存击穿解决方案1-互斥锁PixPin_2024-07-11_22-49-26.gif

image-20240712092721619

3.2.2、异步定时任务

缓存击穿解决方案2-异步定时任务PixPin_2024-07-11_22-53-36.gif

 

image-20240712092917288

4、缓存雪崩

image.png

4.1、模拟缓存雪崩

1、初始化缓存，把数据库中所有数据加入缓存中

2、多线程访问 30至40间的热点key，查询是否全部命中缓存

3、删除 30至40间的热点key的缓存，模拟多个热点key同时过期，多线程访问

4、多线程访问 30至40间的热点key

PixPin_2024-07-07_20-30-05

Snipaste_2024-07-07_11-20-24

Snipaste_2024-07-07_11-41-59

4.2、解决方案

4.2.1、互斥锁

缓存雪崩解决方案1-互斥锁PixPin_2024-07-11_22-57-26.gif

image-20240712093155767

4.2.2、异步定时任务

缓存雪崩解决方案2-异步定时任务PixPin_2024-07-11_22-59-59.gif

image-20240712095913145

4.2.3、随机过期时间

缓存雪崩解决方案3-均匀随机过期时间PixPin_2024-07-11_23-02-15.gif

 

缓存雪崩解决方案3-均匀随机过期时间PixPin_2024-07-11_23-02-15.gif

image-20240712100050664

5、代码实现

5.0、建表语句

 

sql
 

代码解读
 

复制代码
 

CREATE TABLE `user_bank` ( `id` int NOT NULL AUTO_INCREMENT, `user_id` int DEFAULT NULL COMMENT '用户Id', `user_name` varchar(50) DEFAULT NULL COMMENT '用户名称', `amount` int NOT NULL DEFAULT '0' COMMENT '用户余额', PRIMARY KEY (`id`), UNIQUE KEY `user_bank_id_uindex` (`id`), UNIQUE KEY `user_bank_user_id_uindex` (`user_id`) ) ENGINE=InnoDB AUTO_INCREMENT=118 DEFAULT CHARSET=utf8mb3 COMMENT='用户余额表'; 
 

5.1、目录结构
 

image-20240712101851472
 

5.2、依赖
 

 

xml
 

代码解读
 

复制代码
 

<dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-test</artifactId> <scope>test</scope> </dependency> <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- mysql --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <!-- mybatis --> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>1.3.2</version> </dependency> <dependency> <groupId>com.alibaba</groupId> <artifactId>fastjson</artifactId> <version>1.2.83</version> </dependency> <!-- guava实现布隆过滤器 --> <dependency> <groupId>com.google.guava</groupId> <artifactId>guava</artifactId> <version>17.0</version> </dependency> 
 

5.3、配置文件
 

 

yml
 

代码解读
 

复制代码
 

server: port: 8087 servlet: context-path: / # mysql连接 spring: datasource: url: jdbc:mysql://localhost:3309/redis_study?useUnicode=true&characterEncoding=utf-8&useSSL=false&serverTimezone=Asia/Shanghai username: root password: root driver-class-name: com.mysql.cj.jdbc.Driver redis: host: localhost port: 6379 password: redis database: 3 
 

5.4、controller
 

缓存穿透
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.controller; import com.wangzhan.domain.UserBank; import com.wangzhan.service.CachePenetrationService; import org.springframework.beans.factory.annotation.Autowired; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.annotation.Resource; /** * @author wangzhan * @version 1.0 * @description 缓存穿透 * @date 2024/7/6 11:09:30 */ @RestController @RequestMapping("/cachePenetration") public class CachePenetrationController { @Resource private CachePenetrationService cachepenetrationService; /*** * @description 模拟缓存穿透 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("imitateCachePenetration") public UserBank imitateCachePenetration(Integer id) { return cachepenetrationService.imitateCachePenetration(id); } /*** * @description 解决方案一：缓存空对象 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("cacheNullKey") public Object cacheNullKey(Integer id) { return cachepenetrationService.cacheNullKey(id); } /*** * @description 解决方案二：布隆过滤器 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("bloomFilter") public Object bloomFilter(Integer id) { return cachepenetrationService.bloomFilter(id); } } 
 

缓存击穿
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.controller; import com.wangzhan.domain.UserBank; import com.wangzhan.service.HotspotInvalidService; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.annotation.Resource; /** * @author wangzhan * @version 1.0 * @description 缓存击穿 * @date 2024/7/6 11:10:17 */ @RestController @RequestMapping("/hotspotInvalid") public class HotspotInvalidController { @Resource private HotspotInvalidService hotspotInvalidService; /*** * @description 1、模拟缓存击穿-初始化缓存 * @return void * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("initCache") public void initCache() { hotspotInvalidService.initCache(); } /*** * @description 2、模拟缓存击穿(数据从缓存中获取) 4、模拟缓存击穿(数据从数据库中获取) * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("imitateHotspotInvlid") public UserBank imitateHotspotInvlid(Integer id) { return hotspotInvalidService.imitateHotspotInvlid(id); } /*** * @description 3、模拟缓存击穿-删除缓存id为88的数据 * @return void * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("delete88IdData") public void delete88IdData() { hotspotInvalidService.delete88IdData(); } /*** * @description 解决方案一：采用互斥锁 * @param id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/9 16:50:24 */ @GetMapping("lock") public UserBank lock(Integer id) { return hotspotInvalidService.lock(id); } /*** * @description 解决方案二：异步定时任务 * @return void * @author wangzhan * @date 2024/7/9 16:50:24 */ @GetMapping("cornJob") public UserBank cornJob(Integer id) { return hotspotInvalidService.cornJob(id); } } 
 

缓存雪崩
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.controller; import com.wangzhan.domain.UserBank; import com.wangzhan.service.CacheAvalancheService; import org.springframework.web.bind.annotation.GetMapping; import org.springframework.web.bind.annotation.RequestMapping; import org.springframework.web.bind.annotation.RestController; import javax.annotation.Resource; /** * @author wangzhan * @version 1.0 * @description 缓存雪崩 * @date 2024/7/6 11:08:19 */ @RestController @RequestMapping("/cacheAvalanche") public class CacheAvalancheController { @Resource private CacheAvalancheService cacheAvalancheService; /*** * @description 1、模拟缓存击穿-初始化缓存 * @return void * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("initCache") public void initCache() { cacheAvalancheService.initCache(); } /*** * @description 2、模拟缓存雪崩(数据从缓存中获取) 4、模拟缓存雪崩(数据从数据库中获取) * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("imitateCacheAvalanche") public UserBank imitateCacheAvalanche(Integer id) { return cacheAvalancheService.imitateCacheAvalanche(id); } /*** * @description 3、模拟缓存雪崩-删除30-40的数据 * @return void * @author wangzhan * @date 2024/7/3 20:33:11 */ @GetMapping("delete30_40IdData") public void delete30_40IdData() { cacheAvalancheService.delete30_40IdData(); } /*** * @description 解决方案一：采用互斥锁 * @param id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/10 22:28:42 */ @GetMapping("lock") public UserBank lock(Integer id) { return cacheAvalancheService.lock(id); } /*** * @description 解决方案二：异步定时任务 * @param id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/10 22:29:04 */ @GetMapping("cornJob") public UserBank cornJob(Integer id) { return cacheAvalancheService.cornJob(id); } /*** * @description 解决方案三：随机过期时间 * @return int * @author wangzhan * @date 2024/7/10 22:29:04 */ @GetMapping("randomExpire") public UserBank randomExpireTime(Integer id) { return cacheAvalancheService.randomExpireTime(id); } } 
 

5.5、service
 

缓存穿透
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.service; import com.wangzhan.domain.UserBank; /** * @author wangzhan * @version 1.0 * @description * @date 2024/7/7 10:35:45 */ public interface CachePenetrationService { /*** * @description 初始化缓存 * @return void * @author wangzhan * @date 2024/7/3 17:01:01 */ void initCache(); /*** * @description 模拟缓存穿透 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 16:59:45 */ UserBank imitateCachePenetration(Integer id); /*** * @description 解决方案一：缓存空对象 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 16:59:45 */ Object cacheNullKey(Integer id); /*** * @description 解决方案二：布隆过滤器 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 16:59:45 */ Object bloomFilter(Integer id); } 
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.service.impl; import com.alibaba.fastjson.JSON; import com.google.common.hash.BloomFilter; import com.google.common.hash.Funnels; import com.wangzhan.domain.UserBank; import com.wangzhan.mapper.UserBankMapper; import com.wangzhan.service.CachePenetrationService; import com.wangzhan.util.UserBankUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Service; import javax.annotation.PostConstruct; import javax.annotation.Resource; import java.util.List; import java.util.concurrent.TimeUnit; /** * @author wangzhan * @version 1.0 * @description * @date 2024/7/7 10:35:55 */ @Service public class CachePenetrationServiceImpl implements CachePenetrationService { private static final Logger logger = LoggerFactory.getLogger(UserBankServiceImpl.class); private static final String IMITATE_KEY = "user_bank_key:wangzhan:cachePenetration:imitate"; // 缓存key private static final String SOLVE1_IMITATE_KEY = "user_bank_key:wangzhan:cachePenetration:solve1"; // 解决方案的缓存key private static final String SOLVE2_IMITATE_KEY = "user_bank_key:wangzhan:cachePenetration:solve2"; // 解决方案的缓存key public static final int _1W = 10000; //布隆过滤器里预计要插入多少数据 public static int size = _1W; //误判率,它越小误判的个数也就越少(思考，是不是可以设置的无限小，没有误判岂不更好) public static double fpp = 0.03; // 构建布隆过滤器 private static BloomFilter<Integer> bloomFilter = BloomFilter.create(Funnels.integerFunnel(), size, fpp); @Resource private UserBankMapper userBankMapper; @Resource private UserBankUtil userBankUtil; private StringRedisTemplate stringRedisTemplate; public CachePenetrationServiceImpl(StringRedisTemplate stringRedisTemplate) { this.stringRedisTemplate = stringRedisTemplate; } /*--------------------------------缓存穿透模拟-----------------------start----------------------------*/ @Override public UserBank imitateCachePenetration(Integer id) { return userBankUtil.queryUserBankOfHash(id, IMITATE_KEY, 1, TimeUnit.HOURS); } /*--------------------------------缓存穿透模拟-----------------------end----------------------------*/ /*--------------------------------缓存穿透解决方案-----------------------start----------------------------*/ @Override public Object cacheNullKey(Integer id) { String idStr = String.valueOf(id); UserBank userBank = userBankUtil.queryUserBankOfHash(id, SOLVE1_IMITATE_KEY, 1, TimeUnit.HOURS); if (userBank != null) { return userBank; } // 缓存和数据库都不存在 userBank = new UserBank(); userBank.setId(id); userBank.setUserName("当前用户不存在"); userBank.setAmount(0); stringRedisTemplate.opsForHash().put(SOLVE1_IMITATE_KEY, idStr, JSON.toJSONString(userBank)); stringRedisTemplate.expire(SOLVE1_IMITATE_KEY, 1, TimeUnit.HOURS); logger.info("缓存和数据库都不存在"); return userBank; } @PostConstruct @Override public void initCache() { new Thread(() -> { // 查询所有数据进行缓存 List<UserBank> userBanks = userBankMapper.list(); userBanks.forEach(userBank -> { // 初始化时，先添加到布隆过滤器 bloomFilter.put(userBank.getId()); }); // 通过手动删除缓存（delete30And40IdData），模拟缓存失效 //stringRedisTemplate.expire("imitateHotspotInvlid", 1, TimeUnit.SECONDS); }).start(); } @Override public Object bloomFilter(Integer id) { if (bloomFilter.mightContain(id)) { // 可能包含 return userBankUtil.queryUserBankOfHash(id, SOLVE2_IMITATE_KEY, 1, TimeUnit.HOURS); } logger.info("布隆过滤器中一定不存在该数据，id为：{}", id); return null; } /*--------------------------------缓存穿透解决方案-----------------------end----------------------------*/ } 
 

缓存击穿
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.service; import com.wangzhan.domain.UserBank; /** * @author wangzhan * @version 1.0 * @description * @date 2024/7/7 10:36:28 */ public interface HotspotInvalidService { /*** * @description 模拟缓存击穿 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 16:59:45 */ UserBank imitateHotspotInvlid(Integer id); /*** * @description 删除缓存为30~40的数据 * * @return void * @author wangzhan * @date 2024/7/4 08:51:08 */ void delete88IdData(); /*** * @description 初始化缓存 * @return void * @author wangzhan * @date 2024/7/3 17:01:01 */ void initCache(); /*** * @description 解决方案一：采用互斥锁 * @param id 主键id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/3 16:59:45 */ UserBank lock(Integer id); /*** * @description 解决方案二：异步定时任务 * @return void * @author wangzhan * @date 2024/7/3 17:01:01 */ UserBank cornJob(Integer id); } 
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.service.impl; import com.alibaba.fastjson.JSON; import com.wangzhan.domain.UserBank; import com.wangzhan.mapper.UserBankMapper; import com.wangzhan.service.HotspotInvalidService; import com.wangzhan.task.HotspotInvlidTask; import com.wangzhan.util.UserBankUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.scheduling.annotation.Async; import org.springframework.stereotype.Service; import javax.annotation.PostConstruct; import javax.annotation.Resource; import java.util.List; import java.util.concurrent.Executors; import java.util.concurrent.ScheduledExecutorService; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author wangzhan * @version 1.0 * @description * @date 2024/7/7 10:36:40 */ @Service public class HotspotInvalidServiceImpl implements HotspotInvalidService { private static final Logger logger = LoggerFactory.getLogger(UserBankServiceImpl.class); private static final String IMITATE_KEY = "user_bank_key:wangzhan:hotspotInvalid:"; private static final String SOLVE1_IMITATE_KEY = "user_bank_key:wangzhan:hotspotInvalid:solve1:"; private static final String SOLVE2_IMITATE_KEY = "user_bank_key:wangzhan:hotspotInvalid:solve2:"; // 可重入锁 private static final Lock lock = new ReentrantLock(); @Resource private UserBankMapper userBankMapper; @Resource private UserBankUtil userBankUtil; @Resource private HotspotInvlidTask hotspotInvlidTask; private StringRedisTemplate stringRedisTemplate; public HotspotInvalidServiceImpl(StringRedisTemplate stringRedisTemplate) { this.stringRedisTemplate = stringRedisTemplate; } /*--------------------------------缓存击穿模拟-----------------------start----------------------------*/ @Override public void initCache() { new Thread(() -> { // 查询所有数据进行缓存 List<UserBank> userBanks = userBankMapper.list(); userBanks.forEach(userBank -> { stringRedisTemplate.opsForValue().set(IMITATE_KEY + userBank.getId(), JSON.toJSONString(userBank)); stringRedisTemplate.expire(IMITATE_KEY + userBank.getId(), 1, TimeUnit.HOURS); }); // 通过手动删除缓存（delete30And40IdData），模拟缓存失效 //stringRedisTemplate.expire("imitateHotspotInvlid", 1, TimeUnit.SECONDS); }).start(); } @Override public UserBank imitateHotspotInvlid(Integer id) { return userBankUtil.queryUserBankOfStr(id, IMITATE_KEY + id, 1, TimeUnit.MINUTES); } @Override public void delete88IdData() { // 模拟id为88 缓存失效的情况 stringRedisTemplate.delete(IMITATE_KEY + 88); } /*--------------------------------缓存击穿模拟-----------------------end----------------------------*/ /*--------------------------------缓存击穿解决方案-----------------------start----------------------------*/ @Override public UserBank lock(Integer id) { String userBankJson = stringRedisTemplate.opsForValue().get(SOLVE1_IMITATE_KEY + id); UserBank userBank = JSON.parseObject(userBankJson, UserBank.class); if (userBank != null) { logger.info("从【缓存】中获取数据，id为：{}，结果为：{}", id, userBank); return userBank; } try { lock.lock(); return userBankUtil.queryUserBankOfStr(id, SOLVE1_IMITATE_KEY + id, 1, TimeUnit.HOURS); } catch (Exception e) { e.printStackTrace(); }finally { // 释放锁 lock.unlock(); } return userBank; } // 初始化88的缓存，同时启动定时任务 @PostConstruct public void init88IdData() { hotspotInvlidTask.enableScheduledUpdate(); } @Override public UserBank cornJob(Integer id) { return userBankUtil.queryUserBankOfStr(id, SOLVE2_IMITATE_KEY + id, 1, TimeUnit.MINUTES); } /*--------------------------------缓存击穿解决方案-----------------------end----------------------------*/ } 
 

缓存雪崩
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.service; import com.wangzhan.domain.UserBank; /** * @author wangzhan * @version 1.0 * @description * @date 2024/7/7 10:34:44 */ public interface CacheAvalancheService { /*** * @description 初始化缓存 * @return void * @author wangzhan * @date 2024/7/3 17:01:01 */ void initCache(); /**** * @description 2、模拟缓存雪崩(数据从缓存中获取) 4、模拟缓存雪崩(数据从数据库中获取) * @param id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/6 11:02:38 */ UserBank imitateCacheAvalanche(Integer id); /*** * @description 3、模拟缓存雪崩-删除30-40的数据 * @return void * @author wangzhan * @date 2024/7/3 17:01:01 */ void delete30_40IdData(); /*** * @description 解决方案一：采用互斥锁 * @return void * @author wangzhan * @date 2024/7/3 17:01:01 */ UserBank lock(Integer id); /*** * @description 解决方案二：异步定时任务 * @param id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/6 11:02:38 */ UserBank cornJob(Integer id); /*** * @description 解决方案三：随机过期时间 * @param id * @return com.wangzhan.domain.UserBank * @author wangzhan * @date 2024/7/11 09:39:47 */ UserBank randomExpireTime(Integer id); } 
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.service.impl; import com.alibaba.fastjson.JSON; import com.wangzhan.domain.UserBank; import com.wangzhan.mapper.UserBankMapper; import com.wangzhan.service.CacheAvalancheService; import com.wangzhan.task.CacheAvalancheTask; import com.wangzhan.util.UserBankUtil; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Service; import javax.annotation.PostConstruct; import javax.annotation.Resource; import java.util.List; import java.util.concurrent.ThreadLocalRandom; import java.util.concurrent.TimeUnit; import java.util.concurrent.locks.Lock; import java.util.concurrent.locks.ReentrantLock; /** * @author wangzhan * @version 1.0 * @description * @date 2024/7/7 10:34:57 */ @Service public class CacheAvalancheServiceImpl implements CacheAvalancheService { private static final Logger logger = LoggerFactory.getLogger(UserBankServiceImpl.class); private static final String IMITATE_KEY = "user_bank_key:wangzhan:cacheAvalanche:imitate:"; // 解决方案1的key - 互斥锁 private static final String SOLVE1_IMITATE_KEY = "user_bank_key:wangzhan:cacheAvalanche:solve1:"; // 解决方案2的key - 异步定时更新缓存 private static final String SOLVE2_IMITATE_KEY = "user_bank_key:wangzhan:cacheAvalanche:solve2:"; // 解决方案3的key - 随机缓存失效时间 private static final String SOLVE3_IMITATE_KEY = "user_bank_key:wangzhan:cacheAvalanche:solve3:"; // 可重入锁 private static final Lock lock = new ReentrantLock(); @Resource private UserBankMapper userBankMapper; @Resource private UserBankUtil userBankUtil; @Resource private CacheAvalancheTask cacheAvalancheTask; private StringRedisTemplate stringRedisTemplate; public CacheAvalancheServiceImpl(StringRedisTemplate stringRedisTemplate) { this.stringRedisTemplate = stringRedisTemplate; } /*--------------------------------缓存雪崩模拟-----------------------start----------------------------*/ @Override public void initCache() { new Thread(() -> { // 查询所有数据进行缓存 List<UserBank> userBanks = userBankMapper.list(); userBanks.forEach(userBank -> { stringRedisTemplate.opsForValue().set(IMITATE_KEY + userBank.getId(), JSON.toJSONString(userBank)); stringRedisTemplate.expire(IMITATE_KEY + userBank.getId(), 1, TimeUnit.HOURS); }); // 通过手动删除缓存（delete30And40IdData），模拟缓存失效 //stringRedisTemplate.expire("imitateHotspotInvlid", 1, TimeUnit.SECONDS); }).start(); } @Override public UserBank imitateCacheAvalanche(Integer id) { return userBankUtil.queryUserBankOfStr(id, IMITATE_KEY + id, 1, TimeUnit.HOURS); } @Override public void delete30_40IdData() { for (int i = 30; i < 40; i++) { stringRedisTemplate.delete(IMITATE_KEY + i); } } /*--------------------------------缓存雪崩模拟-----------------------end----------------------------*/ /*--------------------------------缓存雪崩解决方案-----------------------start----------------------------*/ @Override public UserBank lock(Integer id) { String userBankJson = stringRedisTemplate.opsForValue().get(SOLVE1_IMITATE_KEY + id); UserBank userBank = JSON.parseObject(userBankJson, UserBank.class); if (userBank != null) { logger.info("从【缓存】中获取数据，id为：{}，结果为：{}", id, userBank); return userBank; } try { lock.lock(); // 再次检查数据，确保在获取锁期间没有其他线程更新缓存 userBankUtil.queryUserBankOfStr(id, SOLVE1_IMITATE_KEY + id, 1, TimeUnit.HOURS); } catch (Exception e) { e.printStackTrace(); } finally { lock.unlock(); } return userBank; } // 初始化所有数据的缓存，同时启动定时任务 @PostConstruct public void initData() { cacheAvalancheTask.enableScheduledUpdate(); } @Override public UserBank cornJob(Integer id) { return userBankUtil.queryUserBankOfStr(id, SOLVE2_IMITATE_KEY + id, 1, TimeUnit.MINUTES); } // TODO 这里只是展示 随机过期时间的方案，并不保证线程安全。 @Override public UserBank randomExpireTime(Integer id) { return userBankUtil.queryUserBankOfStr(id, SOLVE3_IMITATE_KEY + id, randomExpireTime(), TimeUnit.SECONDS); } // 随机生成过期时间 public int randomExpireTime() { // 基本时间为60秒 int baseExpireTime = 60; // 随机偏移量范围 int offsetRange = 40; // 生成随机偏移量 int randomOffset = ThreadLocalRandom.current().nextInt(-offsetRange, offsetRange + 1); // 返回最终的过期时间 return baseExpireTime + randomOffset; } /*--------------------------------缓存雪崩解决方案-----------------------end----------------------------*/ } 
 

5.6、mapper
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.mapper; import com.wangzhan.domain.UserBank; import org.apache.ibatis.annotations.Mapper; import org.springframework.stereotype.Repository; import java.util.List; /** * @description user_bank * @author wangzhan * @date 2024-04-22 */ @Mapper //@Repository public interface UserBankMapper { List<UserBank> list(); /** * 新增 * @author wangzhan * @date 2024/04/22 **/ int insert(UserBank userBank); /** * 刪除 * @author wangzhan * @date 2024/04/22 **/ int delete(int id); /** * 更新 * @author wangzhan * @date 2024/04/22 **/ int update(UserBank userBank); /** * 查询 根据主键 id 查询 * @author wangzhan * @date 2024/04/22 **/ UserBank load(int id); /** * 查询 分页查询 * @author wangzhan * @date 2024/04/22 **/ List<UserBank> pageList(int offset, int pagesize); /** * 查询 分页查询 count * @author wangzhan * @date 2024/04/22 **/ int pageListCount(int offset,int pagesize); } 
 

 

xml
 

代码解读
 

复制代码
 

<?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"> <mapper namespace="com.wangzhan.mapper.UserBankMapper"> <resultMap id="BaseResultMap" type="com.wangzhan.domain.UserBank" > <id column="id" property="id" /> <result column="user_id" property="userId" /> <result column="user_name" property="userName" /> <result column="amount" property="amount" /> </resultMap> <sql id="Base_Column_List"> id , user_id, user_name, amount </sql> <insert id="insert" useGeneratedKeys="true" keyColumn="id" keyProperty="id" parameterType="com.wangzhan.domain.UserBank"> INSERT INTO user_bank <trim prefix="(" suffix=")" suffixOverrides=","> <if test="null != userId and '' != userId"> user_id, </if> <if test="null != userName and '' != userName"> user_name, </if> <if test="null != amount and '' != amount"> amount </if> </trim> <trim prefix="values (" suffix=")" suffixOverrides=","> <if test="null != userId and '' != userId"> #{userId}, </if> <if test="null != userName and '' != userName"> #{userName}, </if> <if test="null != amount and '' != amount"> #{amount} </if> </trim> </insert> <delete id="delete" > DELETE FROM user_bank WHERE id = #{id} </delete> <update id="update" parameterType="com.wangzhan.domain.UserBank"> UPDATE user_bank <set> <if test="null != userId and '' != userId">user_id = #{userId},</if> <if test="null != userName and '' != userName">user_name = #{userName},</if> <if test="null != amount and '' != amount">amount = #{amount}</if> </set> WHERE id = #{id} </update> <select id="load" resultMap="BaseResultMap"> SELECT <include refid="Base_Column_List" /> FROM user_bank WHERE id = #{id} </select> <select id="pageList" resultMap="BaseResultMap"> SELECT <include refid="Base_Column_List" /> FROM user_bank LIMIT #{offset}, #{pageSize} </select> <select id="pageListCount" resultType="java.lang.Integer"> SELECT count(1) FROM user_bank </select> <select id="list" resultType="com.wangzhan.domain.UserBank" resultMap="BaseResultMap"> SELECT <include refid="Base_Column_List" /> FROM user_bank </select> </mapper> 
 

5.7、异步定时任务
 

缓存击穿定时任务
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.task; import com.alibaba.fastjson.JSON; import com.wangzhan.domain.UserBank; import com.wangzhan.mapper.UserBankMapper; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.time.LocalDateTime; import java.util.concurrent.TimeUnit; /** * @author wangzhan * @version 1.0 * @description 异步定时更新缓存 * @date 2024/7/10 08:53:18 */ @Component @EnableScheduling public class HotspotInvlidTask { @Resource private UserBankMapper userBankMapper; private StringRedisTemplate stringRedisTemplate; public HotspotInvlidTask(StringRedisTemplate stringRedisTemplate) { this.stringRedisTemplate = stringRedisTemplate; } private volatile boolean enableScheduledUpdate = false; private static final String SOLVE2_IMITATE_KEY = "user_bank_key:wangzhan:hotspotInvalid:solve2:"; /*** * @description 间隔55秒更新缓存 * * @return void * @author wangzhan * @date 2024/7/10 11:12:51 */ @Scheduled(fixedDelay = 55, timeUnit = TimeUnit.SECONDS) public void scheduledUpdate() { if (!enableScheduledUpdate) { return; } updateDataAsync(); } /** * 开启定时更新缓存 */ public void enableScheduledUpdate() { enableScheduledUpdate = true; scheduledUpdate(); } /** * 异步更新缓存 */ public void updateDataAsync() { UserBank userBank = userBankMapper.load(88); stringRedisTemplate.opsForValue().set(SOLVE2_IMITATE_KEY + 88, JSON.toJSONString(userBank), 1, TimeUnit.MINUTES); } } 
 

缓存雪崩定时任务
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.task; import com.alibaba.fastjson.JSON; import com.wangzhan.domain.UserBank; import com.wangzhan.mapper.UserBankMapper; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.scheduling.annotation.EnableScheduling; import org.springframework.scheduling.annotation.Scheduled; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.util.List; import java.util.concurrent.TimeUnit; /** * @author wangzhan * @version 1.0 * @description 异步定时更新缓存 * @date 2024/7/10 08:53:18 */ @Component @EnableScheduling public class CacheAvalancheTask { @Resource private UserBankMapper userBankMapper; private StringRedisTemplate stringRedisTemplate; public CacheAvalancheTask(StringRedisTemplate stringRedisTemplate) { this.stringRedisTemplate = stringRedisTemplate; } private volatile boolean enableScheduledUpdate = false; private static final String SOLVE2_IMITATE_KEY = "user_bank_key:wangzhan:cacheAvalanche:solve2:"; /*** * @description 间隔55秒更新缓存 * * @return void * @author wangzhan * @date 2024/7/10 11:12:51 */ @Scheduled(fixedDelay = 55, timeUnit = TimeUnit.SECONDS) public void scheduledUpdate() { if (!enableScheduledUpdate) { return; } updateDataAsync(); } /** * 开启定时更新缓存 */ public void enableScheduledUpdate() { enableScheduledUpdate = true; scheduledUpdate(); } /** * 异步更新缓存 */ public void updateDataAsync() { List<UserBank> list = userBankMapper.list(); if (list.isEmpty()) { return; } list.forEach(userBank -> { stringRedisTemplate.opsForValue().set(SOLVE2_IMITATE_KEY + userBank.getId(), JSON.toJSONString(userBank), 1, TimeUnit.MINUTES); }); } } 
 

5.8、公共方法
 

 

java
 

代码解读
 

复制代码
 

package com.wangzhan.util; import com.alibaba.fastjson.JSON; import com.wangzhan.domain.UserBank; import com.wangzhan.mapper.UserBankMapper; import org.slf4j.Logger; import org.slf4j.LoggerFactory; import org.springframework.data.redis.core.StringRedisTemplate; import org.springframework.stereotype.Component; import javax.annotation.Resource; import java.util.concurrent.TimeUnit; /** * @author wangzhan * @version 1.0 * @description * @date 2024/7/11 16:54:36 */ @Component public class UserBankUtil { private static final Logger logger = LoggerFactory.getLogger(UserBankUtil.class); @Resource private UserBankMapper userBankMapper; private StringRedisTemplate stringRedisTemplate; public UserBankUtil(StringRedisTemplate stringRedisTemplate) { this.stringRedisTemplate = stringRedisTemplate; } /** * @param id 主键id * @param key 缓存key * @param timeout 过期时间 * @param timeUnit 时间单位 * @description: 查询缓存，如果缓存不存在，则查询数据库，并将数据缓存 * @return: com.wangzhan.domain.UserBank * @author: wangzhan * @date: 2024/7/7 11:04:04 */ public UserBank queryUserBankOfStr(Integer id, String key, int timeout, TimeUnit timeUnit) { String userBankJson = stringRedisTemplate.opsForValue().get(key); UserBank userBank = JSON.parseObject(userBankJson, UserBank.class); if (userBank == null) { userBank = userBankMapper.load(id); if (userBank != null) { logger.info("==========设置数据到缓存======="); // 设置缓存 stringRedisTemplate.opsForValue().set(key, JSON.toJSONString(userBank), timeout, timeUnit); } logger.info("从【数据库】中获取数据，id为：{}，结果为：{}", id, userBank); return userBank; } logger.info("从【缓存】中获取数据，id为：{}，结果为：{}", id, userBank); return userBank; } /** * @param id 主键id * @param key 缓存key * @param timeout 过期时间 * @param timeUnit 时间单位 * @description: 查询缓存，如果缓存不存在，则查询数据库，并将数据缓存 * @return: com.wangzhan.domain.UserBank * @author: wangzhan * @date: 2024/7/7 11:04:04 */ public UserBank queryUserBankOfHash(Integer id, String key, int timeout, TimeUnit timeUnit) { String idStr = String.valueOf(id); String userBankJson = (String) stringRedisTemplate.opsForHash().get(key, idStr); UserBank userBank = JSON.parseObject(userBankJson, UserBank.class); if (userBank == null) { // 查询数据库 userBank = userBankMapper.load(id); if (userBank != null) { logger.info("==========设置数据到缓存======="); stringRedisTemplate.opsForHash().put(key, idStr, JSON.toJSONString(userBank)); stringRedisTemplate.expire(key, timeout, timeUnit); } logger.info("从【数据库】中获取数据，id为：{}，结果为：{}", idStr, userBank); return userBank; } logger.info("从【缓存】中获取数据，id为：{}，结果为：{}", idStr, userBank); return userBank; } } 

                

        

        

    




    

      

        

            

              
                
                  程序以一
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    4
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    4
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
Redis缓存老师笔记

				
			

			

				

					08-29
				

			

		

		

			
				
7. Redis缓存穿透、缓存雪崩和缓存击穿问题及解决方案 8. Redis Cluster分布式集群搭建和管理 9. Redis在实际项目中的应用案例分析  通过学习这些笔记，你可以深入理解Redis的工作原理，提高使用Redis解决问题的能力...

			
		

	



                

              
                



	

		

			

				
					
Redis要点和难点实际应用方向和具体案例代码&代码解析

				
			

			

				

					05-05
				

			

		

		

			
				
 缓存穿透、缓存击穿和缓存雪崩是使用Redis作为缓存时常见的问题。为防止这些情况，可以采用布隆过滤器避免穿透，热点键限流防止击穿，以及设置合理的过期时间和随机过期策略来缓解雪崩。  6. 案例分析  - 用户计数...

			
		

	



                


  
              

                


	

		

			

				
					
数据缓存案例

				
			

			

				

					04-24
				

			

		

		

			
				
常见的解决方法有缓存穿透、缓存雪崩和缓存击穿等问题，以及对应的解决方案，如使用布隆过滤器防止穿透，设置合理的缓存更新策略防止雪崩和击穿。  3. **分布式缓存**：当单个缓存无法满足需求时，可以采用分布式...

			
		

	





	

		

			

				
					
Java系统分布式缓存PPT

				
			

			

				

					04-06
				

			

		

		

			
				
这可能包括但不限于缓存穿透、缓存雪崩、缓存击穿等问题的解决方案，以及如何利用缓存预热、缓存更新策略（如Write-Behind和Write-Through）来提升系统稳定性。此外，还可能涉及缓存的容量管理和数据淘汰策略，例如...

			
		

	



		

			
		



	

		

			

				
					
分布式存储极致性能Redis6视频.zip

				
			

			

				

					07-10
				

			

		

		

			
				
目录网盘文件永久链接 01_大纲简介 ...28_Redis布隆过滤器解决缓存穿透 29_docker安装rebloom 30_缓存击穿简介 31_高并发的淘宝聚划算案例落地 32_分布式锁理论简介 33_分布式锁的起手式案例有问题 .......

			
		

	





	

		

			

				
					
【缓存】缓存击穿、缓存穿透、缓存雪崩

				
			

			

				

					好记性不如烂笔头
				

				

					08-06
					
					191
					
				

			

		

		

			
				
缓存中没找到请求的数据，数据库中也没有请求的数据，那么把这个请求数据保存在缓存里，但是置为空。如果有攻击者伪造了一个请求，而且请求的数据再缓存中找不到，那么每次请求，都会从数据库中查找。一般缓存的数据都有有效期，当某个数据有效期过了，对该数据的所有请求统统走向了数据库，数据库由于突然大量的请求访问可能就会崩掉了，这就是缓存击穿。1）对请求进行校验，比如请求的数据，缓存中肯定没有，并且数据库中也肯定没有的情况，直接拦截过滤掉。3）如果数据量比较小，可以全部放在缓存中，有请求的数据就返回，没有就返回空。

			
		

	





	

		

			

				
					
Babylonjs学习笔记(十四)——通IndexDB缓存模型

				
			

			

				

					localhost
				

				

					08-01
					
					154
					
				

			

		

		

			
				
虽然从浏览器缓存中加载，但是babylonjs仍然需要解析.glb文件并将其转换为内存中的3D模型，这个过程很耗时；使用IndexDB缓存已解析的数据，而不仅仅是.glb文件

			
		

	





	

		

			

				
					
缓存异常：缓存雪崩、击穿、穿透

				
			

			

				

					shenyongsi的博客
				

				

					08-06
					
					332
					
				

			

		

		

			
				
针对某个访问非常频繁的热点数据的请求，无法在缓存中进行处理，紧接着，访问该数据的大量请求，一下子都发送到了后端数据库，导致了数据库压力激增，是发生在某个热点数据失效的场景下，和缓存雪崩相比，缓存击穿失效的数据数量要小很多，应对方法也不一样要访问的数据既不在 Redis 缓存中，也不在数据库中，导致请求在访问缓存时，发生缓存缺失，再去访问数据库时，发现数据库中也没有要访问的数据。

			
		

	





	

		

			

				
					
单体应用提高性能和处理高并发-使用缓存

					
最新发布

				
			

			

				

					Chennyken
				

				

					08-06
					
					680
					
				

			

		

		

			
				
通过使用内存缓存（如Ehcache、Caffeine）和分布式缓存（如Redis、Memcached），可以显著提高单体应用的性能，处理高并发请求。合理选择缓存工具、应用适当的缓存策略、处理常见缓存问题，可以有效优化系统的响应时间和负载能力。

			
		

	





	

		

			

				
					
LeetCode Medium｜【146. LRU 缓存】

				
			

			

				

					糖炒栗子
				

				

					08-03
					
					730
					
				

			

		

		

			
				
题意：本题的题意就是希望我们设计一个满足 LRU 缓存的数据结构，LRU即最近最少使用。需要我们实现 get 和 put 方法，即从缓存中获取值和设置缓存中值的方法。还有一个约束条件就是缓存应当有容量限制，如果实现 put 方法的时候，没有空闲的空间的话，需要淘汰一个最久没有使用的 key同时要求 get 和 put 的时间复杂度是O(1)

			
		

	





	

		

			

				
					
Spring为啥用三级缓存而不用两级缓存

				
			

			

				

					modelsetget的博客
				

				

					08-02
					
					736
					
				

			

		

		

			
				
概括了Spring三级缓存机制的核心要点，包括其目的、结构、工作原理以及如何解决循环依赖问题。

			
		

	





	

		

			

				
					
学习vue3 五，传送，缓存组件以及过渡和过渡列表

				
			

			

				

					tian_liang_jia的博客
				

				

					08-06
					
					609
					
				

			

		

		

			
				
在这些props后接要自定义的名字即可换成自己想要的，相当于起别名也可以指定过渡时间可以分别指定，离开和进入的时间自定义class只要是可以和css的动画库进行连用案例：我们以animate.css为例安装：npm install animate.css -S引入：在main.ts中 import "animate.css"

			
		

	





	

		

			

				
					
缓存面试解析：穿透、击穿、雪崩，一致性、分布式锁、Redis过期，海量数据查找

				
			

			

				

					努力的小雨，一个阳光向上的博客不仅仅给你知识更希望带给你快乐
				

				

					08-06
					
					533
					
				

			

		

		

			
				
本文提供了一些保证数据一致性和设计分布式锁的策略。这些策略可以在实际应用中帮助开发人员解决相关的问题，确保系统的数据一致性和并发访问的正确性。同时，通过合理地使用缓存和分布式锁，可以提高系统的性能和可靠性。希望对你在面对Redis相关面试题时有所帮助！我是努力的小雨，一名 Java 服务端码农，潜心研究着 AI 技术的奥秘。我热爱技术交流与分享，对开源社区充满热情。同时也是一位掘金优秀作者、腾讯云内容共创官、阿里云专家博主、华为云云享专家。

			
		

	





	

		

			

				
					
第12节课：本地存储与应用缓存——提升离线体验和性能

				
			

			

				

					学问小小谢的技术博客
				

				

					08-06
					
					699
					
				

			

		

		

			
				
随着Web应用的日益复杂化，用户期望获得更快的加载速度和更好的离线体验。HTML5引入了本地存储和应用缓存功能，以满足这些需求。本节课将详细介绍`localStorage`、`sessionStorage`以及应用缓存（通过manifest文件），探讨它们如何帮助提升Web应用的性能和用户体验。

			
		

	





	

		

			

				
					
Map缓存token

				
			

			

				

					左--右
				

				

					08-06
					
					133
					
				

			

		

		

			
				
单例设计模式AccessTokenSingleton  缓存token。Map缓存Token 记录过期时间。

			
		

	





	

		

			

				
					
【redis】redis持久化学习

				
			

			

				

					zerotoall的博客
				

				

					08-06
					
					631
					
				

			

		

		

			
				
1.持久化模式
1.RDB模式
2.AOF模式
2.RDB模式
可以在指定的时间间隔内生成数据集的时间点快照
1）RDB模式工作方式
1.默认情况下，Redis保存数据集快照到磁盘，名为dump.rdb的二进制文件。你可以设置让Redis在N秒内至少有M次数据集改动时保存数据集，或者你也可以手动调用SAVE或者BGSAVE命令。
​
2.在上文中我们已经在配置文件中做过对应的配置：
例如，这个配置会让Redis在每个60秒内至少有1000次键改动时自动转储数据集到磁盘：
save 60 1000

			
		

	





	

		

			

				
					
Linux安装 Redis

				
			

			

				

					Blooming death的博客
				

				

					08-02
					
					399
					
				

			

		

		

			
				
下载方式为两种：官网、网盘官网：我这里下载了：7.0.5网盘：链接：https://pan.baidu.com/s/1A_-ZL3x3Xa5YNlcDqyuV_A?pwd=g8jh提取码：g8jh解压：将文件上传至。

			
		

	





	

		

			

				
					
Redisson 实现分布式锁

				
			

			

				

					Hello World
				

				

					08-06
					
					382
					
				

			

		

		

			
				
对于大多数的场景而言，使用 Redisson 的普通锁就可以了，如果项目对分布式锁的安全性要求很高，推荐使用基于 Raft 或 Paxos 算法的 etcd 或 ZooKeeper，他们在设计时充分考虑了分布式环境下的一致性和可靠性问题，提供了比 RedLock 更为健壮的解决方案。我们可以将一个长时间执行的任务拆分为多个独立的较短的小任务，每个步骤都有自己独立的分布式锁，这样就可以减少锁定资源的时间，同时确保每个阶段都能在适当的时间内完成。公平锁与 JUC 中的公平锁一致，遵循先到先得的原则。

			
		

	





	

		

			

				
					
Lettuce 客户端连接 Redis

				
			

			

				

					java_liuyuan的博客
				

				

					08-06
					
					157
					
				

			

		

		

			
				
Lettuce 客户端连接 Redis

			
		

	





	

		

			

				
					

				
			

			

				

					
				

			

		

		

			
				

			
		

	



              




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

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

              

            

          

      

      余额充值