瑞_Redis_短信登录

文章目录

- 项目介绍
- 1 短信登录
- - 1.1 项目准备
  - - 1.1.1 导入SQL
    - 1.1.2 导入后端项目
    - 1.1.3 导入前端项目
  - 1.2 基于Session实现登录流程
  - - 1.2.1 功能流程介绍
    - - 1.2.1.1 发送短信验证码
      - 1.2.1.2 短信验证码登录、注册
      - 1.2.1.3 校验登录状态
    - 1.2.2 实现发送短信验证码功能
    - - 1.2.2.1 页面流程
      - 1.2.2.2 代码实现
      - 1.2.2.3 测试
    - 1.2.3 实现短信验证码登录、注册功能
    - - 1.2.3.1 页面流程
      - 1.2.3.2 代码实现
      - 1.2.3.3 测试
    - 1.2.4 实现校验登录状态功能
    - - 1.2.4.1 实现逻辑
      - 1.2.4.2 代码实现
      - 1.2.4.3 测试
    - 1.2.5 集群的session共享问题
    - 1.2.6 代码资源
  - 1.3 Redis代替session的业务流程
  - - 1.3.1 设计key的结构
    - 1.3.2 设计key的具体细节
    - 1.3.3 整体访问流程
    - 1.3.4 Redis实现发送短信验证码功能
    - 1.3.5 Redis实现短信验证码登录、注册、校验登录状态功能
    - 1.3.6 测试
    - 1.3.7 登录拦截器的优化
    - - 1.3.7.1 当前登录拦截器逻辑
      - 1.3.7.2 改进
      - 1.3.7.3 代码实现
      - 1.3.7.4 测试
    - 1.3.8 代码资源

🙊 前言：本文章为瑞_系列专栏之《Redis》的实战篇的短信登录章节。由于博主是从B站黑马程序员的《Redis》学习其相关知识，所以本系列专栏主要是针对该课程进行笔记总结和拓展，文中的部分原理及图解等也是来源于黑马提供的资料，特此注明。本文仅供大家交流、学习及研究使用，禁止用于商业用途，违者必究！

主机操作系统：Windows10
VMware版本： VMware Workstation 16.2.4
Linux版本：CentOS 7 64位
远程连接工具：MobaXterm_Personal_23.2
Redis版本：redis-6.2.6.tar.gz
Redis客户端：resp-2022.2.0.0
MySQL版本：8.0.29（5.7+均可）
Navicat Premium：15.0.28
JDK：1.8

相关链接：《瑞_VMware虚拟机安装Linux纯净版(含卸载，图文超详细)》
相关链接：《瑞_Redis_初识Redis（含安装教程）》
相关链接：《瑞_Redis_Redis客户端》
相关链接：《瑞_Redis_Redis命令》
相关链接：《瑞_Redis_Redis的Java客户端》

瑞&3l

项目介绍

本文基于B站黑马程序员的《黑马点评》项目进行学习笔记总结和拓展，项目的相关资源和课程视频可以到B站获取。
博主提供的该项目的相关资源的某度网盘链接：https://pan.baidu.com/s/1N-yr86yTRi3LbQdAL7prEQ?pwd=q0ry

本项目具有以下功能点，本文为《短信登录》篇

在这里插入图片描述

短信登录
这一块我们会使用redis共享session来实现
商户查询缓存
通过本章节，我们会理解缓存击穿，缓存穿透，缓存雪崩等问题，让小伙伴的对于这些概念的理解不仅仅是停留在概念上，更是能在代码中看到对应的内容
优惠卷秒杀
通过本章节，我们可以学会Redis的计数器功能，结合Lua完成高性能的redis操作，同时学会Redis分布式锁的原理，包括Redis的三种消息队列
附近的商户
我们利用Redis的GEOHash来完成对于地理坐标的操作
UV统计
主要是使用Redis来完成统计功能
用户签到
使用Redis的BitMap数据统计功能
好友关注
基于Set集合的关注、取消关注，共同关注等等功能，这一块知识咱们之前就讲过，这次我们在项目中来使用一下
达人探店
基于List来完成点赞列表的操作，同时基于SortedSet来完成点赞的排行榜功能

由于该项目主要是为了学习Redis，所以不会设计为微服务架构，简化代码复杂度，所以采用前后端分离的单体架构

说明

手机或者app端发起请求，请求我们的nginx服务器，nginx基于七层模型走的事HTTP协议，可以实现基于Lua直接绕开tomcat访问redis，也可以作为静态资源服务器，轻松扛下上万并发，负载均衡到下游tomcat服务器，打散流量，我们都知道一台4核8G的tomcat，在优化和处理简单业务的加持下，大不了就处理1000左右的并发，经过nginx的负载均衡分流后，利用集群支撑起整个项目，同时nginx在部署了前端项目后，更是可以做到动静分离，进一步降低tomcat服务的压力，这些功能都得靠nginx起作用，所以nginx是整个项目中重要的一环。

在 tomcat 支撑起并发流量后，我们如果让 tomcat 直接去访问 Mysql ，根据经验 Mysql 企业级服务器只要上点并发，一般是16或32 核心cpu，32 或64G内存，像企业级mysql加上固态硬盘能够支撑的并发，大概就是4000起~7000左右，上万并发，瞬间就会让Mysql服务器的cpu，硬盘全部打满，容易崩溃，所以我们在高并发场景下，会选择使用mysql集群，同时为了进一步降低Mysql的压力，同时增加访问的性能，我们也会加入Redis，同时使用Redis集群使得Redis对外提供更好的服务。

在这里插入图片描述

1 短信登录

1.1 项目准备

1.1.1 导入SQL

瑞：注意要使用至少 5.7+ 的MySQL版本，否则会报错。博主使用的是8.0.29

在这里插入图片描述

瑞：刷新数据库之后如果没有hmdp数据库，那就新建数据库，名字为hmdp，再把hmdp.sql文件拖拽到该数据库中加载，成功导入SQL文件后如下图所示

在这里插入图片描述

tb_user：用户表
tb_user_info：用户详情表
tb_shop：商户信息表
tb_shop_type：商户类型表
tb_blog：用户日记表（达人探店日记）
tb_follow：用户关注表
tb_voucher：优惠券表
tb_voucher_order：优惠券的订单表

1.1.2 导入后端项目

在资料中提供了一个项目源码 [hm-dianping.zip] 文件，将其解压到目录后用 idea 打开（要确保该目录中不包含中文、特殊字符和空格）

注意application.yaml文件中不要忘记修改配置，尤其是MySQL和Redis的账户密码，服务IP等信息

在这里插入图片描述

server:
  # 服务器端口号
  port: 8081
spring:
  application:
    # 应用名称
    name: hmdp
  datasource:
    # 数据库驱动类名，如果是版本5的MySQL请修改为com.mysql.jdbc.Driver
    driver-class-name: com.mysql.cj.jdbc.Driver
    # 数据库连接URL
    url: jdbc:mysql://127.0.0.1:3306/hmdp?useSSL=false&serverTimezone=UTC
    # 数据库用户名
    username: root
    # 数据库密码
    password: 123456
  redis:
    # Redis主机地址
    host: 192.168.13.128
    # Redis端口号
    port: 6379
    # Redis密码
    password: 123456
    lettuce:
      pool:
        # 最大活跃连接数
        max-active: 10
        # 最大空闲连接数
        max-idle: 10
        # 最小空闲连接数
        min-idle: 1
        # 连接回收时间间隔
        time-between-eviction-runs: 10s
  jackson:
    # JSON处理时忽略非空字段
    default-property-inclusion: non_null
mybatis-plus:
  # 别名扫描包
  type-aliases-package: com.hmdp.entity # 别名扫描包
logging:
  level:
    # 日志级别为debug
    com.hmdp: debug

启动项目后，在浏览器访问http://localhost:8081/shop-type/list，如果看到如下则后端导入成功

在这里插入图片描述

1.1.3 导入前端项目

在资料中提供了一个前端项目 [nginx-1.18.0.zip] 文件，将其解压到某目录内（要确保该目录中不包含中文、特殊字符和空格，如博主的存放路径为：“F:\code\WebCode\hmdp\nginx-1.18.0”）

在nginx.exe文件目录中用cmd打开控制台，输入start nginx.exe，如下图⬇️

在这里插入图片描述

启动 nginx 服务后后打开 chrome 谷歌浏览器，按F12（或空白位置鼠标右键点击“检查”）打开开发者工具，选择任意一个手机模式即可。URL输入：http://localhost:8080，即可看到如下页面⬇️

在这里插入图片描述

项目准备完成

1.2 基于Session实现登录流程

1.2.1 功能流程介绍

1.2.1.1 发送短信验证码

用户在提交手机号后，会校验手机号是否合法，如果不合法，则要求用户重新输入手机号

如果手机号合法，后台此时生成对应的验证码，同时将验证码进行保存，然后再通过短信的方式将验证码发送给用户

发送短信验证码业务流程图如下⬇️

在这里插入图片描述

1.2.1.2 短信验证码登录、注册

用户将验证码和手机号进行输入，后台从 session 中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验，如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库（快捷注册），无论是否存在，都会将用户信息保存到 session 中，方便后续获得当前登录信息

在这里插入图片描述

1.2.1.3 校验登录状态

登录成功后，用户在请求时候，会从 cookie 中携带者 sessionId 到后台，后台通过 sessionId 从 session 中拿到用户信息，如果没有 session 信息，则进行拦截，如果有 session 信息，则将用户信息保存到 threadLocal 中，并且放行。

在这里插入图片描述

1.2.2 实现发送短信验证码功能

1.2.2.1 页面流程

点击首页中“我的”按钮，进入个人页面，就会跳转到登录页面，用户输入手机号后，点击“发送验证码”时，相关请求就会发送到后端，服务端就是要实现发送短信验证码这个请求的功能

在这里插入图片描述

1.2.2.2 代码实现

业务流程图（点我跳转查看）

发送验证码代码

1️⃣ UserController 的 sendCode 方法

在这里插入图片描述

（图为未实现前）

    /**
     * 发送手机验证码
     */
    @PostMapping("code")
    public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
        // 发送短信验证码并保存验证码
        return userService.sendCode(phone, session);
    }

2️⃣ IUserService 接口中声明 sendCode 方法

public interface IUserService extends IService<User> {

    Result sendCode(String phone, HttpSession session);
}

3️⃣ UserServiceImpl 实现类中实现 sendCode 方法

@Slf4j
@Service
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    @Override
    public Result sendCode(String phone, HttpSession session) {
        // 1.校验手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.符合，生成验证码
        String code = RandomUtil.randomNumbers(6);

        // 4.保存验证码到 session
        session.setAttribute("code", code);
        // 5.发送验证码（此处为模拟，真实要调用第三方接口，较为复杂），记得加上@Slf4j注解
        log.debug("发送短信验证码成功，验证码：{}", code);
        // 返回ok
        return Result.ok();
    }
}

瑞：此处第5步为模拟发送验证码，真实要调用QQ邮箱、阿里云等第三方服务等接口，较为复杂。且不是学习 Redis 的重点，就以日志记录表示发送验证码步骤

1.2.2.3 测试

重新启动后端项目，在前端点“我的”图标后，输入手机号，点击发送验证码

在这里插入图片描述

返回到后端控制台，看到控制台输出随机生成的验证码则测试成功！

在这里插入图片描述

1.2.3 实现短信验证码登录、注册功能

1.2.3.1 页面流程

点击首页中“我的”按钮，进入个人页面，跳转到登录页面，输入手机号并获取验证码后，点击“登录”按钮，相关请求就会发送到后端

在这里插入图片描述

1.2.3.2 代码实现

业务流程图（点我跳转查看）

1️⃣ UserController 的 login 方法

在这里插入图片描述

（图为未实现前）

    /**
     * 登录功能
     *
     * @param loginForm 登录参数，包含手机号、验证码；或者手机号、密码
     */
    @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session) {
        // 实现登录功能
        return userService.login(loginForm, session);
    }

2️⃣ IUserService 接口中声明 login 方法

public interface IUserService extends IService<User> {

    Result sendCode(String phone, HttpSession session);

    Result login(LoginFormDTO loginForm, HttpSession session);
}

3️⃣ UserServiceImpl 实现类中实现 login 方法

    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号（有可能用户输入完验证码之后是改过手机号的，所以要再校验一次，保证安全）
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.校验验证码 此处"code"其实是魔法值，应该放入常量类中
        Object cacheCode = session.getAttribute("code");
        String code = loginForm.getCode();
        // 反向校验避免 if 深层嵌套
        if (cacheCode == null || !cacheCode.toString().equals(code)) {
            //3.不一致，报错
            return Result.fail("验证码错误");
        }
        // 一致，根据手机号查询用户（mp的query()相当于 select * from tb_user）
        User user = query().eq("phone", phone).one();

        // 5.判断用户是否存在
        if (user == null) {
            // 不存在，则创建
            user = createUserWithPhone(phone);
        }
        // 7.保存用户信息到session中
        // 由于像 User 类中的密码等敏感信息不需要通过网络传递返回，所以要转为DTO或者vO类保护隐私信息
        session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
        return Result.ok();
    }

我们应当在返回用户信息之前，将用户的敏感信息（如手机号等）进行隐藏，采用的核心思路就是书写一个UserDTO或UserVO对象，这个UserDTO对象就没有敏感信息了，我们在返回前，将有用户敏感信息的User对象转化成没有敏感信息的UserDTO对象，那么就能够避免这个尴尬的问题了

4️⃣ UserServiceImpl 实现类中实现上一步定义的注册 createUserWithPhone 方法

    private User createUserWithPhone(String phone) {
        // 1.创建用户
        User user = new User();
        user.setPhone(phone);
        user.setNickName(SystemConstants.USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
        // 2.保存用户
        save(user);
        return user;
    }

瑞：
1️⃣ 注意魔法值"user_"应当像USER_NICK_NAME_PREFIX的使用一样，存放在常量池类中。具体可以参考《瑞_Java开发手册_（一）编程规约的（二）常量定义的第1条》
2️⃣ 此处 User 对象没有设置 create_time、update_time，是因为数据库中已经设置了默认值为当前时间

在这里插入图片描述

1.2.3.3 测试

1️⃣ 重新启动后端程序，在登录注册页面中，输入数据库中不存在的手机号，如14567890001，点击发送验证码，后端生成验证码，如419350

在这里插入图片描述

2️⃣ 填入419350，勾选同意（如果不能勾选就强制刷新浏览器，如下图）

在这里插入图片描述

3️⃣ 点击登录

在这里插入图片描述

4️⃣ 查看后端输出日志，由于是未注册的手机号，所以查询结果为0，走注册代码逻辑，插入一个新的User对象到数据库

在这里插入图片描述

瑞：提示：如果数据库中已经存在你填写的该手机号，则会直接登录成功，这是正常的。要输入数据库中没有注册的手机号（此时数据库已经有一千多条数据，可以把数据库中tb_user表中的数据删除）

1.2.4 实现校验登录状态功能

1.2.4.1 实现逻辑

如果在每个暴露给前端的接口（Controller中的方法）都写一个校验登录状态的方法，明显过于繁琐。所以我们可以使用拦截器拦截前端用户请求，由拦截器判断请求是否能到达Controller。但注意，需要把用户信息传递到Controller，且传递过程中要保证线程安全问题，所以需要使用到ThreadLocal中。

在这里插入图片描述

温馨小贴士：tomcat的运行原理

在这里插入图片描述
当用户发起请求时，会访问我们像tomcat注册的端口，任何程序想要运行，都需要有一个线程对当前端口号进行监听，tomcat也不例外，当监听线程知道用户想要和tomcat连接连接时，那会由监听线程创建socket连接，socket都是成对出现的，用户通过socket像互相传递数据，当tomcat端的socket接受到数据后，此时监听线程会从tomcat的线程池中取出一个线程执行用户请求，在我们的服务部署到tomcat后，线程会找到用户想要访问的工程，然后用这个线程转发到工程中的controller，service，dao中，并且访问对应的DB，在用户执行完请求后，再统一返回，再找到tomcat端的socket，再将数据写回到用户端的socket，完成请求和响应。

通过以上讲解，我们可以得知：每个用户其实对应都是去找tomcat线程池中的一个线程来完成工作的，使用完成后再进行回收，既然每个请求都是独立的，所以在每个用户去访问我们的工程时，我们可以使用Threadlocal来做到线程隔离，每个线程操作自己的一份数据。

温馨小贴士：关于Threadlocal

如果小伙伴们看过Threadlocal的源码，你会发现在Threadlocal中，无论是他的put方法和他的get方法，都是先从获得当前用户的线程，然后从线程中取出线程的成员变量map，只要线程不一样，map就不一样，所以可以通过这种方式来做到线程隔离。

1.2.4.2 代码实现

1️⃣ 在 utils 包下新建类LoginInterceptor

在这里插入图片描述

2️⃣ 实现HandlerInterceptor接口，实现preHandle前置拦截方法，以及实现afterCompletion后置拦截方法

import com.hmdp.dto.UserDTO;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import javax.servlet.http.HttpSession;

/**
 * 登录拦截器
 *
 * @author LiaoYuXing-Ray
 * @version 1.0
 * @createDate 2024/3/17 21:54
 **/
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取session
        HttpSession session = request.getSession();
        // 2.获取session中的用户
        Object user = session.getAttribute("user");
        // 3.判断用户是否存在
        if (user == null) {
            // 4.不存在，拦截，返回401状态码
            response.setStatus(401);
            return false;
        }
        // 5.存在，保存用户信息到Threadlocal
        UserHolder.saveUser((UserDTO) user);
        // 6.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}

3️⃣ 为了让登录拦截器生效，在config包下新增MvcConfig配置类

在这里插入图片描述

4️⃣ MvcConfig类实现addInterceptors方法

import com.hmdp.utils.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * SpringMVC配置类
 *
 * @author LiaoYuXing-Ray
 * @version 1.0
 * @createDate 2024/3/17 22:09
 **/
@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 登录拦截器
        registry.addInterceptor(new LoginInterceptor())
                // 白名单
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
    }
}

5️⃣ 实现UserController中的me方法

    @GetMapping("/me")
    public Result me() {
        // 获取当前登录的用户并返回
        UserDTO user = UserHolder.getUser();
        return Result.ok(user);
    }

1.2.4.3 测试

1️⃣ 重新启动后端程序，进入登录注册页面，输入之前注册的手机号，如14567890001，将后端生成的验证码填入，点击登录（如果前端异常请强制重刷）

2️⃣ 点击“我的”，查看me方法返回情况

在这里插入图片描述

1.2.5 集群的session共享问题

session共享问题：多台Tomcat并不共享session存储空间，当请求切换到不同tomcat服务时导致数据丢失的问题

session的替代方案应该满足：
1️⃣ 数据共享
2️⃣ 内存存储
3️⃣ key、value结构

核心思路分析：

每个tomcat中都有一份属于自己的session，假设用户第一次访问第一台tomcat，并且把自己的信息存放到第一台服务器的session中，但是第二次这个用户访问到了第二台tomcat，那么在第二台服务器上，肯定没有第一台服务器存放的session，所以此时，整个登录拦截功能就会出现问题，我们能如何解决这个问题呢？

早期的方案是session拷贝，就是说虽然每个tomcat上都有不同的session，但是每当任意一台服务器的session修改时，都会同步给其他的Tomcat服务器的session，这样的话，就可以实现session的共享了

但是这种方案具有两个大问题

1️⃣ 每台服务器中都有完整的一份session数据，服务器压力过大。

2️⃣ session拷贝数据时，可能会出现延迟

所以咱们后来采用的方案都是基于redis来完成，我们把session换成redis，redis数据本身就是共享的，就可以避免session共享的问题了

在这里插入图片描述

1.2.6 代码资源

hm-dianping【1.2基于Session实现登录流程】后端代码的某度网盘链接如下，需要请自取

链接：https://pan.baidu.com/s/1kKY-ggJsiHwPJRwgkVuovA?pwd=hp9q 
提取码：hp9q

瑞：Redis在接下来的篇章将正式登场！

1.3 Redis代替session的业务流程

1.3.1 设计key的结构

首先我们要思考一下，利用redis来存储数据，那么到底使用哪种结构呢？

由于存入的数据比较简单，我们可以考虑使用String，或者是使用哈希Hash，如下图

在这里插入图片描述

（String 结构）

在这里插入图片描述

（hash 结构）

瑞：保存登录的用户信息，可以使用String结构，以JSON字符串来保存，比较直观。但是Hash结构可以将对象中的每个字段独立存储，可以针对单个字段做CRUD，并且内存占用更少。
瑞：关于Redis的数据结构，可以参考《瑞_Redis_Redis命令》

如果使用String，注意他的value，会多占用一点空间，但直观；如果使用哈希，则他的value中只会存储他数据本身。如果不是特别在意内存的情况下，其实使用String也是不错的选择。

1.3.2 设计key的具体细节

所以我们可以使用String结构，就是一个简单的key，value键值对的方式，但是关于key的处理，session他是每个用户都有自己的session，但是redis的key是共享的，咱们就不能使用code了

在设计这个key的时候，我们之前讲过需要满足两点

1️⃣ key要具有唯一性
2️⃣ key要方便携带

如果我们采用phone:手机号这个的数据来存储当然是可以的，但是如果把这样的敏感数据存储到redis中并且从页面中带过来毕竟不太合适，所以我们在后台生成一个随机串token，然后让前端带来这个token就能完成我们的整体逻辑了

1.3.3 整体访问流程

当注册完成后，用户去登录会去校验用户提交的手机号和验证码，是否一致，如果一致，则根据手机号查询用户信息，不存在则新建，最后将用户数据保存到redis，并且生成token作为redis的key，当我们校验用户是否登录时，会去携带着token进行访问，从redis中取出token对应的value，判断是否存在这个数据，如果没有则拦截，如果存在则将其保存到ThreadLocal中，并且放行。

在这里插入图片描述

注意：后端把token返回给前端，前端以后每次请求都要携带该token。

前端逻辑分析：

1️⃣ 用 VsCode 打开提供的前端资料中的nginx-1.18.0\html\hmdp\login.html

2️⃣ 可以看到login()方法中，将后端的token保存到了浏览器缓存中

在这里插入图片描述

3️⃣ 用 VsCode 打开提供的前端资料中的nginx-1.18.0\html\hmdp\js\common.js

4️⃣ 可以看到从sessionStorage中获取到token，并定义了 request 拦截器，在每次前端发送axios请求的时候携带 authorization 的 token 请求头。后续在后端就可以获取 authorization 的 token 请求头从而拿到token实现对登录的验证（登录凭证是保存在前端浏览器的）

在这里插入图片描述

瑞：所以手机号作为 token 的方案不可行，手机号保存到浏览器是很不安全的操作，有很大的泄漏用户隐私风险

瑞：以下功能的实现均是在基于Session实现登录流程实现代码的基础上修改

1.3.4 Redis实现发送短信验证码功能

1️⃣ 在 UserServiceImpl 中注入 StringRedisTemplate

    @Resource
    private StringRedisTemplate stringRedisTemplate;

2️⃣ 将 UserServiceImpl 的 sendCode 方法修改如下

    @Override
    public Result sendCode(String phone, HttpSession session) {
        // 1.校验手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.符合，生成验证码
        String code = RandomUtil.randomNumbers(6);

        // 4.保存验证码到 Redis // 等于 set key value ex 120
        stringRedisTemplate.opsForValue().set(RedisConstants.LOGIN_CODE_KEY + phone, code, RedisConstants.LOGIN_CODE_TTL, TimeUnit.MINUTES);

        // 5.发送验证码（此处为模拟，真实要调用第三方接口，较为复杂），记得加上@Slf4j注解
        log.debug("发送短信验证码成功，验证码：{}", code);

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

在这里插入图片描述

1.3.5 Redis实现短信验证码登录、注册、校验登录状态功能

1️⃣ 将 UserServiceImpl 的 login 方法修改如下


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.bean.copier.CopyOptions;
import cn.hutool.core.lang.UUID;
import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.dto.LoginFormDTO;
import com.hmdp.dto.Result;
import com.hmdp.dto.UserDTO;
import com.hmdp.entity.User;
import com.hmdp.mapper.UserMapper;
import com.hmdp.service.IUserService;
import com.hmdp.utils.RedisConstants;
import com.hmdp.utils.RegexUtils;
import com.hmdp.utils.SystemConstants;
import lombok.extern.slf4j.Slf4j;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import javax.servlet.http.HttpSession;
import java.util.HashMap;
import java.util.Map;
import java.util.concurrent.TimeUnit;

    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号（有可能用户输入完验证码之后是改过手机号的，所以要再校验一次，保证安全）
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.校验验证码
        String cacheCode = stringRedisTemplate.opsForValue().get(RedisConstants.LOGIN_CODE_KEY + phone);
        String code = loginForm.getCode();
        // 反向校验避免 if 深层嵌套
        if (cacheCode == null || !cacheCode.equals(code)) {
            // 不一致，报错
            return Result.fail("验证码错误");
        }
        // 4.一致，根据手机号查询用户（mp的query()相当于 select * from tb_user）即 select * from tb_user where phone = ?
        User user = query().eq("phone", phone).one();

        // 5.判断用户是否存在
        if (user == null) {
            // 不存在，则创建
            user = createUserWithPhone(phone);
        }

        // 7.保存用户信息到 redis中
        // 7.1.随机生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        // 7.2.将User对象转为HashMap存储（由于像 User 类中的密码等敏感信息不需要通过网络传递返回，所以要转为DTO或者vO类保护隐私信息）
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        // 由于使用的是StringRedisTemplate，所以每一个key,value都要保证是String类型，否则会报类型转换异常
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
                CopyOptions.create()
                        .setIgnoreNullValue(true)
                        .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
        // 7.3.存储
        String tokenKey = RedisConstants.LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
        // 7.4.设置token有效期
        stringRedisTemplate.expire(tokenKey, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);

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

在这里插入图片描述

2️⃣ 在 LoginInterceptor 中注入StringRedisTemplate

瑞：由于LoginInterceptor是我们new出来的，所以不能通过spring提供的注解的方式进行依赖注入，需要自己通过构造方法注入

public class LoginInterceptor implements HandlerInterceptor {
    
    private final StringRedisTemplate stringRedisTemplate;
    
    public LoginInterceptor(StringRedisTemplate stringRedisTemplate){
        this.stringRedisTemplate = stringRedisTemplate;
    }

// preHandle方法...

// afterCompletion方法...
}

3️⃣ 在 MvcConfig 中注入StringRedisTemplate


import com.hmdp.utils.LoginInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * SpringMVC配置类
 *
 * @author LiaoYuXing-Ray
 * @version 1.0
 * @createDate 2024/3/17 22:09
 **/
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 登录拦截器
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
                // 白名单
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
    }
}

4️⃣ 将 LoginInterceptor 的 preHandle 方法修改如下


import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * 登录拦截器
 *
 * @author LiaoYuXing-Ray
 * @version 1.0
 * @createDate 2024/3/17 21:54
 **/
public class LoginInterceptor implements HandlerInterceptor {

    private final StringRedisTemplate stringRedisTemplate;

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


    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1.获取请求头中的token （authorization是和前端配合好的）
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            // 不存在，拦截，返回401状态码
            response.setStatus(401);
            return false;
        }
        // 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;
        }
        // 5.将查询到的Hash数据转为UserDTO对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap,new UserDTO(),false);

        // 6.存在，保存用户信息到 ThreadLocal
        UserHolder.saveUser(userDTO);

        // 7.刷新token有效期
        stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);

        // 8.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}

在这里插入图片描述

1.3.6 测试

1️⃣ 打开前端项目nginx-1.18.0.zip文件解压路径，在nginx.exe文件目录中用cmd打开控制台，输入start nginx.exe运行前端项目

2️⃣ 在浏览器输入http://localhost:8080/，按F12（或空白位置鼠标右键点击“检查”）打开开发者工具，选择任意一个手机模式

3️⃣ 点击“我的”图标，输入注册的手机号，如14567890001，点击发送验证码按钮，可以看到后端日志输出的验证码和Redis中存放的验证码是相同的

在这里插入图片描述

4️⃣ 输入验证码登录成功后，点击“我的”图标进入登录成功后的主页，可以看到请求me的请求头中携带了token并且和Redis中存储的token相同

在这里插入图片描述

1.3.7 登录拦截器的优化

1.3.7.1 当前登录拦截器逻辑

当前登录拦截器的逻辑：用户请求进入拦截器之后，拦截器获取请求头中的token，如果之前用户登录成功过，则请求头中会携带token，根据token到redis中查询是否存在该用户信息，如果存在则将用户信息保存到ThreadLocal中，方便后续的Controller使用，并刷新token的有效期；若不存在则拦截请求，返回401状态码

在这里插入图片描述

1.3.7.2 改进

但是，当前设计并不合理，假设用户一直访问不需要登录的页面（如首页，商品页面），则拦截器不会生效（因为白名单过滤了）即有效期不会刷新，此时尽管用户在访问，但由于token的有效期不会刷新，后续如果用户访问需要拦截的请求，则会给用户造成不友好的体验

改进：设置两个拦截器。在新加入的拦截器拦截一切请求路径，保存用户信息到TheadLocal和刷新token的操作，确保一切请求都会触发token刷新机制。而第二个拦截器从ThreadLocal中查询用户信息，存在则继续，不存在则拦截⬇️

在这里插入图片描述

1.3.7.3 代码实现

1️⃣ 在 utils 包下新建 RefreshTokenInterceptor 类

在这里插入图片描述

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.TimeUnit;

/**
 * token 刷新拦截器
 *
 * @author LiaoYuXing-Ray
 * @version 1.0
 * @createDate 2024/3/19 0:40
 **/
public class RefreshTokenInterceptor implements HandlerInterceptor {

    private final StringRedisTemplate stringRedisTemplate;

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

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

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        // 移除用户
        UserHolder.removeUser();
    }
}

2️⃣ LoginInterceptor 登录拦截器修改如下

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

/**
 * 登录拦截器
 *
 * @author LiaoYuXing-Ray
 * @version 1.0
 * @createDate 2024/3/17 21:54
 **/
public class LoginInterceptor implements HandlerInterceptor {

    @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;
    }
    
}

3️⃣ MvcConfig 中配置两个拦截器

import com.hmdp.utils.LoginInterceptor;
import com.hmdp.utils.RefreshTokenInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

/**
 * SpringMVC配置类
 *
 * @author LiaoYuXing-Ray
 * @version 1.0
 * @createDate 2024/3/17 22:09
 **/
@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 登录拦截器
        registry.addInterceptor(new LoginInterceptor())
                // 白名单
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
        // token刷新的拦截器（默认/**，拦截所有请求）
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    }
}

瑞：order越大执行优先级越低，这样设置可以确保 token 刷新拦截器优先于登录拦截器

1.3.7.4 测试

重新启动前后端程序，正常登录后，前端访问任何请求，token的有效期都会重新刷新

在这里插入图片描述

1.3.8 代码资源

hm-dianping【1.3Redis代替session的业务流程】后端代码的某度网盘链接如下，需要请自取

链接：https://pan.baidu.com/s/1DomlH_sXyAkrciXk8-bWww?pwd=z6lu 
提取码：z6lu

基于Redis登录流程（完）

瑞：后续内容请关注瑞_系列专栏之《Redis》

本文是博主的粗浅理解，可能存在一些错误或不完善之处，如有遗漏或错误欢迎各位补充，谢谢

如果觉得这篇文章对您有所帮助的话，请动动小手点波关注💗，你的点赞👍收藏⭐️转发🔗评论📝都是对博主最好的支持~