day04-商家查询缓存03

功能02-商铺查询缓存03

3.功能02-商铺查询缓存

3.6封装redis工具类

3.6.1需求说明

基于StringRedisTemplate封装一个工具列，满足下列需求：
方法1：将任意Java对象序列化为json，并存储在string类型的key中，并且可以设置TTL过期时间
方法2：将任意Java对象序列化为json，并存储在string类型的key中，并且可以设置逻辑过期时间，用户处理缓存击穿问题（针对热点key）
方法3：根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
方法4：根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题（针对热点key）
3.6.2代码实现

（1）创建redis工具类，封装上述方法

1. package com.hmdp.utils;
3. import cn.hutool.core.util.BooleanUtil;
4. import cn.hutool.core.util.StrUtil;
5. import cn.hutool.json.JSONObject;
6. import cn.hutool.json.JSONUtil;
7. import lombok.extern.slf4j.Slf4j;
8. import org.springframework.data.redis.core.StringRedisTemplate;
9. import org.springframework.stereotype.Component;
11. import javax.annotation.Resource;
12. import java.time.LocalDateTime;
13. import java.util.concurrent.ExecutorService;
14. import java.util.concurrent.Executors;
15. import java.util.concurrent.TimeUnit;
16. import java.util.function.Function;
18. import static com.hmdp.utils.RedisConstants.*;
20. /**
21. * @author 李
22. * @version 1.0
23. * 封装redis工具类
24. */
25. @Component
26. @Slf4j
27. public class CacheClient {
28.     @Resource
29.     private StringRedisTemplate stringRedisTemplate;
31.     /**
32.      * 将任意Java对象序列化为json，并存储在string类型的key中，并且可以设置TTL过期时间
33.      *
34.      * @param key   缓存的key值
35.      * @param value 缓存的value值
36.      * @param time  过期时间值
37.      * @param unit  过期的时间单位
38.      */
39.     public void set(String key, Object value, Long time, TimeUnit unit) {
40.         stringRedisTemplate.opsForValue()
41.                 .set(key, JSONUtil.toJsonStr(value), time, unit);
42.     }
44.     /**
45.      * 将任意Java对象序列化为json，并存储在string类型的key中，
46.      * 并且可以设置逻辑过期时间，用户处理缓存击穿问题（针对热点key）
47.      *
48.      * @param key   缓存的key值
49.      * @param value 缓存的value值
50.      * @param time  过期时间值
51.      * @param unit  过期的时间单位
52.      */
53.     public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
54.         //设置逻辑过期时间
55.         RedisData redisData = new RedisData();
56.         redisData.setData(value);
57.         //逻辑过期时间=当前时间+指定的时间
58.         redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
59.         stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
60.     }
62.     /**
63.      * 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透问题
64.      *
65.      * @param keyPrefix  查询的key值的前缀
66.      * @param id         查询的key值的后缀
67.      * @param type       要转换的Class类型
68.      * @param dbFallback 传入的函数
69.      * @param time       过期时间值
70.      * @param unit       时间单位
71.      * @param <R>        泛型
72.      * @param <ID>       泛型
73.      * @return 返回指定的类型对象
74.      */
75.     public <R, ID> R queryWithPassThrough(
76.             String keyPrefix, ID id, Class<R> type, Function<ID, R> dbFallback, Long time, TimeUnit unit) {
77.         String key = keyPrefix + id;
78.         //redis查询缓存
79.         String json = stringRedisTemplate.opsForValue().get(key);
80.         //判断json是否存在
81.         if (StrUtil.isNotBlank(json)) {
82.             //存在，转为java对象并返回
83.             return JSONUtil.toBean(json, type);
84.         }
85.         //判断是否为""，如果是，说明该key是为了解决缓存穿透设置的空值
86.         if ("".equals(json)) {
87.             //返回错误信息
88.             return null;
89.         }
90.         //不存在，根据id查询数据库——使用函数式编程
91.         R r = dbFallback.apply(id);
92.         if (r == null) {//说明数据库中没有该数据
93.             //缓存空值，应对缓存穿透
94.             stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
95.             //返回错误信息
96.             return null;
97.         }
98.         //r存在，则将其写入redis
99.         this.set(key, r, time, unit);
100.         return r;
101.     }
103.     private static final ExecutorService CACHE_REBUILD_EXECUTOR =
104.             Executors.newFixedThreadPool(10);
106.     /**
107.      * 根据指定的key查询缓存，并反序列化为指定类型，需要利用逻辑过期解决缓存击穿问题（针对热点key）
108.      * @param keyPrefix  查询的key值的前缀
109.      * @param id         查询的key值的后缀
110.      * @param type       要转换的Class类型
111.      * @param dbFallback 传入的函数
112.      * @param time       过期时间值
113.      * @param unit       时间单位
114.      * @param <R>        泛型
115.      * @param <ID>       泛型
116.      * @return 返回指定的类型对象
117.      */
118.     public <R, ID> R queryWithLogicalExpire(String keyPrefix, ID id, Class<R> type,
119.                                             Function<ID, R> dbFallback, Long time,
120.                                             TimeUnit unit) {
121.         String key = keyPrefix + id;
122.         String json = stringRedisTemplate.opsForValue().get(key);
123.         //这里不再考虑缓存穿透问题，因为key永不过期
124.         if (StrUtil.isBlank(json)) {
125.             //如果未命中,说明不是热点key,直接返回null
126.             return null;
127.         }
128.         //如果命中
129.         //先把json反序列化为对象
130.         RedisData redisData = JSONUtil.toBean(json, RedisData.class);
131.         R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
132.         LocalDateTime expireTime = redisData.getExpireTime();
133.         //判断是否逻辑过期
134.         if (expireTime.isAfter(LocalDateTime.now())) {
135.             //未过期，直接返回信息
136.             return r;
137.         }
138.         //过期，获取互斥锁
139.         String lockKey = LOCK_SHOP_KEY + id;
140.         boolean isLock = tryLock(lockKey);
141.         if (isLock) {//成功获取互斥锁
142.             //开启独立线程
143.             CACHE_REBUILD_EXECUTOR.submit(() -> {
144.                 try {
145.                     //重建缓存
146.                     //先查询数据库
147.                     R apply = dbFallback.apply(id);
148.                     //再存入reids缓存
149.                     this.setWithLogicalExpire(key, apply, time, unit);
150.                 } catch (Exception e) {
151.                     throw new RuntimeException(e);
152.                 }
153.                 //释放互斥锁
154.                 unLock(lockKey);
155.             });
156.         }
157.         //如果未获取互斥锁，直接返回旧数据
158.         return r;
159.     }
161.     private boolean tryLock(String key) {
162.         Boolean flag = stringRedisTemplate.opsForValue()
163.                 .setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
164.         return BooleanUtil.isTrue(flag);
165.     }
167.     private void unLock(String key) {
168.         stringRedisTemplate.delete(key);
169.     }
170. }

复制代码

（2）修改ShopServiceImpl，调用封装好的方法，简化代码

1. package com.hmdp.service.impl;
3. import ...
5. /**
6. * 服务实现类
7. *
8. * @author 李
9. * @version 1.0
10. */
11. @Service
12. public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop>
13.         implements IShopService {
14.     @Resource
15.     StringRedisTemplate stringRedisTemplate;
17.     @Resource
18.     private CacheClient cacheClient;
20.     @Override
21.     public Result queryById(Long id) {
22.         //缓存穿透
23.         //Shop shop =
24.         //        cacheClient.queryWithPassThrough
25.         //                (CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
27.         //缓存击穿方案（逻辑过期）
28.         Shop shop = cacheClient.queryWithLogicalExpire
29.                 (CACHE_SHOP_KEY, id, Shop.class, this::getById, 20L, TimeUnit.MINUTES);
31.         if (shop == null) {
32.             return Result.fail("店铺不存在！");
33.         }
34.         return Result.ok(shop);
35.     }
37.     @Override
38.     @Transactional
39.     public Result update(Shop shop) {
40.         ...
41.     }
42. }

复制代码

3.7缓存总结


免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！