• 设为首页
  • 收藏本站
  • 积分充值
  • VIP赞助
  • 手机版
  • 微博
  • 微信
    微信公众号 添加方式：
    1:搜索微信号（888888）
    2:扫描左侧二维码
  • 登录 立即注册
    • 切换风格
    快捷导航
    福建二哥 › 门户 › 查看主题

    基于Redis实现短信验证码登录功能

    发布者: 山止川行 | 发布时间: 2025-6-19 12:47| 查看数: 132| 评论数: 0|帖子模式

    1 基于Session实现短信验证码登录

    1.     /**
    2.      * 发送验证码
    3.      */
    4.     @Override
    5.     public Result sendCode(String phone, HttpSession session) {
    6.         // 1、判断手机号是否合法
    7.         if (RegexUtils.isPhoneInvalid(phone)) {
    8.             return Result.fail("手机号格式不正确");
    9.         }
    10.         // 2、手机号合法，生成验证码，并保存到Session中
    11.         String code = RandomUtil.randomNumbers(6);
    12.         session.setAttribute(SystemConstants.VERIFY_CODE, code);
    13.         // 3、发送验证码
    14.         log.info("验证码:{}", code);
    15.         return Result.ok();
    16.     }

    18.     /**
    19.      * 用户登录
    20.      */
    21.     @Override
    22.     public Result login(LoginFormDTO loginForm, HttpSession session) {
    23.         String phone = loginForm.getPhone();
    24.         String code = loginForm.getCode();
    25.         // 1、判断手机号是否合法
    26.         if (RegexUtils.isPhoneInvalid(phone)) {
    27.             return Result.fail("手机号格式不正确");
    28.         }
    29.         // 2、判断验证码是否正确
    30.         String sessionCode = (String) session.getAttribute(LOGIN_CODE);
    31.         if (code == null || !code.equals(sessionCode)) {
    32.             return Result.fail("验证码不正确");
    33.         }
    34.         // 3、判断手机号是否是已存在的用户
    35.         User user = this.getOne(new LambdaQueryWrapper<User>()
    36.                 .eq(User::getPassword, phone));
    37.         if (Objects.isNull(user)) {
    38.             // 用户不存在，需要注册
    39.             user = createUserWithPhone(phone);
    40.         }
    41.         // 4、保存用户信息到Session中，便于后面逻辑的判断（比如登录判断、随时取用户信息，减少对数据库的查询）
    42.         session.setAttribute(LOGIN_USER, user);
    43.         return Result.ok();
    44.     }

    46.     /**
    47.      * 根据手机号创建用户
    48.      */
    49.     private User createUserWithPhone(String phone) {
    50.         User user = new User();
    51.         user.setPhone(phone);
    52.         user.setNickName(SystemConstants.USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
    53.         this.save(user);
    54.         return user;
    55.     }
    复制代码
    2 配置登录拦截器

    1. public class LoginInterceptor implements HandlerInterceptor {
    2.     /**
    3.      * 前置拦截器，用于判断用户是否登录
    4.      */
    5.     @Override
    6.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    7.         HttpSession session = request.getSession();
    8.         // 1、判断用户是否存在
    9.         User user = (User) session.getAttribute(LOGIN_USER);
    10.         if (Objects.isNull(user)){
    11.             // 用户不存在，直接拦截
    12.             response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
    13.             return false;
    14.         }
    15.         // 2、用户存在，则将用户信息保存到ThreadLocal中，方便后续逻辑处理
    16.         // 比如：方便获取和使用用户信息，session获取用户信息是具有侵入性的
    17.         ThreadLocalUtls.saveUser(user);

    19.         return HandlerInterceptor.super.preHandle(request, response, handler);
    20.     }
    21. }
    复制代码
    3 配置完拦截器还需将自定义拦截器添加到SpringMVC的拦截器列表中 才能生效
    1. @Configuration
    2. public class WebMvcConfig implements WebMvcConfigurer {

    4.     @Override
    5.     public void addInterceptors(InterceptorRegistry registry) {
    6.         // 添加登录拦截器
    7.         registry.addInterceptor(new LoginInterceptor())
    8.                 // 设置放行请求
    9.                 .excludePathPatterns(
    10.                         "/user/code",
    11.                         "/user/login",
    12.                         "/blog/hot",
    13.                         "/shop/**",
    14.                         "/shop-type/**",
    15.                         "/upload/**",
    16.                         "/voucher/**"
    17.                 );
    18.     }
    19. }
    复制代码
    4 Session集群共享问题

    （1）什么是Session集群共享问题？
    1. 在分布式集群环境中，会话（Session）共享是一个常见的挑战。默认情况下，Web 应用程序的会话是保存在单个服务器上的，当请求不经过该服务器时，会话信息无法被访问。
    复制代码
    （2） Session集群共享问题造成哪些问题？
    1.  服务器之间无法实现会话状态的共享。比如：在当前这个服务器上用户已经完成了登录，Session中存储了用户的信息，能够判断用户已登录，但是在另一个服务器的Session中没有用户信息，无法调用显示没有登录的服务器上的服务
    复制代码
    （3）如何解决Session集群共享问题？
    方案一：Session拷贝（不推荐）
    Tomcat提供了Session拷贝功能，通过配置Tomcat可以实现Session的拷贝，但是这会增加服务器的额外内存开销，同时会带来数据一致性问题
    方案二：Redis缓存（推荐）
    Redis缓存具有Session存储一样的特点，基于内存、存储结构可以是key-value结构、数据共享
    （4）Redis缓存相较于传统Session存储的优点
    1 高性能和可伸缩性：Redis 是一个内存数据库，具有快速的读写能力。相比于传统的 Session 存储方式，将会话数据存储在 Redis 中可以大大提高读写速度和处理能力。此外，Redis 还支持集群和分片技术，可以实现水平扩展，处理大规模的并发请求。
    2 可靠性和持久性：Redis 提供了持久化机制，可以将内存中的数据定期或异步地写入磁盘，以保证数据的持久性。这样即使发生服务器崩溃或重启，会话数据也可以被恢复。
    3 丰富的数据结构：Redis 不仅仅是一个键值存储数据库，它还支持多种数据结构，如字符串、列表、哈希、集合和有序集合等。这些数据结构的灵活性使得可以更方便地存储和操作复杂的会话数据。
    4 分布式缓存功能：Redis 作为一个高效的缓存解决方案，可以用于缓存会话数据，减轻后端服务器的负载。与传统的 Session 存储方式相比，使用 Redis 缓存会话数据可以大幅提高系统的性能和可扩展性。
    5 可用性和可部署性：Redis 是一个强大而成熟的开源工具，有丰富的社区支持和活跃的开发者社区。它可以轻松地与各种编程语言和框架集成，并且可以在多个操作系统上运行。
    PS：但是Redis费钱，而且增加了系统的复杂度

    5 基于Redis实现短信验证码登录



    6 Hash 结构与 String 结构类型的比较


    • String 数据结构是以 JSON 字符串的形式保存，更加直观，操作也更加简单，但是 JSON 结构会有很多非必须的内存开销，比如双引号、大括号，内存占用比 Hash 更高
    • Hash 数据结构是以 Hash 表的形式保存，可以对单个字段进行CRUD，更加灵活

    7 Redis替代Session需要考虑的问题

    （1）选择合适的数据结构，了解 Hash 比 String 的区别
    （2）选择合适的key，为key设置一个业务前缀，方便区分和分组，为key拼接一个UUID，避免key冲突防止数据覆盖
    （3）选择合适的存储粒度，对于验证码这类数据，一般设置TTL为3min即可，防止大量缓存数据的堆积，而对于用户信息这类数据可以稍微设置长一点，比如30min，防止频繁对Redis进行IO操作

    8 基于redis短信验证登录
    1.     /**
    2.      * 发送验证码
    3.      *
    4.      * @param phone
    5.      * @param session
    6.      * @return
    7.      */
    8.     @Override
    9.     public Result sendCode(String phone, HttpSession session) {
    10.         // 1、判断手机号是否合法
    11.         if (RegexUtils.isPhoneInvalid(phone)) {
    12.             return Result.fail("手机号格式不正确");
    13.         }
    14.         // 2、手机号合法，生成验证码，并保存到Redis中
    15.         String code = RandomUtil.randomNumbers(6);
    16.         stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code,
    17.                 RedisConstants.LOGIN_CODE_TTL, TimeUnit.MINUTES);
    18.         // 3、发送验证码
    19.         log.info("验证码:{}", code);
    20.         return Result.ok();
    21.     }

    23.     /**
    24.      * 用户登录
    25.      *
    26.      * @param loginForm
    27.      * @param session
    28.      * @return
    29.      */
    30.     @Override
    31.     public Result login(LoginFormDTO loginForm, HttpSession session) {
    32.         String phone = loginForm.getPhone();
    33.         String code = loginForm.getCode();
    34.         // 1、判断手机号是否合法
    35.         if (RegexUtils.isPhoneInvalid(phone)) {
    36.             return Result.fail("手机号格式不正确");
    37.         }
    38.         // 2、判断验证码是否正确
    39.         String redisCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
    40.         if (code == null || !code.equals(redisCode)) {
    41.             return Result.fail("验证码不正确");
    42.         }
    43.         // 3、判断手机号是否是已存在的用户
    44.         User user = this.getOne(new LambdaQueryWrapper<User>()
    45.                 .eq(User::getPhone, phone));
    46.         if (Objects.isNull(user)) {
    47.             // 用户不存在，需要注册
    48.             user = createUserWithPhone(phone);
    49.         }
    50.         // 4、保存用户信息到Redis中，便于后面逻辑的判断（比如登录判断、随时取用户信息，减少对数据库的查询）
    51.         UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
    52.         // 将对象中字段全部转成string类型，StringRedisTemplate只能存字符串类型的数据
    53.         Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
    54.                 CopyOptions.create().setIgnoreNullValue(true).
    55.                         setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
    56.         String token = UUID.randomUUID().toString(true);
    57.         String tokenKey = LOGIN_USER_KEY + token;
    58.         stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
    59.         stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

    61.         return Result.ok(token);
    62.     }

    64.     /**
    65.      * 根据手机号创建用户并保存
    66.      *
    67.      * @param phone
    68.      * @return
    69.      */
    70.     private User createUserWithPhone(String phone) {
    71.         User user = new User();
    72.         user.setPhone(phone);
    73.         user.setNickName(SystemConstants.USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
    74.         this.save(user);
    75.         return user;
    76.     }
    复制代码
    9 配置登录拦截器


    单独配置一个拦截器用户刷新Redis中的token：在基于Session实现短信验证码登录时，我们只配置了一个拦截器，这里需要另外再配置一个拦截器专门用于刷新存入Redis中的 token，因为我们现在改用Redis了，为了防止用户在操作网站时突然由于Redis中的 token 过期，导致直接退出网站，严重影响用户体验。那为什么不把刷新的操作放到一个拦截器中呢，因为之前的那个拦截器只是用来拦截一些需要进行登录校验的请求，对于哪些不需要登录校验的请求是不会走拦截器的，刷新操作显然是要针对所有请求比较合理，所以单独创建一个拦截器拦截一切请求，刷新Redis中的Key
    登录拦截器：
    1. public class LoginInterceptor implements HandlerInterceptor {

    3.     /**
    4.      * 前置拦截器，用于判断用户是否登录
    5.      */
    6.     @Override
    7.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    8.         // 判断当前用户是否已登录
    9.         if (ThreadLocalUtls.getUser() == null){
    10.             // 当前用户未登录，直接拦截
    11.             response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
    12.             return false;
    13.         }
    14.         // 用户存在，直接放行
    15.         return true;
    16.     }
    17. }
    复制代码
    刷新token的拦截器
    1. public class RefreshTokenInterceptor implements HandlerInterceptor {

    3.     // new出来的对象是无法直接注入IOC容器的（LoginInterceptor是直接new出来的）
    4.     // 所以这里需要再配置类中注入，然后通过构造器传入到当前类中
    5.     private StringRedisTemplate stringRedisTemplate;

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

    11.     @Override
    12.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    13.         // 1、获取token，并判断token是否存在
    14.         String token = request.getHeader("authorization");
    15.         if (StrUtil.isBlank(token)){
    16.             // token不存在，说明当前用户未登录，不需要刷新直接放行
    17.             return true;
    18.         }
    19.         // 2、判断用户是否存在
    20.         String tokenKey = LOGIN_USER_KEY + token;
    21.         Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(tokenKey);
    22.         if (userMap.isEmpty()){
    23.             // 用户不存在，说明当前用户未登录，不需要刷新直接放行
    24.             return true;
    25.         }
    26.         // 3、用户存在，则将用户信息保存到ThreadLocal中，方便后续逻辑处理，比如：方便获取和使用用户信息，Redis获取用户信息是具有侵入性的
    27.         UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
    28.         ThreadLocalUtls.saveUser(BeanUtil.copyProperties(userMap, UserDTO.class));
    29.         // 4、刷新token有效期
    30.         stringRedisTemplate.expire(token, LOGIN_USER_TTL, TimeUnit.MINUTES);
    31.         return true;
    32.     }
    33. }
    复制代码
    将自定义的拦截器添加到SpringMVC的拦截器表中，使其生效：
    1. @Configuration
    2. public class WebMvcConfig implements WebMvcConfigurer {

    4.     // new出来的对象是无法直接注入IOC容器的（LoginInterceptor是直接new出来的）
    5.     // 所以这里需要再配置类中注入，然后通过构造器传入到当前类中
    6.     @Resource
    7.     private StringRedisTemplate stringRedisTemplate;

    9.     @Override
    10.     public void addInterceptors(InterceptorRegistry registry) {
    11.         // 添加登录拦截器
    12.         registry.addInterceptor(new LoginInterceptor())
    13.                 // 设置放行请求
    14.                 .excludePathPatterns(
    15.                         "/user/code",
    16.                         "/user/login",
    17.                         "/blog/hot",
    18.                         "/shop/**",
    19.                         "/shop-type/**",
    20.                         "/upload/**",
    21.                         "/voucher/**"
    22.                 ).order(1); // 优先级默认都是0，值越大优先级越低
    23.         // 添加刷新token的拦截器
    24.         registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    25.     }
    26. }
    复制代码

      1. RefreshTokenInterceptor
      复制代码
      先执行，主要用来检查 token 的有效性并刷新 token 的有效期，同时将用户信息存入
      1. ThreadLocal
      复制代码
      。
      1. LoginInterceptor
      复制代码
      后执行，验证
      1. ThreadLocal
      复制代码
      中是否有用户信息，以确认用户是否登录。
    以上就是基于Redis实现短信验证码登录功能的详细内容，更多关于Redis短信验证码登录的资料请关注脚本之家其它相关文章！

    来源：https://www.jb51.net/database/334667jv0.htm
    免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

    本帖子中包含更多资源

    您需要 登录 才可以下载或查看，没有账号？立即注册

    ×

    最新评论

    浏览过的版块

    新人须知

    常见问题

    维权申诉

    关注微博

    扫描微信

    关于合作

    通讯联系

    QQ Archiver 手机版 小黑屋 福建二哥 ( 闽ICP备2022004717号|闽公网安备35052402000345号 )

    Powered by Discuz! X3.5 © 2001-2023

    快速回复 返回顶部 返回列表