Redis进阶学习02---Redis替代Session和Redis缓存

转x33g5p2x  于2022-04-28 转载在 Redis  
字(21.5k)|赞(0)|评价(0)|浏览(713)

参考b站虎哥redis视频

本系列项目源码将会保存在gitee上面，仓库链接如下:

https://gitee.com/DaHuYuXiXi/redis-combat-project

基于Session登录流程

我们先来看一下基于Session实现登录的模板流程是什么样子的:

  • 发送短信验证码

核心逻辑：

  1. public Result sendCode(String phone, HttpSession session) {
  2.         //1.校验手机号
  3.         if(RegexUtils.isPhoneInvalid(phone))
  4.         {
  5.             //2.如果不符合,返回错误信息
  6.             return Result.fail(getErrMsg("01",UserServiceImpl.class));
  7.         }
  8.         //3.符合,生成验证码
  9.         String code = RandomUtil.randomNumbers(6);
  10.         //4.保存验证码到session
  11.         session.setAttribute("code",code);
  12.         //5.发送验证码
  13.          log.debug("发送短信验证码成功,code {}",code);
  14.          //6.返回ok
  15.         return Result.ok();
  16.     }
  • 短信验证码的登录和注册

  1. @Override
  2.     public Result login(LoginFormDTO loginForm, HttpSession session) {
  3.         //1.校验手机号
  4.         String phone = loginForm.getPhone();
  5.         if (RegexUtils.isPhoneInvalid(phone)) {
  6.             //2.如果不符合,返回错误信息
  7.             return Result.fail(getErrMsg("01", UserServiceImpl.class));
  8.         }
  9.         //3.校验验证码
  10.         Object cacheCode = session.getAttribute("code");
  11.         String code = loginForm.getCode();
  12.         if (cacheCode == null || !cacheCode.toString().equals(code)) {
  13.             //4.不一致报错
  14.             return Result.fail(getErrMsg("02", UserServiceImpl.class));
  15.         }
  16.         //5.一致,根据手机号查询用户
  17.         User user = query().eq("phone", phone).one();
  19.         //6.判断用户是否存在
  20.         if (user == null) {
  21.             //7.不存在,创建新用户并保存
  22.             user = createUserWithPhone(phone);
  23.         }
  24.         //8.保存用户信息到session中
  25.         session.setAttribute("user", user);
  26.         return Result.ok();
  27.     }
  29.     private User createUserWithPhone(String phone) {
  30.         //1.创建用户
  31.         User user = new User();
  32.         user.setPhone(phone);
  33.         user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
  34.         //2.保存用户
  35.         save(user);
  36.         return user;
  37.     }
  • 校验登录状态

我们需要把验证功能放到拦截器中实现:

  1. public class LoginInterceptor implements HandlerInterceptor {
  2.     @Override
  3.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  4.       //1.获取session
  5.         HttpSession session = request.getSession();
  6.       //2.获取session中的用户
  7.         Object user = session.getAttribute("user");
  8.       //3.判断用户是否存在
  9.         if(user==null)
  10.         {
  11.             //4.不存在,拦截,返回401状态码
  12.             response.setStatus(401);
  13.             return false;
  14.         }
  15.         //5.存在,保存用户信息到ThreadLocal
  16.         UserHolder.saveUser(getUserDTO(user));
  17.         //6.放行
  18.         return true;
  19.     }
  21.     @Override
  22.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  23.        //清空ThreadLocal
  24.        UserHolder.removeUser();
  25.     }
  27.     private UserDTO getUserDTO(Object user) {
  28.         UserDTO userDTO = new UserDTO();
  29.         BeanUtils.copyProperties(user,userDTO);
  30.         return userDTO;
  31.     }
  32. }

保存用户信息到ThreadLocal可以确保当前请求从开始到结束这段时间，我们可以轻松从ThreadLocal中获取当前用户信息，而不需要每次用到的时候，还去查询一遍

本节项目完整代码，参考2.0版本

集群session共享问题

既然多台tomcat之间的session存在隔离问题，那么我们是否可以将session中存储的内容移动到redis中进行存放，即用redis代替session

基于Redis实现session共享

这里说一下: 登录成功后，会将用户保存到redis中，这和上面讲用户保存到session中的思想是一致的，都是一种缓存思想，防止每次都需要拦截器拦截请求时，都需要去数据库查找，而是直接通过token去redis中获取即可

注意，这里的token不是jwt的token,这里的token只是随机生成的一段字符串，我们无法通过解析这个字符串拿到用户信息，而是只能通过这个token作为key,去redis中获取到对应用户的信息。

个人想法:即便是jwt的token，因为一般不会在里面token中保存完整的用户信息，并且每次请求打进拦截器的时候，还是需要去解析token,并去数据库查一下，防止token伪造，但是这样太浪费性能了，可以考虑在登录成功后，将用户信息存入redis，并且规定过期时间,然后拦截器每次根据token去redis获取用户完整信息，如果成功获取，那么刷新token过期时间，否则，从数据库重新获取，然后再放入缓存中。

我们这里选用HASH来存储User对象的信息:

UserServiceImpl代码:

  1. @Service
  2. @Slf4j
  3. @RequiredArgsConstructor
  4. public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
  5.     private final StringRedisTemplate stringRedisTemplate;
  7.     @Override
  8.     public Result sendCode(String phone, HttpSession session) {
  9.         //1.校验手机号
  10.         if (RegexUtils.isPhoneInvalid(phone)) {
  11.             //2.如果不符合,返回错误信息
  12.             return Result.fail(getErrMsg("01", UserServiceImpl.class));
  13.         }
  14.         //3.符合,生成验证码
  15.         String code = RandomUtil.randomNumbers(6);
  16.         //4.保存验证码到redis
  17.         stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,2, TimeUnit.MINUTES);
  18.         //5.发送验证码
  19.         log.debug("phone code {}", code);
  20.         //6.返回ok
  21.         return Result.ok();
  22.     }
  24.     @Override
  25.     public Result login(LoginFormDTO loginForm, HttpSession session) {
  26.         //1.校验手机号
  27.         String phone = loginForm.getPhone();
  28.         if (RegexUtils.isPhoneInvalid(phone)) {
  29.             //2.如果不符合,返回错误信息
  30.             return Result.fail(getErrMsg("01", UserServiceImpl.class));
  31.         }
  32.         //3.从redis中获取验证码然后进行校验
  33.         String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);
  34.         String code = loginForm.getCode();
  35.         if (cacheCode == null || !cacheCode.toString().equals(code)) {
  36.             //4.不一致报错
  37.             return Result.fail(getErrMsg("02", UserServiceImpl.class));
  38.         }
  39.         //5.一致,根据手机号查询用户
  40.         User user = query().eq("phone", phone).one();
  42.         //6.判断用户是否存在
  43.         if (user == null) {
  44.             //7.不存在,创建新用户并保存
  45.             user = createUserWithPhone(phone);
  46.         }
  48.         //7.保存用户信息到redis
  49.         //7.1 随机生成token,作为登录令牌
  50.         String token = generateToken();
  51.         //7.2 将User对象转换为Hash对象
  52.         Map map = beanToMap(BeanUtil.copyProperties(user, UserDTO.class));
  53.         String key=LOGIN_USER_KEY+token;
  54.         stringRedisTemplate.opsForHash().putAll(key,map);
  55.         //设置有效期
  56.         stringRedisTemplate.expire(key,LOGIN_USER_TTL,TimeUnit.MINUTES);
  57.         //7.3 存储
  58.         return Result.ok();
  59.     }
  61.     private Map<String, Object> beanToMap(UserDTO user) {
  62.         return BeanUtil.beanToMap(user, new HashMap<>(), CopyOptions.create().setIgnoreNullValue(true)
  63.                 //解决long转String报错的问题
  64.                 .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
  65.     }
  67.     private String generateToken() {
  68.         return UUID.randomUUID().toString(true);
  69.     }
  71.     private User createUserWithPhone(String phone) {
  72.         //1.创建用户
  73.         User user = new User();
  74.         user.setPhone(phone);
  75.         user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
  76.         //2.保存用户
  77.         save(user);
  78.         return user;
  79.     }
  81. }

LoginInterceptor 代码:

  1. public class LoginInterceptor implements HandlerInterceptor {
  2.     private StringRedisTemplate stringRedisTemplate;
  4.     public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
  5.         this.stringRedisTemplate = stringRedisTemplate;
  6.     }
  8.     @Override
  9.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  10.         //1.获取请求头中的token
  11.         String token = request.getHeader("authorization");
  12.         if (StrUtil.isBlank(token)) {
  13.             //不存在,拦截,返回401状态码
  14.             response.setStatus(401);
  15.             return false;
  16.         }
  17.         token = LOGIN_USER_KEY + token;
  18.         //2.基于Token获取redis中的用户
  19.         Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(token);
  20.         //3.判断用户是否存在
  21.         if (userMap.isEmpty()) {
  22.             //不存在,拦截,返回401状态码
  23.             response.setStatus(401);
  24.             return false;
  25.         }
  26.         //5.map转换为userDto
  27.         UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
  29.         //6.用户信息保存到threadLocal
  30.         UserHolder.saveUser(userDTO);
  32.         //7.刷新token的有效期
  33.         stringRedisTemplate.expire(token, LOGIN_USER_TTL, TimeUnit.MINUTES);
  34.         return true;
  35.     }
  37.     @Override
  38.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  39.         UserHolder.removeUser();
  40.     }
  41. }

解决状态登录刷新问题

上面的代码设计思路: 如果用户长时间都在请求不需要拦截的请求，那么token就不会被刷新，进而导致用户浏览浏览着，token就过期了

优化后:分离拦截器职责，用一个单独的拦截器拦截所有请求，每次都刷新token，另一个拦截器就负责需要登录的请求进行拦截即可

  1. public class RefreshTokenInterceptor implements HandlerInterceptor {
  3.     private StringRedisTemplate stringRedisTemplate;
  5.     public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
  6.         this.stringRedisTemplate = stringRedisTemplate;
  7.     }
  9.     @Override
  10.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  11.         //1.获取请求头中的token
  12.         String token = request.getHeader("authorization");
  13.         if (StrUtil.isBlank(token)) {
  14.             //不存在,拦截,返回401状态码
  15.             response.setStatus(401);
  16.             return false;
  17.         }
  18.         token = LOGIN_USER_KEY + token;
  20.         //2.基于Token获取redis中的用户
  21.         Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(token);
  22.         //3.判断用户是否存在
  23.         if (userMap.isEmpty()) {
  24.             //不存在,拦截,返回401状态码
  25.             response.setStatus(401);
  26.             return false;
  27.         }
  28.         //5.map转换为userDto
  29.         UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
  31.         //6.用户信息保存到threadLocal
  32.         UserHolder.saveUser(userDTO);
  34.         //7.刷新token的有效期
  35.         stringRedisTemplate.expire(token, LOGIN_USER_TTL, TimeUnit.MINUTES);
  36.         return true;
  37.     }
  38.        
  39.     @Override
  40.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  41.         UserHolder.removeUser();
  42.     }
  43. }
  1. public class LoginInterceptor implements HandlerInterceptor {
  2.     @Override
  3.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  4.         //判断是否需要去拦截
  5.         if(UserHolder.getUser()==null)
  6.         {
  7.             response.setStatus(401);
  8.             return false;
  9.         }
  10.         return true;
  11.     }
  12. }

RefreshTokenInterceptor 要先于LoginInterceptor 执行，否则LoginInterceptor 中无法中ThreadLocal中获取用户信息

  1. @Configuration
  2. @RequiredArgsConstructor
  3. public class WebMvcConfig implements WebMvcConfigurer {
  4.     private final StringRedisTemplate stringRedisTemplate;
  6.     @Override
  7.     public void addInterceptors(InterceptorRegistry registry) {
  8.         registry.addInterceptor(new LoginInterceptor())
  9.                 .excludePathPatterns(
  10.                      "/shop/**",
  11.                      "/voucher/**",
  12.                      "/shop-type/**",
  13.                        "/upload/**",
  14.                        "/blog/hot",
  15.                        "/user/code",
  16.                        "/user/login"
  17.                 )
  18.                 //指定拦截器的执行顺序---数字越小,优先级越高
  19.                 .order(2);
  20.         
  21.       registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(1);
  22.     }
  24. }

还有一点需要注意：如果用户信息被修改了，需要清空redis中的缓存信息，让用户重新进行登录

本节项目完整代码，参考3.0版本

Redis缓存应用

什么是缓存

添加redis缓存

下面给出一个例子:

  1. @Service
  2. @RequiredArgsConstructor
  3. public class ShopServiceImpl extends ServiceImpl<ShopMapper, Shop> implements IShopService {
  4.     @Autowired
  5.     private final StringRedisTemplate stringRedisTemplate;
  7.     @Override
  8.     public Result queryById(Long id) {
  9.         String key=CACHE_SHOP_KEY+id;
  10.         //1.从redis中查询商铺缓存
  11.         String shopJson=stringRedisTemplate.opsForValue().get(key);
  12.         //2.判断是否存在
  13.         if(StrUtil.isNotBlank(shopJson))
  14.         {
  15.             //3.存在,直接返回
  16.             Shop shop = JSONUtil.toBean(shopJson, Shop.class);
  17.             return Result.ok(shop);
  18.         }
  19.         //4.不存在,根据id查询数据库
  20.         Shop shop = getById(id);
  21.         //5.不存在,返回错误
  22.         if(shop==null)
  23.         {
  24.             return Result.fail(ErrorMsgHandler.getErrMsg("03",ShopServiceImpl.class));
  25.         }
  26.         //6.存在,写入redis
  27.         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop));
  28.         return Result.ok(shop);
  29.     }
  30. }

缓存更新策略

主动更新策略

先操作缓存，还是先操作数据库

总结

案例

  1. @Override
  2.     public Result queryById(Long id) {
  3.         String key=CACHE_SHOP_KEY+id;
  4.         //1.从redis中查询商铺缓存
  5.         String shopJson=stringRedisTemplate.opsForValue().get(key);
  6.         //2.判断是否存在
  7.         if(StrUtil.isNotBlank(shopJson))
  8.         {
  9.             //3.存在,直接返回
  10.             Shop shop = JSONUtil.toBean(shopJson, Shop.class);
  11.             return Result.ok(shop);
  12.         }
  13.         //4.不存在,根据id查询数据库
  14.         Shop shop = getById(id);
  15.         //5.不存在,返回错误
  16.         if(shop==null)
  17.         {
  18.             return Result.fail(ErrorMsgHandler.getErrMsg("03",ShopServiceImpl.class));
  19.         }
  20.         //6.存在,写入redis
  21.         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
  22.         return Result.ok(shop);
  23.     }
  1. @Override
  2.     public Result update(Shop shop) {
  3.         Long id = shop.getId();
  4.         if(id==null)
  5.         {
  6.             return Result.fail(ErrorMsgHandler.getErrMsg("04",ShopServiceImpl.class));
  7.         }
  8.         //1.更新数据库
  9.         updateById(shop);
  10.         //2.删除缓存
  11.         stringRedisTemplate.delete(CACHE_SHOP_KEY+id);
  12.         return Result.ok();
  13.     }

缓存穿透

缓存空对象解决缓存穿透

  1. @Override
  2.     public Result queryById(Long id) {
  3.         String key=CACHE_SHOP_KEY+id;
  4.         //1.从redis中查询商铺缓存
  5.         String shopJson=stringRedisTemplate.opsForValue().get(key);
  6.         //2.判断是否存在
  7.         if(StrUtil.isNotBlank(shopJson))
  8.         {
  9.             //3.存在,直接返回
  10.             Shop shop = JSONUtil.toBean(shopJson, Shop.class);
  11.             return Result.ok(shop);
  12.         }
  13.         //判断命中的是否是空值
  14.         if(shopJson!=null&&shopJson.equals(NULL_OBJ_TAG))
  15.         {
  16.             return Result.fail(ErrorMsgHandler.getErrMsg("05",ShopServiceImpl.class));
  17.         }
  18.         //4.不存在,根据id查询数据库
  19.         Shop shop = getById(id);
  20.         //5.不存在,返回错误
  21.         if(shop==null)
  22.         {
  23.             //将空值写入到redis
  24.             stringRedisTemplate.opsForValue().set(key,NULL_OBJ_TAG,CACHE_NULL_TTL,TimeUnit.MINUTES);
  25.             return Result.fail(ErrorMsgHandler.getErrMsg("03",ShopServiceImpl.class));
  26.         }
  27.         //6.存在,写入redis
  28.         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
  29.         return Result.ok(shop);
  30.     }

缓存穿透小结

缓存雪崩

缓存击穿

互斥锁和逻辑过期解决缓存击穿的思路

互斥锁的实现其实很简单，既然热点key过期失效了，并且同时有很多个请求打进来，尝试重构缓存，那么就用一把锁，只让第一个请求去重构缓存，其余的请求线程就等待加重试，直到缓存重构成功

而对于逻辑过期的思路来讲，既然是因为热度key过期导致的缓存击穿，那我我就让这些热点key不会真的过期，而通过增加一个逻辑过期字段，每一次获取的时候，先去判断是否过期，如果过期了，就按照上图的流程执行

互斥锁可以实现一致性，但是牺牲了可用性。逻辑过期实现了可用性，但是牺牲了一致性。

一般是手动为热度key设置逻辑过期，然后等到热度过后，再删除这些热点key

互斥锁解决缓存击穿问题

为了防止出现死锁，我们还需要给锁设置一个过期时间，来确保锁一定会被释放掉

案例

  1. @Override
  2.     public Result queryById(Long id) {
  3.         //缓存穿透逻辑
  4.         //Shop shop=passThrough(id);
  5.         //缓存击穿逻辑
  6.         Shop shop = queryWithMutex(id);
  7.         if(shop==null)
  8.         {
  9.             return Result.fail(ErrorMsgHandler.getErrMsg("03",ShopServiceImpl.class));
  10.         }
  11.         return Result.ok(shop);
  12.     }
  14.     private Shop queryWithMutex(Long id) {
  15.             Shop shop=null;
  16.             String key=CACHE_SHOP_KEY+id;
  17.             //1.从redis中查询商铺缓存
  18.             String shopJson=stringRedisTemplate.opsForValue().get(key);
  19.             //2.判断是否存在
  20.             if(StrUtil.isNotBlank(shopJson))
  21.             {
  22.                 //3.存在,直接返回
  23.                 shop = JSONUtil.toBean(shopJson, Shop.class);
  24.                 return shop;
  25.             }
  26.             //判断命中的是否是空值---解决缓存雪崩
  27.                  if(shopJson!=null&&shopJson.equals(NULL_OBJ_TAG))
  28.             {
  29.                 return null;
  30.             }
  31.             //4.缓存重建---解决缓存击穿
  32.             //4.1 获取互斥锁
  33.             String lockKey=LOCK_SHOP_KEY+id;
  34.         try{
  35.             //4.2判断是否获取成功
  36.             if(!tryLock(lockKey)){
  37.                 //4.3失败，则休眠并重试
  38.                 Thread.sleep(50);
  39.                 //重试
  40.                 return queryWithMutex(id);
  41.             }
  42.             //4.3 成功,根据id查询数据库
  43.             shop = getById(id);
  44.             //5.不存在,返回错误
  45.             if(shop==null)
  46.             {
  47.                 //将空值写入到redis---解决缓存雪崩
  48.                 stringRedisTemplate.opsForValue().set(key,NULL_OBJ_TAG,CACHE_NULL_TTL,TimeUnit.MINUTES);
  49.                 return null;
  50.             }
  51.             //6.存在,写入redis
  52.             stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
  53.             return shop;
  54.         } catch (InterruptedException e) {
  55.             e.printStackTrace();
  56.         }finally {
  57.             unLock(key);
  58.         }
  59.         return shop;
  60.     }
  61.     /**
  62.      * 尝试获取锁
  63.      */
  64.     private boolean tryLock(String key) {
  65.         return BooleanUtil.isTrue(stringRedisTemplate.opsForValue().setIfAbsent(key,"1",10,TimeUnit.SECONDS));
  66.     }
  68.     /**
  69.      * 解锁
  70.      */
  71.     private void unLock(String key)
  72.     {
  73.         stringRedisTemplate.delete(key);
  74.     }

下载的源码包后，请删除mapper包下面的controller包，这是因为操作不当，导致存在两个完全相同的controller包

逻辑过期解决缓存击穿问题

首先我们需要给热点key增加一个逻辑过期字段，比如: 某个shop对象作为热点key，难道就因为几个shop对象作为热点key，我们就要给shop类增加一个逻辑过期字段吗？—显然这是极其不合理的

按照重构的思想，我们需要弄出一种方案，可以让所有的需要作为热点key的对象，都重用一个逻辑过期字段，并且与业务对象是不耦合的,这里我给出一种解决方案:

  1. @Data
  2. public class RedisData<T> {
  3.     private LocalDateTime expireTime;
  4.     //data封装任何想要作为热点key的对象
  5.     private T data;
  6. }

我们这里还需要写一个针对店铺信息进行逻辑过期保存的功能:

  1. public void saveShopToRedis(Long id,Long expireSeconds){
  2.         //1.查询店铺数据
  3.         Shop shop = getById(id);
  4.         //2.封装逻辑过期时间
  5.         RedisData<Shop> shopRedisObj = new RedisData<>();
  6.         shopRedisObj.setData(shop);
  7.         shopRedisObj.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
  8.         //3.写入redis
  9.         stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shopRedisObj));
  10.     }

手动往redis中存入热点key:

  1. @SpringBootTest
  2. class HmDianPingApplicationTests {
  3.     @Autowired
  4.     private ShopServiceImpl service;
  5.     @Test
  6.     public void testRedisLogicTTL(){
  7.         service.saveShopToRedis(1L,10L);
  8.     }
  9. }

在对店铺查询逻辑进行修改，增加逻辑过期:

  1. @Override
  2.     public Result queryById(Long id) {
  3.         //缓存穿透逻辑
  4.         //Shop shop=passThrough(id);
  5.         //缓存击穿逻辑
  6.         //Shop shop = queryWithMutex(id);
  7.         Shop shop=queryWithLogicExpire(id);
  8.         if(shop==null)
  9.         {
  10.             return Result.fail(ErrorMsgHandler.getErrMsg("03",ShopServiceImpl.class));
  11.         }
  12.         return Result.ok(shop);
  13.     }
  15.     private static final ExecutorService CACHE_REBUILD_EXECUTOR= Executors.newFixedThreadPool(10);
  17.     private Shop queryWithLogicExpire(Long id) {
  18.         String key=CACHE_SHOP_KEY+id;
  19.         //1.从redis查询商铺缓存
  20.         String shopJson=stringRedisTemplate.opsForValue().get(key);
  21.         //2.判断是否存在---不存在需要去数据库重新创建缓存，这里是针对热点Key处理，没有完善
  22.         //这里还需要考虑缓存穿透的问题处理--得到的是否是缓存空对象
  23.         if(StrUtil.isBlank(shopJson)) {
  24.             //3.不存在,直接返回
  25.             return null;
  26.         }
  27.         //4.命中,需要先把JSON反序列化为对象
  28.         RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
  29.         Shop shop = JSONUtil.toBean((JSONObject) redisData.getData(), Shop.class);
  30.         LocalDateTime expireTime = redisData.getExpireTime();
  31.         //5.判断是否过期
  32.         if(expireTime.isAfter(LocalDateTime.now())) {
  33.             //5.1未过期,直接返回
  34.             return shop;
  35.         }
  36.         //5.2过期了,需要缓存重建
  37.         //6.缓存重建
  38.         //6.1获取互斥锁
  39.         String lockKey=LOCK_SHOP_KEY+id;
  40.         boolean lock = tryLock(lockKey);
  41.         //6.2判断是否获取锁成功
  42.         if(lock){
  43.             //6.3成功,开启独立线程，实现缓存重建
  44.             CACHE_REBUILD_EXECUTOR.submit(()->{
  45.                //重建缓存
  46.                this.saveShopToRedis(id,LOCK_SHOP_TTL);
  47.                //释放锁
  48.                 unLock(lockKey);
  49.             });
  50.         }
  51.         //6.4返回过期的店铺信息
  52.         return shop;
  53.     }
  54.     
  55.     public void saveShopToRedis(Long id,Long expireSeconds){
  56.         //1.查询店铺数据
  57.         Shop shop = getById(id);
  58.         try {
  59.             //200ms的延迟，模拟长时间数据库重建
  60.             Thread.sleep(200L);
  61.         } catch (InterruptedException e) {
  62.             e.printStackTrace();
  63.         }
  64.         //2.封装逻辑过期时间
  65.         RedisData<Shop> shopRedisObj = new RedisData<>();
  66.         shopRedisObj.setData(shop);
  67.         shopRedisObj.setExpireTime(LocalDateTime.now().plusSeconds(expireSeconds));
  68.         //3.写入redis
  69.         stringRedisTemplate.opsForValue().set(CACHE_SHOP_KEY+id,JSONUtil.toJsonStr(shopRedisObj));
  70.     }

下面我们启动项目，然后使用jemeter进行压力测试:

我们来测试一下，看是否只会触发一次数据库查询，并且缓存重建成功:

封装redis工具类

  1. package com.hmdp.cache;
  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 com.hmdp.utilObj.RedisData;
  8. import org.springframework.data.redis.core.StringRedisTemplate;
  9. import org.springframework.stereotype.Component;
  10. import java.time.LocalDateTime;
  11. import java.time.temporal.TemporalUnit;
  12. import java.util.concurrent.ExecutorService;
  13. import java.util.concurrent.Executors;
  14. import java.util.concurrent.TimeUnit;
  15. import java.util.function.Function;
  17. /**
  18.  * @author 大忽悠
  19.  * @create 2022/4/27 13:35
  20.  */
  21. @Component
  22. public class RedisCacheClient {
  24.     private final StringRedisTemplate stringRedisTemplate;
  26.     /**
  27.      * 默认线程池大小
  28.      */
  29.     private static final int DEFAULT_THREAD_SIZE=10;
  31.     /**
  32.      * 负责缓存重建工作的线程池
  33.      */
  34.     private static final ExecutorService CACHE_REBUILD_EXECUTOR= Executors.newFixedThreadPool(DEFAULT_THREAD_SIZE);
  36.     /**
  37.      * 缓存空对象存入的标记
  38.      */
  39.     private static final String NULL_OBJ_TAG="nullObjSaveTag";
  41.     public RedisCacheClient(StringRedisTemplate stringRedisTemplate) {
  42.         this.stringRedisTemplate = stringRedisTemplate;
  43.     }
  45.     /**
  46.      * @param key redis中存入的key
  47.      * @param value redis中存入的value
  48.      * @param expireTime 过期时间
  49.      * @param timeUnit 过期时间的单位
  50.      */
  51.     public void set(String key,Object value,Long expireTime,TimeUnit timeUnit){
  52.         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(value),expireTime,timeUnit);
  53.     }
  55.     /**
  56.      * <p>
  57.      *     这里的过期时间,是增加一个逻辑过期字段,传入的value会使用RedisData封装起来
  58.      * </p>
  59.      * @param key redis中存入的key
  60.      * @param value redis中存入的value
  61.      * @param expireTime 过期时间
  62.      * @param timeUnit 过期时间的单位
  63.      */
  64.     public void setWithLogicalExpire(String key,Object value,Long expireTime,TimeUnit timeUnit){
  65.         //设置逻辑过期
  66.         RedisData redisData = new RedisData();
  67.         redisData.setData(value);
  68.         redisData.setExpireTime(LocalDateTime.now().plusSeconds(timeUnit.toSeconds(expireTime)));
  69.         //写入redis
  70.         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(redisData));
  71.     }
  73.     /**
  74.      * <p>
  75.      *     查询过程中会处理缓存穿透问题,解决redis和数据库都不存在的key的查询问题
  76.      *     利用空对象缓存来解决这个问题
  77.      * </p>
  78.      * @param keyPrefix key的前缀
  79.      * @param id 去数据库查询的具体对象id
  80.      * @param dbCallBack 数据库的回调接口,向该回调接口传入一个id,然后获取到该回调接口查询出来的对象
  81.      * @param dataClass 目标对象的类型
  82.      * @param expireTime 过期时间
  83.      * @param timeUnit 过期时间单位
  84.      * @param nullObjExpireTime 缓存的空对象的过期时间
  85.      * @param nullObjTimeunit 缓存的空对象的过期时间单位
  86.      * @param <ID> id的类型
  87.      * @param <R> 返回值类型
  88.      * @return 返回的是查询到的对象
  89.      */
  90.     public  <ID,R>  R  queryWithPassThrough(String keyPrefix, ID id, Function<ID,R> dbCallBack, Class<R> dataClass, Long expireTime, TimeUnit timeUnit,
  91.                                             Long nullObjExpireTime,TimeUnit nullObjTimeunit){
  92.         //0.缓存key
  93.         String key=keyPrefix+id;
  94.         //1.从redis中查询商铺缓存
  95.         String shopJson=stringRedisTemplate.opsForValue().get(key);
  96.         //2.判断是否存在
  97.         if(StrUtil.isNotBlank(shopJson))
  98.         {
  99.             //3.存在,直接返回
  100.             R bean = JSONUtil.toBean(shopJson, dataClass);
  101.             return bean;
  102.         }
  103.         //判断命中的是否是空值
  104.         if(shopJson!=null&&shopJson.equals(NULL_OBJ_TAG))
  105.         {
  106.             return null;
  107.         }
  108.         //4.不存在,根据id查询数据库
  109.         R bean = dbCallBack.apply(id);
  110.         //5.不存在,返回错误
  111.         if(bean==null)
  112.         {
  113.             //将空值写入到redis
  114.             stringRedisTemplate.opsForValue().set(key,NULL_OBJ_TAG,nullObjExpireTime,nullObjTimeunit);
  115.             return null;
  116.         }
  117.         //6.存在,写入redis
  118.         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(bean),expireTime, timeUnit);
  120.         return bean;
  121.     }
  123.     /**
  124.      * <p>
  125.      *     查询过程中会处理缓存击穿问题,解决热点key的查询问题
  126.      *     利用逻辑过期来解决这个问题
  127.      * </p>
  128.      * @param keyPrefix 缓存对象关联的key前缀
  129.      * @param lockKeyPrefix  锁住当前对象重构过程的锁前缀
  130.      * @param id 对象id
  131.      * @param dbCallBack 数据库的回调接口,向该回调接口传入一个id,然后获取到该回调接口查询出来的对象
  132.      * @param dataClass 对象类型
  133.      * @param expireTime 过期时间
  134.      * @param timeUnit 过期时间单位
  135.      * @param <ID> id的类型
  136.      * @param <R> 返回值类型
  137.      * @return 返回的是查询到的对象
  138.      */
  139.     public <ID,R> R queryWithLogicExpire(String keyPrefix,String lockKeyPrefix, ID id, Function<ID,R> dbCallBack, Class<R> dataClass
  140.             ,Long expireTime, TemporalUnit timeUnit) {
  141.         String key=keyPrefix+id;
  142.         //1.从redis查询商铺缓存
  143.         String shopJson=stringRedisTemplate.opsForValue().get(key);
  144.         //2.判断是否存在
  145.         if(StrUtil.isBlank(shopJson)) {
  146.             //3.不存在,直接返回
  147.             return null;
  148.         }
  149.         //4.命中,需要先把JSON反序列化为对象
  150.         RedisData redisData = JSONUtil.toBean(shopJson, RedisData.class);
  151.         R bean = JSONUtil.toBean((JSONObject) redisData.getData(), dataClass);
  152.         LocalDateTime getExpireTime = redisData.getExpireTime();
  153.         //5.判断是否过期
  154.         if(getExpireTime.isAfter(LocalDateTime.now())) {
  155.             //5.1未过期,直接返回
  156.             return bean;
  157.         }
  158.         //5.2过期了,需要缓存重建
  159.         //6.缓存重建
  160.         //6.1获取互斥锁
  161.         String lockKey=lockKeyPrefix+id;
  162.         boolean lock = tryLock(lockKey);
  163.         //6.2判断是否获取锁成功
  164.         if(lock){
  165.             //6.3成功,开启独立线程，实现缓存重建
  166.             CACHE_REBUILD_EXECUTOR.submit(()->{
  167.                 //重建缓存
  168.                 this.saveHotBeanToRedisWithLogicTag(keyPrefix,id,dbCallBack,expireTime,timeUnit);
  169.                 //释放锁
  170.                 unLock(lockKey);
  171.             });
  172.         }
  173.         //6.4返回过期的店铺信息
  174.         return bean;
  175.     }
  177.     /**
  178.      * <P>
  179.      *     利用互斥锁解决缓存击穿问题
  180.      * </P>
  181.      * @param keyPrefix key的前缀
  182.      * @param id 去数据库查询的具体对象id
  183.      * @param dbCallBack 数据库的回调接口,向该回调接口传入一个id,然后获取到该回调接口查询出来的对象
  184.      * @param dataClass 目标对象的类型
  185.      * @param expireTime 过期时间
  186.      * @param timeUnit 过期时间单位
  187.      * @param nullObjExpireTime 缓存的空对象的过期时间
  188.      * @param nullObjTimeunit 缓存的空对象的过期时间单位
  189.      * @param <ID> id的类型
  190.      * @param <R> 返回值类型
  191.      * @return 返回的是查询到的对象
  192.      */
  193.     public  <ID,R>  R queryWithMutex(String keyPrefix,String lockKeyPrefix,ID id,Class<R> dataClass,Function<ID,R> dbCallBack,Long expireTime,
  194.                                      TimeUnit timeUnit,Long nullObjExpireTime,TimeUnit nullObjTimeunit) {
  195.         R bean=null;
  196.         String key=keyPrefix+id;
  197.         //1.从redis中查询商铺缓存
  198.         String shopJson=stringRedisTemplate.opsForValue().get(key);
  199.         //2.判断是否存在
  200.         if(StrUtil.isNotBlank(shopJson))
  201.         {
  202.             //3.存在,直接返回
  203.             bean = JSONUtil.toBean(shopJson, dataClass);
  204.             return bean;
  205.         }
  206.         //判断命中的是否是空值---解决缓存雪崩
  207.         if(shopJson!=null&&shopJson.equals(NULL_OBJ_TAG))
  208.         {
  209.             return null;
  210.         }
  211.         //4.缓存重建---解决缓存击穿
  212.         //4.1 获取互斥锁
  213.         String lockKey=lockKeyPrefix+id;
  214.         try{
  215.             //4.2判断是否获取成功
  216.             if(!tryLock(lockKey)){
  217.                 //4.3失败，则休眠并重试
  218.                 Thread.sleep(50);
  219.                 //重试
  220.                 return queryWithMutex(keyPrefix,lockKeyPrefix,id,dataClass,dbCallBack,expireTime,timeUnit,nullObjExpireTime,nullObjTimeunit);
  221.             }
  222.             //4.3 成功,根据id查询数据库
  223.             bean = dbCallBack.apply(id);
  224.             //5.不存在,返回错误
  225.             if(bean==null)
  226.             {
  227.                 //将空值写入到redis---解决缓存雪崩
  228.                 stringRedisTemplate.opsForValue().set(key,NULL_OBJ_TAG,nullObjExpireTime,nullObjTimeunit);
  229.                 return null;
  230.             }
  231.             //6.存在,写入redis
  232.             stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(bean),expireTime,timeUnit);
  233.             return bean;
  234.         } catch (InterruptedException e) {
  235.             e.printStackTrace();
  236.         }finally {
  237.             unLock(key);
  238.         }
  239.         return bean;
  240.     }
  242.     /**
  243.      * <p>
  244.      *     可以通过该方法,设置一个热点key进redis
  245.      * </p>
  246.      * @param keyPrefix 缓存对象关联的key前缀
  247.      * @param id 对象id
  248.      * @param dbCallBack 数据库的回调接口,向该回调接口传入一个id,然后获取到该回调接口查询出来的对象
  249.      * @param expireTime 过期时间
  250.      * @param timeUnit 过期时间单位
  251.      * @param <ID> id的类型
  252.      * @param <R> 返回值类型
  253.      * @return 返回的是查询到的对象
  254.      */
  255.     public <ID,R> void saveHotBeanToRedisWithLogicTag(String keyPrefix,ID id, Function<ID,R> dbCallBack, Long expireTime, TemporalUnit timeUnit){
  256.         String key=keyPrefix+id;
  257.         //1.查询店铺数据
  258.         R bean = dbCallBack.apply(id);
  259.         //2.封装逻辑过期时间
  260.         RedisData redisData = new RedisData<>();
  261.         redisData.setData(bean);
  262.         redisData.setExpireTime(LocalDateTime.now().plus(expireTime,timeUnit));
  263.         //3.写入redis
  264.         stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(redisData));
  265.     }
  267.     /**
  268.      * 尝试获取锁
  269.      */
  270.     private boolean tryLock(String key) {
  271.         return BooleanUtil.isTrue(stringRedisTemplate.opsForValue().setIfAbsent(key,"locked",10,TimeUnit.SECONDS));
  272.     }
  274.     /**
  275.      * 解锁
  276.      */
  277.     private void unLock(String key)
  278.     {
  279.         stringRedisTemplate.delete(key);
  280.     }
  281. }

版权说明 : 本文为转载文章, 版权归原作者所有 版权申明

原文链接 : https://cjdhy.blog.csdn.net/article/details/124289717

内容来源于网络，如有侵权，请联系作者删除！

Javaspring源码研读

相关文章

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新文章

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com