• Redis的缓存问题（四）将redis常用操作封装成工具类

    Redis的缓存问题（四）将redis常用操作封装成工具类

    Redis工具类功能设计

    Redis工具类中代码分析

    queryWithPassThrough()    缓存穿透分析

    （1）泛型 

    （2）Function 函数接口

    Redis工具类完整代码实现

    Redis缓存问题小结 

    Redis的缓存问题（四）将redis常用操作封装成工具类

    Redis工具类功能设计

    1. 将任意的Java对象序列化为json并储存在string类型的key中，并且可以设置TTL过期时间。

    2. 将任意的Java对象序列化为json并储存在string类型的key中，并且可以设置逻辑过期时间，用于缓存击穿。

    3. 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透。

    4. 根据指定的key查询缓存，并反序列化为指定类型，利用逻辑过期解决缓存击穿。

    Redis工具类中代码分析

    本文查看黑马程序员视频，有一说一，这一节黑马的视频质量是真的高！链接如下：

    黑马程序员Redis入门到实战教程，全面透析redis底层原理+redis分布式锁+企业解决方案+redis实战_哔哩哔哩_bilibili

    完整的工具类代码在文末，这里主要是对工具类中的一些细节做一下分析！

    我们先来看一下 缓存穿透 的代码

    queryWithPassThrough()    缓存穿透分析

    1. // 缓存穿透
    2. public  R queryWithPassThrough(
    3.     String keyPrefix, ID id, Class type, 
    4.     Function dbFallback, Long time, TimeUnit unit){
    5.     String key = keyPrefix + id;
    6.     // 1.从redis查询商铺缓存
    7.     String json = stringRedisTemplate.opsForValue().get(key);
    8.     // 2.判断是否存在
    9.     if (StrUtil.isNotBlank(json)) {
    10.         // 3.存在，直接返回
    11.         return JSONUtil.toBean(json, type);
    12.     }
    13.     // 判断命中的是否是空值
    14.     if (json != null) {
    15.         // 返回一个错误信息
    16.         return null;
    17.     }
    18.     // 4.不存在，根据id查询数据库
    19.     R r = dbFallback.apply(id);
    20.     // 5.不存在，返回错误
    21.     if (r == null) {
    22.         // 将空值写入redis
    23.         stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
    24.         // 返回错误信息
    25.         return null;
    26.     }
    27.     // 6.存在，写入redis
    28.     this.set(key, r, time, unit);
    29.     return r;
    30. }

    （1）泛型 

    里面使用了泛型，我们可以先看一下方法返回值泛型的写法，如下图：

    所以在我们在 R里面定义泛型，再在Class type 和 ID id 指明泛型R，ID的具体类型（泛型的推断）

    调用queryWithPassThrough() 

    （2）Function 函数接口

    关于这个内容可以参考一下这里：Java 8 Function 函数接口 | 未读代码 (wdbyte.com)

    因为我们实现的是Redis工具类，代码要有一定的复用性，原逻辑是“获取店铺ID”，但是下次可能就会用在“获取店铺类型”。

    1. // Shop shop = getById(id);
    2. R r = dbFallback.apply(id);

    Function dbFallback：表示参数是ID，返回值是R类型

    在 Java 8 中，Function 接口是一个函数接口，它位于包 java.util.function 下。 Function 接口中定义了一个 R apply(T t) 方法，它可以接受一个泛型 T 对象，返回一个泛型 R 对象，即参数类型和返回类型可以不同。

    所以说，在这里我们用 dbFallback 调用 apply() 方法，相当于是执行外部传进来的方法（下图）

    这里的 this::getById 等同于 id2 -> getById(id2)

    Java里面this后面跟着两个“冒号”的意思是：

    英文：double colon，双冒号（::）运算符在Java 8中被用作方法引用（method reference），方法引用是与lambda表达式相关的一个重要特性。它提供了一种不执行方法的方法。将方法作为参数传入stream中，使stream中每个元素都能进入方法中运行

    格式：类名::方法名

    user -> user.getAge()    等价于   User::getAge

    new HashMap<>()   等价于   HsahMap::new

    Redis工具类完整代码实现

    我们在工具类中还是会使用到RedisData这个类。

    RedisData 类

    1. @Data
    2. public class RedisData {
    3.     // LocalDateTime ： 同时含有年月日时分秒的日期对象
    4.     // 并且LocalDateTime是线程安全的！
    5.     private LocalDateTime expireTime;
    6.     private Object data;
    7. }

    里面的属性expireTime（过期时间）使用了Java8新定义的时间类 LocalDateTime ，是线程安全的。 

    CacheClient 工具类

    1. package com.hmdp.utils;
    2.  
    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;
    10.  
    11. import java.time.LocalDateTime;
    12. import java.util.concurrent.ExecutorService;
    13. import java.util.concurrent.Executors;
    14. import java.util.concurrent.TimeUnit;
    15. import java.util.function.Function;
    16.  
    17. import static com.hmdp.utils.RedisConstants.CACHE_NULL_TTL;
    18. import static com.hmdp.utils.RedisConstants.LOCK_SHOP_KEY;
    19.  
    20. /**
    21.  * 1. 将任意的Java对象序列化为json并储存在string类型的key中，并且可以设置TTL过期时间。
    22.  * 2. 将任意的Java对象序列化为json并储存在string类型的key中，并且可以设置逻辑过期时间，用于缓存击穿。
    23.  * 3. 根据指定的key查询缓存，并反序列化为指定类型，利用缓存空值的方式解决缓存穿透。
    24.  * 4. 根据指定的key查询缓存，并反序列化为指定类型，利用逻辑过期解决缓存击穿。
    25.  */
    26.  
    27. @Slf4j
    28. @Component
    29. public class CacheClient {
    30.     private final StringRedisTemplate stringRedisTemplate;
    31.  
    32.     // stringRedisTemplate 构造函数注入 ！
    33.     public CacheClient(StringRedisTemplate stringRedisTemplate) {
    34.         this.stringRedisTemplate = stringRedisTemplate;
    35.     }
    36.  
    37.     // 存入redis的ket-value，并设计过期时间
    38.     public void set(String key, Object value, Long time, TimeUnit unit) {
    39.         // stringRedisTemplate要求是string类型，value直接拿下来是一个object
    40.         // 使用 JSONUtil将 object 序列化为 string
    41.         stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value), time, unit);
    42.     }
    43.  
    44.     // 逻辑过期
    45.     public void setWithLogicalExpire(String key, Object value, Long time, TimeUnit unit) {
    46.         // 设置逻辑过期
    47.         RedisData redisData = new RedisData();
    48.         redisData.setData(value);
    49.         // LocalDateTime.now() 获取当前时间
    50.         // plusSeconds 添加秒数
    51.         // 使用TimeUnit包的 toSeconds将时间转换为秒数
    52.         redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
    53.         // 写入Redis
    54.         stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    55.     }
    56.  
    57.     // 缓存穿透
    58.     public  R queryWithPassThrough(
    59.             String keyPrefix, ID id, Class type, Function dbFallback, Long time, TimeUnit unit){
    60.         // Java 8 定义了 Function 接口，apply()可以接受一个泛型 T 对象，返回一个泛型 R 对象
    61.         // keyPrefix Key的前缀
    62.         String key = keyPrefix + id;
    63.         // 1.从redis查询商铺缓存
    64.         String json = stringRedisTemplate.opsForValue().get(key);
    65.         // 2.判断是否存在
    66.         if (StrUtil.isNotBlank(json)) {
    67.             // 3.存在，直接返回
    68.             return JSONUtil.toBean(json, type);
    69.         }
    70.         // 判断命中的是否是空值
    71.         if (json != null) {
    72.             // 返回一个错误信息
    73.             return null;
    74.         }
    75.         // 4.不存在，根据id查询数据库
    76.         // Shop shop = getById(id); 但是需要使用到缓存穿透的场景有很多，可能是查shop，可能是user
    77.         // 所以执行的orm是不一样的！
    78.         // Function dbFallback : ID是参数、R是返回值。
    79.         R r = dbFallback.apply(id);
    80.         // 5.不存在，返回错误
    81.         if (r == null) {
    82.             // 将空值写入redis
    83.             stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
    84.             // 返回错误信息
    85.             return null;
    86.         }
    87.         // 6.存在，写入redis
    88.         this.set(key, r, time, unit);
    89.         return r;
    90.     }
    91.  
    92.     // 定义线程池
    93.     private static final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);
    94.     // 逻辑过期
    95.     public  R queryWithLogicalExpire(
    96.             String keyPrefix, ID id, Class type, Function dbFallback, Long time, TimeUnit unit) {
    97.         String key = keyPrefix + id;
    98.         // 1.从redis查询商铺缓存
    99.         String json = stringRedisTemplate.opsForValue().get(key);
    100.         // 2.判断是否存在
    101.         if (StrUtil.isBlank(json)) {
    102.             // 3.存在，直接返回
    103.             return null;
    104.         }
    105.         // 4.命中，需要先把json反序列化为对象
    106.         RedisData redisData = JSONUtil.toBean(json, RedisData.class);
    107.         R r = JSONUtil.toBean((JSONObject) redisData.getData(), type);
    108.         LocalDateTime expireTime = redisData.getExpireTime();
    109.         // 5.判断是否过期
    110.         if(expireTime.isAfter(LocalDateTime.now())) {
    111.             // 5.1.未过期，直接返回店铺信息
    112.             return r;
    113.         }
    114.         // 5.2.已过期，需要缓存重建
    115.         // 6.缓存重建
    116.         // 6.1.获取互斥锁
    117.         String lockKey = LOCK_SHOP_KEY + id;
    118.         boolean isLock = tryLock(lockKey);
    119.         // 6.2.判断是否获取锁成功
    120.         if (isLock){
    121.             // 6.3.成功，开启独立线程，实现缓存重建
    122.             CACHE_REBUILD_EXECUTOR.submit(() -> {
    123.                 try {
    124.                     // 查询数据库
    125.                     R newR = dbFallback.apply(id);
    126.                     // 重建缓存
    127.                     this.setWithLogicalExpire(key, newR, time, unit);
    128.                 } catch (Exception e) {
    129.                     throw new RuntimeException(e);
    130.                 }finally {
    131.                     // 释放锁
    132.                     unlock(lockKey);
    133.                 }
    134.             });
    135.         }
    136.         // 6.4.返回过期的商铺信息
    137.         return r;
    138.     }
    139.  
    140.     public  R queryWithMutex(
    141.             String keyPrefix, ID id, Class type, Function dbFallback, Long time, TimeUnit unit) {
    142.         String key = keyPrefix + id;
    143.         // 1.从redis查询商铺缓存
    144.         String shopJson = stringRedisTemplate.opsForValue().get(key);
    145.         // 2.判断是否存在
    146.         if (StrUtil.isNotBlank(shopJson)) {
    147.             // 3.存在，直接返回
    148.             return JSONUtil.toBean(shopJson, type);
    149.         }
    150.         // 判断命中的是否是空值
    151.         if (shopJson != null) {
    152.             // 返回一个错误信息
    153.             return null;
    154.         }
    155.  
    156.         // 4.实现缓存重建
    157.         // 4.1.获取互斥锁
    158.         String lockKey = LOCK_SHOP_KEY + id;
    159.         R r = null;
    160.         try {
    161.             boolean isLock = tryLock(lockKey);
    162.             // 4.2.判断是否获取成功
    163.             if (!isLock) {
    164.                 // 4.3.获取锁失败，休眠并重试
    165.                 Thread.sleep(50);
    166.                 return queryWithMutex(keyPrefix, id, type, dbFallback, time, unit);
    167.             }
    168.             // 4.4.获取锁成功，根据id查询数据库
    169.             r = dbFallback.apply(id);
    170.             // 5.不存在，返回错误
    171.             if (r == null) {
    172.                 // 将空值写入redis
    173.                 stringRedisTemplate.opsForValue().set(key, "", CACHE_NULL_TTL, TimeUnit.MINUTES);
    174.                 // 返回错误信息
    175.                 return null;
    176.             }
    177.             // 6.存在，写入redis
    178.             this.set(key, r, time, unit);
    179.         } catch (InterruptedException e) {
    180.             throw new RuntimeException(e);
    181.         }finally {
    182.             // 7.释放锁
    183.             unlock(lockKey);
    184.         }
    185.         // 8.返回
    186.         return r;
    187.     }
    188.  
    189.     private boolean tryLock(String key) {
    190.         Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
    191.         return BooleanUtil.isTrue(flag);
    192.     }
    193.  
    194.     private void unlock(String key) {
    195.         stringRedisTemplate.delete(key);
    196.     }
    197. }

    ShopServiceImpl 类

    我们没有使用到Redis工具类的时候，所编写的Service层的代码看起来是十分复杂的！

    现在将主要功能使用CacheClient工具类封装之后，只要寥寥数十行即可！

    1. package com.hmdp.service.impl;
    2.  
    3. import cn.hutool.json.JSONUtil;
    4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    5. import com.hmdp.dto.Result;
    6. import com.hmdp.entity.Shop;
    7. import com.hmdp.mapper.ShopMapper;
    8. import com.hmdp.service.IShopService;
    9. import com.hmdp.utils.CacheClient;
    10. import com.hmdp.utils.RedisData;
    11. import org.springframework.data.redis.core.StringRedisTemplate;
    12. import org.springframework.stereotype.Service;
    13. import org.springframework.transaction.annotation.Transactional;
    14.  
    15. import javax.annotation.Resource;
    16.  
    17. import java.time.LocalDateTime;
    18. import java.util.concurrent.TimeUnit;
    19.  
    20. import static com.hmdp.utils.RedisConstants.*;
    21.  
    22. @Service
    23. public class ShopServiceImpl extends ServiceImpl implements IShopService {
    24.  
    25.     @Resource
    26.     private StringRedisTemplate stringRedisTemplate;
    27.  
    28.     @Resource
    29.     private CacheClient cacheClient;
    30.  
    31.  
    32.     @Override
    33.     public Result queryById(Long id) {
    34.  
    35.         // 缓存穿透
    36.         // Shop shop = cacheClient.queryWithPassThrough(CACHE_SHOP_KEY,id,Shop.class,this::getById,CACHE_SHOP_TTL,TimeUnit.MINUTES);
    37.  
    38.         // 1.互斥锁解决缓存击穿问题
    39.         // 注意！！！
    40.         // 如果使用了逻辑过期由于使用了 RedisData，所以存入的redis的类型发生了改变。
    41.         // Shop shop = cacheClient.queryWithMutex(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
    42.  
    43.         // 2.逻辑过期解决缓存击穿问题
    44.         Shop shop = cacheClient.queryWithLogicalExpire(CACHE_SHOP_KEY, id, Shop.class, this::getById, CACHE_SHOP_TTL, TimeUnit.MINUTES);
    45.  
    46.         if (shop == null) {
    47.             return Result.fail("店铺不存在");
    48.         }
    49.         System.out.println(shop);
    50.         return Result.ok(shop);
    51.     }
    52.  
    53.     /**
    54.      * 重建缓存,先缓存预热一下，否则queryWithLogicalExpire() 的expire为null
    55.      * @param id
    56.      * @param expireSeconds
    57.      */
    58.     public void saveShopRedis(Long id, Long expireSeconds) {
    59.         // 1.查询店铺数据
    60.         Shop shop = getById(id);
    61.         // 2.封装逻辑过期时间
    62.         RedisData redisData = new RedisData();
    63.         redisData.setData(shop);
    64.         redisData.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));  // 过期时间
    65.         // 3.写入redis
    66.         stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY + id, JSONUtil.toJsonStr(redisData));
    67.     }
    68.  
    69.  
    70.     @Override
    71.     @Transactional
    72.     public Result update(Shop shop) {
    73.         System.out.println("up");
    74.         Long id = shop.getId();
    75.         if (id == null) {
    76.             return Result.fail("店铺id不能为空！");
    77.         }
    78.         // 1.更新数据库
    79.         updateById(shop);
    80.  
    81.         // 2.删除缓存
    82.         stringRedisTemplate.delete(CACHE_SHOP_KEY + id);
    83.  
    84.         return Result.ok();
    85.     }
    86. }

    Redis缓存问题小结 

    • 如何添加缓存

    Redis的缓存问题（一）添加redis缓存与扩展_面向鸿蒙编程的博客-CSDN博客_redis添加缓存

    • 缓存更新策略

    Redis的缓存问题（二）缓存更新策略与实践_面向鸿蒙编程的博客-CSDN博客_redis修改缓存数据

    • 缓存穿透问题
    • 缓存雪崩问题
    • 缓存击穿问题

    Redis的缓存问题（三）缓存穿透、缓存雪崩、缓存击穿_面向鸿蒙编程的博客-CSDN博客

    • redis工具类的编写

    Redis的缓存问题（四）将redis常用操作封装成工具类_面向鸿蒙编程的博客-CSDN博客

  • 相关阅读:
    Linux常用操作汇总：内容有点杂，但很实用
    KubeSphere 网关的设计与实现（解读）
    Vue 源码解读（7）—— Hook Event
    Web Components详解-Shadow DOM样式控制
    zynq mpsoc裸机多中断运行
    【力扣的101夜】轮转数组
    鸿蒙应用开发初尝试《创建项目》，之前那篇hello world作废
    Docker Postgres 安装部署指南1.0
    js中super的使用
    【GoWeb项目-个人Blog】初始化数据库和日志
  • 原文地址：https://blog.csdn.net/weixin_43715214/article/details/126514517