Redis实战篇（一）验证码登录、缓存穿透、缓存击穿、缓存雪崩的讲解以及解决

最新推荐文章于 2024-03-04 10:16:35 发布
最新推荐文章于 2024-03-04 10:16:35 发布
阅读量629 收藏 3
点赞数 1
分类专栏： Redis 文章标签： redis 缓存 数据库 spring boot spring cloud
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_53669566/article/details/131394056
版权

目录

基于session实验短信登录

 发送验证码

 登录验证功能​编辑

 用Redis实现共享Session问题

登录拦截器的优化

商品查询缓存

什么是缓存

添加redis缓存

 缓存穿透

 缓存雪崩

 缓存击穿

 缓存工具封装​编辑

基于session实验短信登录

 发送验证码

 

 登录验证功能

 

 

 用Redis实现共享Session问题

 

 

 

登录拦截器的优化


public class LoginInterceptor implements HandlerInterceptor {


//登录优化后 创建RefreshTokenInterceptor
@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        //1.判断是否需要拦截（ThreadLocal是否用户）
    if ( UserHolder.getUser()==null ){
        //没有，需要拦截，设置状态码
        response.setStatus(401);
        //拦截
        return false;

    }
//    有用户，则放行
    return true;
    }
//登录优化前

//    @Override
//    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
//        //1.获取session
//        //HttpSession session = request.getSession();
//        //TODO 1.获取请求头中的token
//        String token = request.getHeader("authorization");
//        if ( StrUtil.isBlank(token) ) {
//            //不存在，拦截，返回401状态码
//            response.setStatus(401);
//            return false;
//        }
//        //2.获取session中的用户
        Object user = session.getAttribute("user");
//        //TODO 2.基于TOKEN获取redis中的用户
//        String key = RedisConstants.LOGIN_USER_KEY + token;
//        Map<Object, Object> userMap = stringRedisTemplate.opsForHash()
//                .entries(key);
//
//        //3.判断用户是否存在
//        if ( userMap.isEmpty()){
//         //4.不存在，拦截 返回401状态码
//        response.setStatus(401);
//        return false;
//        }
//        //TODO 5.将查询到的Hash数据转为UserDTO对象
//        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
//        //TODO 6.存在，保存用户信息到ThreadLocal
//        UserHolder.saveUser(userDTO);
//        //5.存在，保存用户信息到ThreadLocal
//        //5.存在，保存用户信息到ThreadLocal
//       // UserHolder.saveUser((UserDTO) user);
//        //TODO 7.刷新token有效期
//        stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
//        //6.放行
//        return true;
//    }



    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

 


public class RefreshTokenInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取session
        //HttpSession session = request.getSession();
        //TODO 1.获取请求头中的token
        String token = request.getHeader("authorization");
        if ( StrUtil.isBlank(token) ) {
            //不存在，拦截，返回401状态码
//            response.setStatus(401);
            return true;
        }
        //2.获取session中的用户
//        Object user = session.getAttribute("user");
        //TODO 2.基于TOKEN获取redis中的用户
        String key = RedisConstants.LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash()
                .entries(key);

        //3.判断用户是否存在
        if ( userMap.isEmpty()){
         //4.不存在，拦截 返回401状态码
//        response.setStatus(401);
        return true;
        }
        //TODO 5.将查询到的Hash数据转为UserDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //TODO 6.存在，保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
        //5.存在，保存用户信息到ThreadLocal
        //5.存在，保存用户信息到ThreadLocal
       // UserHolder.saveUser((UserDTO) user);
        //TODO 7.刷新token有效期
        stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        //6.放行
        return true;
    }



    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {

    }
}

商品查询缓存

什么是缓存

 

添加redis缓存

 

 

 

 

 

 缓存穿透

 

 

//    TODO 封装缓存穿透
    public Shop queryWithPassThrough(Long id){
        String key = CACHE_SHOP_KEY + id;
        //1、从redis查询商品缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        //2.判断是否存在
        if ( StrUtil.isNotBlank(shopJson) ){
            //TODO 如果是“”也是返回false
            //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
//            return Result.ok(shop);
            return shop;
        }

        //TODO 判断命中的是否是空值
        if ( shopJson!=null ){//第一步判断后这里就只剩下null和""
//            或者 if ( "".equals(shopJson) )
            //返回一个错误信息
//            return Result.fail("店铺不存在！！！");

            return null;

        }

        //4、不存在，根据id查询数据库
        Shop shop = getById(id);
        //5、不存在，返回错误
        if ( shop==null ){
            //TODO  解决缓存穿透
            //将控制写入redis中
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
//            return Result.fail("店铺不存在");
            return null;
        }
        //6、存在，写入redis
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7、返回
        return shop;
    }

 缓存雪崩

 缓存击穿

 

 

 //    TODO 封装缓存击穿
    public Shop queryWithMutex(Long id){
        String key = CACHE_SHOP_KEY + id;
        //1、从redis查询商品缓存
        String shopJson = stringRedisTemplate.opsForValue().get(key);

        //2.判断是否存在
        if ( StrUtil.isNotBlank(shopJson) ){
            //TODO 如果是“”也是返回false
            //3.存在，直接返回
            Shop shop = JSONUtil.toBean(shopJson, Shop.class);
//            return Result.ok(shop);
            return shop;
        }

        //TODO 判断命中的是否是空值
        if ( shopJson!=null ){//第一步判断后这里就只剩下null和""
//            或者 if ( "".equals(shopJson) )
            //返回一个错误信息
//            return Result.fail("店铺不存在！！！");
            return null;

        }
        //ToDO 4.实现缓存重建
        //ToDO 4.1获取互斥锁
        String lockKey = LOCK_SHOP_KEY + id;
        Shop shop = null;
        try {
            boolean isLock = tryLock(lockKey);
            //ToDO 4.2判断是否获取成功
            if ( !isLock ){
                //ToDO 4.3失败，则休眠并重试
                Thread.sleep(50);
                return queryWithMutex(id);

            }

            //ToDO 4.4、成功，根据id查询数据库
            shop = getById(id);
            //模拟重建的延时
            Thread.sleep(200);
            //5、不存在，返回错误
            if ( shop==null ){
                //TODO  解决缓存穿透
                //将控制写入redis中
                stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
    //            return Result.fail("店铺不存在");
                return null;
            }
            //6、存在，写入redis
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(shop),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        }
        catch (InterruptedException e) {
            throw new RuntimeException(e);
        }finally {
            //TODO 释放互斥锁
            unlock(lockKey);
        }


        //7、返回
        return shop;
    }





 private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        //防止拆箱
        return BooleanUtil.isTrue(flag);
    }

    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }

 缓存工具封装


@Slf4j
@Component
public class CacheClient {


    private final StringRedisTemplate stringRedisTemplate;

    public CacheClient(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    public void set(String key, Object value, Long time , TimeUnit unit){
        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(value),time,unit);
    }

    public void setWithLogicalExpire(String key, Object value, Long time , TimeUnit unit){
        //设置逻辑过期时间
        RedisData redisData = new RedisData();
        redisData.setData(value);
        redisData.setExpireTime(LocalDateTime.now().plusSeconds(unit.toSeconds(time)));
        //写入Redis

        stringRedisTemplate.opsForValue().set(key, JSONUtil.toJsonStr(redisData));
    }

    //    TODO 封装缓存穿透
    public <R,ID> R queryWithPassThrough(
            String keyPrefix, ID id, Class<R> type, Function<ID,R> dbFallback,Long time , TimeUnit unit){
        String key = keyPrefix + id;
        //1、从redis查询商品缓存
        String json = stringRedisTemplate.opsForValue().get(key);

        //2.判断是否存在
        if ( StrUtil.isNotBlank(json) ){
            //TODO 如果是“”也是返回false
            //3.存在，直接返回
            return JSONUtil.toBean(json, type);
        }

        //TODO 判断命中的是否是空值
        if ( json!=null ){//第一步判断后这里就只剩下null和""
//            或者 if ( "".equals(shopJson) )
            //返回一个错误信息
            return null;

        }

        //4、不存在，根据id查询数据库
        R r = dbFallback.apply(id);
        //5、不存在，返回错误
        if ( r==null ){
            //TODO  解决缓存穿透
            //将控制写入redis中
            stringRedisTemplate.opsForValue().set(key,"",CACHE_NULL_TTL,TimeUnit.MINUTES);
//            return Result.fail("店铺不存在");
            return null;
        }
        //6、存在，写入redis
        this.set(key,r,time,unit);
//        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(r),CACHE_SHOP_TTL, TimeUnit.MINUTES);
        //7、返回
        return r;
    }

    //TODO 线程池
    private  static  final ExecutorService CACHE_REBUILD_EXECUTOR = Executors.newFixedThreadPool(10);

    public <R,ID> R queryWithLogicalExpire(
            String keyPrefix,ID id,Class<R> type,Function<ID,R> dbFallback, Long time , TimeUnit unit){
        String key = keyPrefix + id;
        //1、从redis查询商品缓存
        String json = stringRedisTemplate.opsForValue().get(key);

        //2.判断是否存在
        if ( StrUtil.isBlank(json) ){
            //TODO 如果是“”也是返回false
            //3.不存在，直接返回
            return null;
        }

        //4.命中，需要先把json反序列化为对象
        RedisData redisData = JSONUtil.toBean(json, RedisData.class);
        JSONObject data = (JSONObject)redisData.getData();
        R r = JSONUtil.toBean(data, type);
        LocalDateTime expireTime = redisData.getExpireTime();

        //5.判断是否过期
        if ( expireTime.isAfter(LocalDateTime.now()) ) {
            //5.1未过期，直接返回店铺信息
            return r;
        }

        //5.2已过期，需要缓存重建
        //6.缓存重建
        //6.1获取互斥锁
        String lockKey = LOCK_SHOP_KEY+id;
        boolean isLock = tryLock(lockKey);
        //6.2判断是否获取锁成功
        if ( isLock ) {
            //TODO 6.3成功，开启独立线程，实现缓存重建
            CACHE_REBUILD_EXECUTOR.submit(()->{
                try {
                    //重建缓存(分下面两步)
                    //查询数据库
                    R r1 = dbFallback.apply(id);
                    //写入redis
                    this.setWithLogicalExpire(key,r1,time,unit);

                }
                catch (Exception e) {
                    e.printStackTrace();
                }finally {
                    //释放锁
                    unlock(lockKey);
                }

            });
        }
        //6.4失败，返回过期的商铺信息
        //7、返回
        return r;
    }
    private boolean tryLock(String key){
        Boolean flag = stringRedisTemplate.opsForValue().setIfAbsent(key, "1", 10, TimeUnit.SECONDS);
        //防止拆箱
        return BooleanUtil.isTrue(flag);
    }

    private void unlock(String key){
        stringRedisTemplate.delete(key);
    }


}

 

 

 

纯24k
关注
  • 1
    点赞
  • 踩
  • 3
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
通过redis(缓存)实现单点登录
05-19
跨应用访问 通过redis实现单点登录。即保证安全又减少多次输入密码的繁琐。
web项目缓存配置及单点登录借助redis实现
chutong452的博客
08-01 7265
最近项目在做多工程之间的缓存及单点登录时用到redis，心得总结如下： Redis 有三个主要使其有别于其它很多竞争对手的特点： Redis是完全在内存中保存数据的数据库，使用磁盘只是为了持久性目的；  Redis相比许多键值数据存储系统有相对丰富的数据类型；  Redis可以将数据复制到任意数量的从服务器中；  Redis优点 异常快速 : Red
redis缓存
m0_58342797的博客
07-07 601
缓存空数据是指：比如查找id为3的店铺，在缓存中找不到，在数据库中也找不到，这时在缓存放置 key为“shop3”，value为空的数据，下一次请求查找id为3的店铺，在缓存中就获取到了这个值，只不过内容为空而已。出现的问题就是：如果这个查询数据库的时间过长，其余线程就只能不断循环，等到查询完成之后，写入缓存，才会命中缓存，返回结果。redis是可以充当缓存的，因为redis是存于内存的，读写速度很快，请求来到服务器，服务器从redis读取数据，就返回数据，可以降低响应时间，提高读写速度，降低后端负载。
Redis实战—验证码登录功能实现
最新发布
向上的咸鱼blueblue的博客
03-04 917
实战篇之验证码登录。
使用redis进行缓存用户相关信息
无深度不学习的博客
09-14 1388
使用redis进行缓存用户相关信息 使用redis进行查询之后缓存的流程： 优先从缓存中取值 取不到时去数据库查询，并初始化缓存数据 数据变更时清除缓存数据 主体代码实现 //根据id查找用户 @Override public User selectById(int id) { // User user = userDao.selectById(id); // return user; //先去缓存中去user数据，如果没有的话就去数
redis实战(6):登录和cookie缓存
water Wang
03-13 945
1 检查会话 当我们登录互联网服务（比如银行账户或者电子邮件）的时候．这些服务都会使用cookie来记录我们的身份。cookie又少量数据组成，网站会要求我们的浏览器存储这些数据， 并在每次服务发送请求时将这些数据传回给服务。对于用来登录的cookie．有两种常见的方 法可以将登录信息存储在cookie里面：一种是签名（signed ) cookie，另一种是令牌（token) cookie。 签名cookie通常会存储用户名，可能还有用户ID、用户最后一次成功登录的时间．以及网 站觉得有用的其他任何信息除
Redis 实现验证码登录
Gettler的博客
01-31 2060
将获取到的user对象转为Map对象，并以随机字符串token为键存入redis中，再将token传回前端。使用正则表达式校验手机号，使用随机数工具生成六位数验证码，并将其存入redis中。编写配置文件将拦截器注册，并将StringRedisTemplate注入到容器中。编写一个拦截器，在发送请求后，刷新token在redis中所对应键值对的有效期。还有在访问需要登录才能访问的路径时的登录拦截器，统一判断是否有权限访问。在redis中获取以手机号为键的值，以此校验前端传回的验证码。
Redis学习3：使用Reids实现验证码校验功能
你来看我啦！
01-10 2443
Reids实现验证码校验功能 设计一个函数实现生成验证码功能 //生成6位数字验证码 public static String getCode(){ Random random=new Random(); String code=""; for(int i=0;i<6;i++){ int rand=random.nextInt(10); code+=rand; }
Redis使用验证码
m0_51505198的博客
11-03 1807
redis获取验证码 及 redisTemplate的通用配置
Redis实现短信验证码登录
weixin_46016309的博客
07-12 722
使用Redis实现短信验证登录功能
Redis缓存穿透，缓存击穿和缓存雪崩
12-14
二、缓存穿透，缓存击穿和缓存雪崩 缓存穿透 描述：缓存穿透是指缓存和数据库中都没有的数据，而用户不断发起请求，如发起为id为“-1024”的数据或id为特别大不存在的数据。这时的用户很可能是攻击者，攻击会导致...
什么是redis缓存穿透 雪崩 ,如何应对解决 redis缓存穿透 雪崩 的解决办法
01-07
什么是redis缓存穿透 雪崩 ,如何应对解决 redis缓存穿透 雪崩 的解决办法 redis缓存穿透的解决办法 redis雪崩的解决办法
Redis 缓存穿透、缓存击穿工具类资源
09-07
Redis 缓存穿透的处理（缓存空值） Redis缓存击穿处理（互斥锁与逻辑删除方案） 封装为工具类，并适用于所有需要进行缓存穿透、击穿的方案，采用了泛型以及Lambda 函数式编程来完成编码
如何解决Redis缓存雪崩、缓存穿透、缓存并发等5大难题.pdf
06-29
提供了解redis实践开过程中，所面对缓存雪崩 缓存穿透 缓存并发的处理方案，同时这些个问题也是面试的经典问题，有助提升开发者的知识视野
使用redis校验验证码
m0_61616629的博客
04-28 192
首先在linux中下载redis，要先有gcc环境，因为redis是基于c，而且gcc版本要高于5.3。进入默认安装路径/usr/local/bin redis-cli 连接redis。然后可以创建maven工程导入以来的jar包jedis或者使用普通的工程下载jar包。启动redis-server /etc/redis.conf(配置文件所在的目录)将配置文件daemonize对应的值改成yes，表示支持后台启动。redis默认安装到usr/local/bin。可以把生成验证码抽取成一个方法。
【项目实战】基于Redis实现短信验证码登录 (附源码、思路)
扎哇太枣糕的笔记博客
05-11 3943
  各位小伙伴们大家好，欢迎来到这个小扎扎的Redis 6专栏，在这个系列专栏中我对B站黑马的Redis教程进行一个总结，鉴于 看到就是学到、学到就是赚到 精神，这波依然是血赚 ┗|｀O′|┛
redis验证码
weixin_45318552的博客
10-14 408
redis验证码的实现 输入手机号，点击发送后随机生成6位数字码，3分钟有效 输入验证码，点击验证，返回成功或者失败 每个手机号每天只能输入3次 实现思路： 在0号数据库创建手机号，时间以及次数 我们在进行验证码发送的时候，首先考虑的是这个手机号是否存在 存在 —今日发送了几次了 大于3次 小于3次，生成验证码 不存在，就创建这个手机号 ，并且生成验证码 在1号数据库创建手机号，以及验证码 代码如下 index.jsp <%@ page contentType="text/html; char
使用Redis实现登录验证功能
weixin_62595121的博客
04-04 3179
首先启动redis 1 依赖 <!-- redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <dependency> <groupId>org.apach.
Spring-Data Redis 实现验证码的功能
jhq2904982765的博客
07-28 534
Redis是一个 Key-Value 存储系统。和 Memcached 类似，它支持存储的 value 类型相对更多，包括 string(字符串)、 list(链表)、 set(集合)和 zset(有序集合)。这些数据类型都支持 push/pop、add/remove 及取交集并集和差集及更丰富的操作，而且这些操作都是原子性的。在此基础上，Redis 支持各种不同方式的排序。与 memcached
redis的缓存穿透缓存击穿缓存雪崩
01-04
缓存穿透、缓存击穿和缓存雪崩是常见的缓存问题，下面是关于Redis的缓存穿透、缓存击穿和缓存雪崩的介绍： 1. 缓存穿透： 缓存穿透是指当一个请求查询一个不存在于缓存中的数据时，由于缓存无法命中，请求会直接...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值