Redis实战

最新推荐文章于 2024-09-07 19:36:01 发布
最新推荐文章于 2024-09-07 19:36:01 发布
阅读量1.1k 收藏 17
点赞数 19
文章标签： redis 数据库 缓存
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_61702109/article/details/140797833
版权

短信登录功能

发送短信验证码实现流程

  1. 提交手机号
  2. 校验手机号
  3. 生成验证码，并保存
  4. 保存验证码到redis
  5. 发送验证码
    @Override
    public Result sendCode(String phone) {
        //校验手机号
        if(RegexUtils.isPhoneInvalid(phone)){
            return Result.fail(UserErrorConstant.PHONE_FORMAT_ERROR);
        }
        //生成验证码
        String code = RandomUtil.randomNumbers(6);

        //保存验证码(有效期:5min)
        stringRedisTemplate.opsForValue().set(RedisConstants.LOGIN_CODE_KEY +phone,code,RedisConstants.CACHE_SHOP_TTL, TimeUnit.MINUTES);

        //发送验证码
        log.debug("发送短信验证码成功，验证码:{}",code);

        return Result.ok();
    }

短信验证码登录注册实现流程

  1. 提交手机号和验证码
  2. 验证验证码
  3. 根据手机号查询用户
  4. 用户是否存在（如果不存在创建新用户并保存用户到数据库）
  5. 保存用户到redis
    @Override
    public Result loginByCode(LoginFormDTO loginFormDTO) {
        //校验手机号
        String phone = loginFormDTO.getPhone();
        if(RegexUtils.isPhoneInvalid(phone)){
            return Result.fail(UserErrorConstant.PHONE_FORMAT_ERROR);
        }

        //从redis获取验证码并验证
        String cacheCode = stringRedisTemplate.opsForValue().get(RedisConstants.LOGIN_CODE_KEY+phone);
        String code = loginFormDTO.getCode();
        if(cacheCode==null||!cacheCode.equals(code)){
            return Result.fail(UserErrorConstant.VERIFICATION_CODE_ERROR);
        }

        //根据手机号查询用户
        User user = query().eq("mobile",phone).one();

        //判断用户是否存在
        if(user==null){
            user = createUserWithPhone(phone);
        }

        //使用jwt令牌
        String token = UUID.randomUUID().toString();

        //将user对象转成HashMap存储(由于使用的是stringRedisTemplate，所以要把id转为string）
        UserDTO userDTO = BeanUtil.copyProperties(user,UserDTO.class);
        userDTO.setToken(token);
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
                CopyOptions.create().setIgnoreNullValue(true).setFieldValueEditor((fieldName, fieldValue) -> fieldValue == null ? "" : fieldValue.toString()));

        stringRedisTemplate.opsForHash().putAll(RedisConstants.LOGIN_USER_KEY+token,userMap);
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY+token,RedisConstants.LOGIN_USER_TTL,TimeUnit.HOURS);

        //返回token
        return Result.ok(userDTO);
    }

校验登录状态实现流程

  1. 请求并携带cookie
  2. 从redis获取用户
  3. 判断用户是否存在（如果不存在则拦截）
  4. 如果存在则保存用户到threadlocal
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       
        //从请求头中获取token
        String token = request.getHeader("authorization");
        if (StringUtils.isEmpty(token)) {
            //不存在token
            return true;
        }
        //从redis中获取用户
        Map<Object, Object> userMap =
                stringRedisTemplate.opsForHash()
                        .entries(RedisConstants.LOGIN_USER_KEY + token);
        //用户不存在
        if (userMap.isEmpty()) {
            return true;
        }
        //hash转UserDTO存入ThreadLocal
        UserHolder.saveUser(BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false));
        //token续命
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        return true;
    }

缓存功能

缓存就是数据交换的缓冲区(Cache),是存储数据的临时地方,一般读写性能较高。

作用：

  • 降低后端负载。
  • 提高读写效率，降低响应时间。（解决高并发问题）

成本：

  • 数据一致性成本
  • 代码维护成本（缓存击穿）
  • 运维成本

缓存更新策略

内存淘汰：利用redis的内存淘汰机制，内存不足时自动淘汰部分数据。

超时剔除：添加ttl时间，到期自动删除缓存（兜底）。

主动更新：在修改数据库的同时，更新缓存。

  1. 方案1：由缓存的调用者，在更新数据库的同时更新缓存。
  2. 方案2：缓存与数据库整合为一个服务，由服务来维护一致性。
  3. 方案3：调用者只操作缓存，由其他线程异步的将缓存数据持久化到数据库，保证最终一致。
如何保证缓存与数据库的操作的同时成功或失败（原子操作问题）？
  • 单体系统，将缓存与数据库操作放在一个事务。
  • 分布式系统，利用tcc等分布式事务方案。
先操作缓存还是先操作数据库（线程安全）？

先操作数据库再删除缓存的操作更保险，因为数据库的操作时间一般要比缓存慢。

缓存穿透

缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，这样缓存永远不会生效，这些请求都会达到数据库。

缓存空对象（被动方案）

优点：实现简单，维护方便

缺点：额外的内存消耗（缓存垃圾，设置ttl删除）、可能造成短期的不一致（插入时更新缓存）

布隆过滤（被动方案）

在客户端和redis之间加入布隆过滤器，如果不存在则拒绝，存在则放行。（用byte数组存储，hashcode二进制hash对应位置，若为1存在，若为0不存在）

优点：内存占用少，没有多余key

缺点：实现复杂，存在误判可能

主动方案
  • 增加id的复杂度，避免被猜测id规律（雪花算法）
  • 做好数据的基础格式校验
  • 加强用户权限校验
  • 做好热点参数的限流
    /**
     * 缓存穿透
     * @param id
     * @return
     */
    public Result queryWithPassThrough(int id){
        String key = RedisConstants.CACHE_SHOP_KEY+id;
        //从redis查询企业用户信息缓存
        String userJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if(StrUtil.isNotBlank(userJson)){
            User user = JSONUtil.toBean(userJson,User.class);
            return Result.ok(user);
        }
        //判断命中的是否是空值
        if(userJson!=null){
            //返回错误信息
            return Result.fail(UserErrorConstant.USER_NOEXIST_ERROR);
        }

        //不存在，根据id查询数据库
        User user = userMapper.queryUserById(id);
        //不存在，返回错误
        if(user==null){
            //缓存穿透-》将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            return Result.fail(UserErrorConstant.USER_NOEXIST_ERROR);
        }
        //存储到redis中,设置了超时时间
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(user),RedisConstants.CACHE_SHOP_TTL,TimeUnit.HOURS);

        return Result.ok(user);
    }

缓存雪崩

缓存雪崩是指同一时段大量的缓存key同时失效或者redis服务宕机，导致大量请求到达数据库，带来巨大压力。

解决方案
  • 给不同的key的ttl添加随机值（同一时间段大量key失效，有时候在做缓存的预热时会在同一时间批量的数据导入）
  • 利用redis集群提高服务的可用性（主宕机，从结点上还有数据）
  • 给缓存业务添加降级限流策略（提前做好服务降级，比如快速失败拒绝服务）
  • 给业务添加多级缓存

缓存击穿

缓存击穿问题也叫热点key问题，就是一个被高并发访问并且缓存重建业务较复杂的key突然失效了，无数的请求访问会在瞬间给数据库带来巨大的冲击。（无数请求缓存重建）

解决方案

互斥锁

未命中需要获取锁才能查询数据库重建缓存数据，写入缓存后再释放锁。

优点：没有额外内存消耗，保证数据的一致性，实现简单。

缺点：线程需要等待，性能受影响，可能有死锁风险。

    /**
     * 缓存击穿->互斥锁
     * @param id
     * @return
     */
    public Result queryWithPassMutex(int id)  {
        String key = RedisConstants.CACHE_SHOP_KEY+id;
        //从redis查询企业用户信息缓存
        String userJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if(StrUtil.isNotBlank(userJson)){
            User user = JSONUtil.toBean(userJson,User.class);
            return Result.ok(user);
        }
        //判断命中的是否是空值
        if(userJson!=null){
            //返回错误信息
            return Result.fail(UserErrorConstant.USER_NOEXIST_ERROR);
        }

        //缓存重建
        String lockKey = RedisConstants.LOCK_SHOP_KEY+id;
        User user =null;
        try {
            boolean isLock = tryLock(lockKey);
            if(!isLock){
                Thread.sleep(50);
                //风险！改成while（true）轮询就好
                return queryWithPassMutex(id);
            }
            //不存在，根据id查询数据库
            user = userMapper.queryUserById(id);
            //不存在，返回错误
            if(user==null){
                //缓存穿透-》将空值写入redis
                stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
                return Result.fail(UserErrorConstant.USER_NOEXIST_ERROR);
            }
            //存储到redis中,设置了超时时间
            stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(user),RedisConstants.CACHE_SHOP_TTL,TimeUnit.HOURS);
        } catch (InterruptedException e){
            throw new RuntimeException(e);
        } finally {
            //释放互斥锁
            unlock(lockKey);
        }

        return Result.ok(user);
    }
逻辑过期

发现逻辑时间已过期，未命中获取互斥锁，返回过期数据，开启新线程去做缓存重建并释放锁，如果有新线程来的时候还是会返回新数据。

优点：线程无需等待，性能较好。

缺点：不保证一致性，有额外内存消耗，实现复杂。

    /**
     * 缓存穿透
     * @param id
     * @return
     */
    public Result queryWithPassThrough(int id){
        String key = RedisConstants.CACHE_SHOP_KEY+id;
        //从redis查询企业用户信息缓存
        String userJson = stringRedisTemplate.opsForValue().get(key);
        //判断是否存在
        if(StrUtil.isNotBlank(userJson)){
            User user = JSONUtil.toBean(userJson,User.class);
            return Result.ok(user);
        }
        //判断命中的是否是空值
        if(userJson!=null){
            //返回错误信息
            return Result.fail(UserErrorConstant.USER_NOEXIST_ERROR);
        }

        //不存在，根据id查询数据库
        User user = userMapper.queryUserById(id);
        //不存在，返回错误
        if(user==null){
            //缓存穿透-》将空值写入redis
            stringRedisTemplate.opsForValue().set(key,"",RedisConstants.CACHE_NULL_TTL,TimeUnit.MINUTES);
            return Result.fail(UserErrorConstant.USER_NOEXIST_ERROR);
        }
        //存储到redis中,设置了超时时间
        stringRedisTemplate.opsForValue().set(key,JSONUtil.toJsonStr(user),RedisConstants.CACHE_SHOP_TTL,TimeUnit.HOURS);

        return Result.ok(user);
    }

No.Ada
关注
  • 19
    点赞
  • 踩
  • 17
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
Redis 实战
qq_34218330的博客
10-21 133
1.单数据源 (1)pom.xml <?xml version="1.0" encoding="UTF-8"?> <project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schem...
redis实战
laomumu1992的博客
02-26 304
分布式锁的实现 关于锁，其实我们或多或少都有接触过一些，比如synchronized、 Lock这些，这类锁的目的很简单，在多线程环 境下，对共享资源的访问造成的线程安全问题，通过锁的机制来实现资源访问互斥。那么什么是分布式锁呢?或者 为什么我们需要通过Redis来构建分布式锁，其实最根本原因就是Score(范围)，因为在分布式架构中，所有的应 用都是进程隔离的，在多进程访问共享资源的...
Redis实战：缓存穿透及其解决思路 实战演示
热门推荐
终于等到你啦~欢迎来到我的知识空间 这里是苏泽的成神之路
03-21 3万+
缓存穿透是指客户端请求的数据在缓存中和数据库中都不存在，导致每次请求都要访问数据库，增加数据库的负载。为了解决缓存穿透问题
Redis实战案例
weixin_36531037的博客
04-07 2054
Redis实战案例
Redis实战.pdf
11-17
**Redis实战.pdf** Redis，全称Remote Dictionary Server，是一款开源的、高性能的键值存储系统。它被设计为一个内存数据库，支持多种数据结构，如字符串、哈希、列表、集合和有序集合，同时提供了持久化功能，确保...
Redis实战Redis实战
12-24
《Redis实战》这本书深入浅出地探讨了Redis这一高性能、键值存储系统在实际应用中的各种技巧和策略。Redis作为一款内存数据结构存储系统，因其快速的数据读写能力，广泛应用于缓存、消息队列、计数器以及分布式锁等...
【苍穹外卖】Day 5 Redis、店铺营业状态接口
Yudiannann的博客
09-03 864
Redis是一个基于的 key-value 结构数据库运行在cmd下启动状态下，再测试：也可以在配置文件设置密码（4位密码不行）改为6位然后发现已经需要密码需要简化：安装管理客户端（但是需要先启动redis）
Redis 实现原理或机制
Flying_Fish_roe的博客
09-07 702
Redis 的高性能、高可用性和灵活性来自其精巧的实现原理和机制。通过高效的内存管理、灵活的数据结构、强大的持久化机制、主从复制和集群功能，Redis 能够满足各种复杂的应用场景需求。无论是在缓存、会话管理、还是分布式存储领域，Redis 都能够提供卓越的性能和稳定性。
Redis的incr命令引发的反序列化异常和ERR value is not an integer or out of range异常
m0_61891910的博客
09-03 477
在Java中使用inc命令的时候发现redis中的值被反序列化后居然不是数字,检查后发现可能是序列化器没对,在redis配置的地方将序列化器设置为。Jackson2JsonRedisSerializer后使用整成,贴上代码。
Redis 篇-深入了解基于 Redis 实现分布式锁（解决多线程安全问题、锁误删问题和确保锁的原子性问题）
小扳手
09-07 833
假设线程一正常获取锁之后，执行任务，但是该任务出现了阻塞情况，等待的时间较久，此时当锁到过期时间之后，就会自动被释放了，当时此时线程一还不知道当前锁被释放了，就在这时候，线程二来正常的获取锁，因为锁已经被释放了，所以线程二是可以获取锁成功的，接着，线程二获取锁之后，就开始执行任务了，此刻线程一任务执行完之后，会直接释放锁，这就出现线程一误删了线程二的锁问题。为了解决 Redis 分布式锁被误删的问题，可以想到的办法是：在释放锁之前，判断当前的锁 “是否” 是自己之前获取的锁，如果是，则可以直接释放锁；
Redis两种类型分区
Flying_Fish_roe的博客
09-07 638
水平分区，也称为Sharding，是最常见的 Redis 分区方法。这种分区方法的核心思想是将 Redis 的**键值对（key-value pairs）**按照一定的规则（例如哈希函数）分散到不同的 Redis 节点上。每个 Redis 实例保存数据集的一个子集，而不是整个数据集。通过这种方式，Redis 集群可以存储和管理更多数据，并且能够更好地处理高并发请求。垂直分区（Vertical Partitioning），又称为功能分区，是一种根据数据的不同功能或逻辑，将数据拆分到不同的 Redis 实例上。
如何在在Java中操作Redis
几许的博客
09-07 923
前面我们讲解了Redis的常用命令，这些命令是我们操作Redis的基础，那么我们在java程序中应该如何操作Redis呢？这就需要使用Redis的Java客户端，就如同我们使用JDBC操作MySQL数据库一样。JedisLettuceRedissonSpring 对 Redis 客户端进行了整合，提供了 Spring Data Redis，在Spring Boot项目中还提供了对应的Starter，即 spring-boot-starter-data-redis。
Redis发布订阅PUB/SUB
OceanSky的专栏
09-02 496
Redis发布订阅PUB/SUB是一种消息通信模式，发送者PUB发送消息，订阅者SUB接收消息。Redis客户端可以订阅任意数量的频道，一个通道CHANNEL可以被多个客户端订阅，当一条消息发送到CHANNEL中去后所有订阅的客户端都会接收到此消息。
redis之zset命令学习
青青子衿
09-04 295
zset是一个不包含重复元素的字符串集合，且每个元素都会关联一个 double 类型的分数（score）。这使得有序集合既可以通过成员（member）来查询，也可以通过分数（score）来排序。以下是zset的一些简单命令。
Redis-主从集群
最新发布
weixin_64133130的博客
09-07 573
因为slave原本也是一个master，有自己的replid和offset，（宕机重启后）当第一次变成slave，与master建立连接时，发送的replid和offset是自己的replid和offset。如果slave的offset小于master的offset，说明slave数据落后于master，需要更新。如果master继续写入新数据，其offset就会覆盖旧的数据，直到将slave现在的offset也覆盖，注意此时master已经覆盖了从节点尚未同步过去的数据，这就出现了主从之间数据的不一致。
Redis常见面试问题
青山猿的博客
09-07 797
②考虑线程安全问题：如果此时刚好缓存key过期等其他问题导致缓存失效了，当有线程去查询缓存肯定是未命中然后去查数据库，然后另一个线程刚好在更新数据库，紧接着删除了缓存然后主线程才做的写入缓存操作，也会导致缓存与数据库不一致。高并发条件下，对于热点数据（一般地，80%的情况下都是访问某些热点数据，也就是访问某些热点key，其他key访问会比较少），当数据失效的一瞬间，或者刚开始时缓存中还没有对热点数据进行缓存，所有请求都被发送到数据库去查询，数据库被压垮；缺点：缓存的热点数据是静态的，得不到更新；
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值