瑞_Redis_短信登录_Redis代替session的业务流程

• 短信登录
  这一块我们会使用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 项目准备

瑞：请看《瑞_Redis_短信登录_项目准备》

1.2 基于Session实现登录流程

瑞：请看《瑞_Redis_短信登录_基于Session实现登录流程》

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