• 基于 Redis 实现共享 Session 登录

     那么又该选用什么形式的 key 来存储用户数据呢？
            在这我们选择随机的 token 作为 key 来存储用户数据。在短信验证码登录时，我们还需要将这个随机 token 返回给客户端，这是因为后期我们在访问各个页面时都是需要校验登录状态，来判断哪些页面用户可以在未登录状态下访问，哪些页面需要登录后才能访问。

    来看下前端是如何存储 token 的。
    当我们访问接口 /user/login 时，如果访问成功，会将 token 返回给前端登录页面，而前端则会将该 token 保存到 session 中（通过 sessionStorage.setItem 方法）。

     再来看下 common.js
    可以看到，common.js 中将 token 数据保存到了请求头中，该请求头的名字叫做”authorization“，这样在后续所有的 Ajax 请求中，都会在请求头中携带该 token。

             而在此处为什么没有使用手机号作为 token 呢？这是因为 token 需要保存在客户端，如果以手机号作为 token，会有泄露用户隐私的风险。   

    代码实现

    1. public class UserHolder {
    2.     private static final ThreadLocal tl = new ThreadLocal<>();
    3.  
    4.     public static void saveUser(UserDTO user){
    5.         tl.set(user);
    6.     }
    7.  
    8.     public static UserDTO getUser(){
    9.         return tl.get();
    10.     }
    11.  
    12.     public static void removeUser(){
    13.         tl.remove();
    14.     }
    15. }
    1. package com.hmdp.service.impl;
    2.  
    3. import cn.hutool.core.bean.BeanUtil;
    4. import cn.hutool.core.lang.UUID;
    5. import cn.hutool.core.util.RandomUtil;
    6. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
    7. import com.hmdp.dto.LoginFormDTO;
    8. import com.hmdp.dto.Result;
    9. import com.hmdp.dto.UserDTO;
    10. import com.hmdp.entity.User;
    11. import com.hmdp.mapper.UserMapper;
    12. import com.hmdp.service.IUserService;
    13. import com.hmdp.utils.RegexUtils;
    14. import lombok.extern.slf4j.Slf4j;
    15. import org.springframework.beans.factory.annotation.Autowired;
    16. import org.springframework.data.redis.core.StringRedisTemplate;
    17. import org.springframework.stereotype.Service;
    18.  
    19. import javax.servlet.http.HttpSession;
    20.  
    21. import java.util.Map;
    22. import java.util.concurrent.TimeUnit;
    23.  
    24. import static com.hmdp.utils.RedisConstants.*;
    25. import static com.hmdp.utils.SystemConstants.USER_NICK_NAME_PREFIX;
    26.  
    27. @Slf4j
    28. @Service
    29. public class UserServiceImpl extends ServiceImpl implements IUserService {
    30.  
    31.     @Autowired
    32.     private StringRedisTemplate stringRedisTemplate;
    33.  
    34.     @Override
    35.     public Result sendCode(String phone, HttpSession session) {
    36.         // 1、校验手机号
    37.         if (RegexUtils.isPhoneInvalid(phone)) {
    38.             // 2、如果不符合，返回错误信息
    39.             return Result.fail("手机号格式错误！");
    40.         }
    41.         // 3、符合，生成验证码
    42.         String code = RandomUtil.randomNumbers(6);
    43.         // 4、保存验证码到 Redis 中
    44.         stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);
    45.         // 5、发送验证码
    46.         log.debug("发送短信验证码成功，验证码：{}", code);
    47.         return Result.ok();
    48.     }
    49.  
    50.     @Override
    51.     public Result login(LoginFormDTO loginForm, HttpSession session) {
    52.         // 1、校验手机号
    53.         String phone = loginForm.getPhone();
    54.         String code = loginForm.getCode();
    55.         if (RegexUtils.isPhoneInvalid(phone)) {
    56.             return Result.fail("手机号格式错误！");
    57.         }
    58.  
    59.         // 2、从 Redis 中获取验证码
    60.         String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
    61.  
    62.         // 3、不一致，报错
    63.         if(cacheCode == null || !cacheCode.equals(code)){
    64.             return Result.fail("验证码错误！");
    65.         }
    66.         // 4、一致，根据手机号去查询用户
    67.         User user = query().eq("phone", phone).one();
    68.  
    69.         // 5、判断用户是否存在
    70.         if(user == null){
    71.             // 6、不存在，创建新用户并保存
    72.             user = createUserWithPhone(phone);
    73.         }
    74.  
    75.         // 7、将用户信息保存到 Redis 中
    76.         // 7.1 生成 token，此处使用 UUID 作为 token
    77.         String tokenKey = UUID.randomUUID().toString(true);
    78.         // 7.2 将 User 对象转为 HashMap 存储
    79.         UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
    80.         Map userMap = BeanUtil.beanToMap(userDTO);
    81.         // 7.3 将用户信息存储到 Redis 中
    82.         stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + tokenKey, userMap);
    83.         // 7.4 设置过期时间
    84.         stringRedisTemplate.expire(LOGIN_USER_KEY + tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);
    85.  
    86.         // 将 token 返回给客户端
    87.         return Result.ok(tokenKey);
    88.     }
    89.  
    90.     /**
    91.      * 根据手机号创建用户
    92.      * */
    93.     private User createUserWithPhone(String phone) {
    94.         // 创建用户
    95.         User user = new User();
    96.         user.setPhone(phone);
    97.         user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
    98.         // 保存用户
    99.         save(user);
    100.         return user;
    101.     }
    102. }
    103.

    代码实现分析：
    1、sendCode 方法，将 session 存储验证码改为 Redis 存储，同时设置过期时间
    2、login 方法中，将 session 存储用户信息，修改为 Redis 存储，value 值采用 Hash 类型，同时设置过期时间，模拟 session 过期时间。但是 session 过期是在用户未作任何操作的情况下，而 Redis 则是从用户登录开始计时，到指定时间后自动过期。我们应当保证只要用户在不断访问，就不断更新 Redis 中的 token 过期时间。那我们如何知道用户什么时候访问，有没有访问呢？我们所有的请求都要经过拦截器进行校验，只要同过了拦截器的校验就说明用户是已经登录的且在活跃的状态。那么我们就可以在拦截器中对 token 的过期时间进行刷新操作。只有什么都不操作的情况下，才不会走拦截器的校验，也就不会刷新 token 的过期时间。

    修改拦截器
    这里要注意一点就是，LoginInterceptor 是我们自定义的一个类，并非 Spring 进行管理的类，所以在使用 StringRedisTemplate 的时候，无法使用 @Autowired 或者 @Resource 进行注入。但是，MvcConfig 是由 Spring 进行管理的，可以由 Spring 注入 StringRedisTemplate 的实例

    1. package com.hmdp.utils;
    2.  
    3. import cn.hutool.core.bean.BeanUtil;
    4. import cn.hutool.core.util.StrUtil;
    5. import com.hmdp.dto.UserDTO;
    6. import org.springframework.data.redis.core.StringRedisTemplate;
    7. import org.springframework.web.servlet.HandlerInterceptor;
    8.  
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11. import java.util.Map;
    12. import java.util.concurrent.TimeUnit;
    13.  
    14. public class LoginInterceptor implements HandlerInterceptor {
    15.  
    16.     private StringRedisTemplate stringRedisTemplate;
    17.  
    18.     public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
    19.         this.stringRedisTemplate = stringRedisTemplate;
    20.     }
    21.  
    22.     @Override
    23.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    24.         // 1、从请求头中获取 token
    25.         String token = request.getHeader("authorization");
    26.         // 2、判断token是否为空
    27.         if (StrUtil.isBlank(token)) {
    28.             // 不存在报401
    29.             response.setStatus(401);
    30.             return false;
    31.         }
    32.         // 3、根据 token 从 redis 中获取用户信息
    33.         String tokenKey = RedisConstants.LOGIN_USER_KEY + token;
    34.         // 使用 entries 方法获取所有的 field-value
    35.         Map userMap = stringRedisTemplate.opsForHash().entries(tokenKey);
    36.  
    37.         // 4、判断 userMap 是否为空
    38.         if (userMap.isEmpty()) {
    39.             // 不存在报401
    40.             response.setStatus(401);
    41.             return false;
    42.         }
    43.  
    44.         // 4、将 userMap 转换为 UserDTO
    45.         UserDTO user = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
    46.  
    47.         // 5、将 user 保存到 ThreadLocal 中
    48.         UserHolder.saveUser(user);
    49.  
    50.         // 6、刷新 token 过期时间
    51.         stringRedisTemplate.expire(tokenKey, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
    52.  
    53.         return true;
    54.     }
    55.  
    56.     @Override
    57.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    58.         UserHolder.removeUser();
    59.     }
    60. }
    61.

    修改 MvcConfig 配置类

    在 MvcConfig 中注入 StringRedisTemplate，同时在添加拦截器时，将 StringRedisTemplate 的实例通过 LoginInterceptor 的构造器传入。

    1. package com.hmdp.config;
    2.  
    3. import com.hmdp.utils.LoginInterceptor;
    4. import org.springframework.beans.factory.annotation.Autowired;
    5. import org.springframework.context.annotation.Configuration;
    6. import org.springframework.data.redis.core.StringRedisTemplate;
    7. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    8. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    9.  
    10. @Configuration
    11. public class MvcConfig implements WebMvcConfigurer {
    12.  
    13.     @Autowired
    14.     private StringRedisTemplate stringRedisTemplate;
    15.  
    16.     @Override
    17.     public void addInterceptors(InterceptorRegistry registry) {
    18.         registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
    19.                 .excludePathPatterns(
    20.                         "/shop/**",
    21.                         "/voucher/**",
    22.                         "/user/login",
    23.                         "/user/code",
    24.                         "/shop-type/**",
    25.                         "/upload/**"
    26.                 );
    27.     }
    28. }
    29.

    重启项目后点击登录时，发现后台报了如下的错误。

     这是因为 userMap 中的 id 为 Long 类型，但是 Redis 中存储的都是 String 类型。

    login 方法改进，将 UserDTO 实例转换为 HashMap 时，将每一个属性转换为 String 类型。

    1. @Override
    2. public Result login(LoginFormDTO loginForm, HttpSession session) {
    3.     // 1、校验手机号
    4.     String phone = loginForm.getPhone();
    5.     String code = loginForm.getCode();
    6.     if (RegexUtils.isPhoneInvalid(phone)) {
    7.         return Result.fail("手机号格式错误！");
    8.     }
    9.  
    10.     // 2、从 Redis 中获取验证码
    11.     String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
    12.  
    13.     // 3、不一致，报错
    14.     if(cacheCode == null || !cacheCode.equals(code)){
    15.         return Result.fail("验证码错误！");
    16.     }
    17.     // 4、一致，根据手机号去查询用户
    18.     User user = query().eq("phone", phone).one();
    19.  
    20.     // 5、判断用户是否存在
    21.     if(user == null){
    22.         // 6、不存在，创建新用户并保存
    23.         user = createUserWithPhone(phone);
    24.     }
    25.  
    26.     // 7、将用户信息保存到 Redis 中
    27.     // 7.1 生成 token，此处使用 UUID 作为 token
    28.     String tokenKey = UUID.randomUUID().toString(true);
    29.     // 7.2 将 User 对象转为 HashMap 存储
    30.     UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
    31.     Map userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
    32.             CopyOptions.create().setIgnoreNullValue(true).
    33.                     setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
    34.     // 7.3 将用户信息存储到 Redis 中
    35.     stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + tokenKey, userMap);
    36.     // 7.4 设置过期时间
    37.     stringRedisTemplate.expire(LOGIN_USER_KEY + tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);
    38.  
    39.     // 将 token 返回给客户端
    40.     return Result.ok(tokenKey);
    41. }

    总结

    Redis 代替 session 需要考虑的问题：

    • 选择合适的数据结构
    • 选择合适的 key
    • 选择合适的存储粒度

    登录拦截器的优化

            登录功能是基于拦截器做的校验功能，但是当前拦截器拦截的并不是所有的路径，而是拦截的需要登录的路径，如果用户登录后，一直访问的是首页这种不需要拦截的路径，那么拦截器就会一直不执行，token 的过期时间就不会刷新，那么当 token 过期后，用户访问例如像个人主页时就会出现问题，很不友好。那如何解决？可以在当前拦截器的基础再添加一个拦截器，让新的拦截器拦截一切路径，在该拦截内做 token 的刷新动作。 

     创建 RefreshTokenInterceptor 拦截器

    该拦截器用于拦截所有请求，并刷新 token 过期时间

    1. package com.hmdp.utils;
    2.  
    3. import cn.hutool.core.bean.BeanUtil;
    4. import cn.hutool.core.util.StrUtil;
    5. import com.hmdp.dto.UserDTO;
    6. import org.springframework.data.redis.core.StringRedisTemplate;
    7. import org.springframework.web.servlet.HandlerInterceptor;
    8.  
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11. import java.util.Map;
    12. import java.util.concurrent.TimeUnit;
    13.  
    14. public class RefreshTokenInterceptor implements HandlerInterceptor {
    15.  
    16.     private StringRedisTemplate stringRedisTemplate;
    17.  
    18.     public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
    19.         this.stringRedisTemplate = stringRedisTemplate;
    20.     }
    21.  
    22.     @Override
    23.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    24.         // 1、从请求头中获取 token
    25.         String token = request.getHeader("authorization");
    26.         // 2、判断token是否为空
    27.         if (StrUtil.isBlank(token)) {
    28.             return true;
    29.         }
    30.         // 3、根据 token 从 redis 中获取用户信息
    31.         String tokenKey = RedisConstants.LOGIN_USER_KEY + token;
    32.         Map userMap = stringRedisTemplate.opsForHash().entries(tokenKey);
    33.  
    34.         // 4、判断 userMap 是否为空
    35.         if (userMap.isEmpty()) {
    36.             return true;
    37.         }
    38.  
    39.         // 4、将 userMap 转换为 UserDTO
    40.         UserDTO user = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
    41.  
    42.         // 5、将 user 保存到 ThreadLocal 中
    43.         UserHolder.saveUser(user);
    44.  
    45.         // 6、刷新 token 过期时间
    46.         stringRedisTemplate.expire(tokenKey, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
    47.  
    48.         return true;
    49.     }
    50.  
    51.     @Override
    52.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    53.         UserHolder.removeUser();
    54.     }
    55. }
    56.

    修改 LoginInterceptor 拦截器

    LoginInterceptor 则只需要判断当前访问用户是否已经登录，已经登录则放行，未登录则拦截。

    1. package com.hmdp.utils;
    2.  
    3. import cn.hutool.core.bean.BeanUtil;
    4. import cn.hutool.core.util.StrUtil;
    5. import com.hmdp.dto.UserDTO;
    6. import org.springframework.data.redis.core.StringRedisTemplate;
    7. import org.springframework.web.servlet.HandlerInterceptor;
    8.  
    9. import javax.servlet.http.HttpServletRequest;
    10. import javax.servlet.http.HttpServletResponse;
    11.  
    12. public class LoginInterceptor implements HandlerInterceptor {
    13.  
    14.     @Override
    15.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    16.         // 判断当前用户是否登录
    17.         if (UserHolder.getUser() == null) {
    18.             // 未登录，设置状态码
    19.             response.setStatus(401);
    20.             // 拦截
    21.             return false;
    22.         }
    23.         return true;
    24.     }
    25.  
    26. }
    27.

    MvcConfig 设置拦截规则

    拦截器执行顺序应当是先执行 RefreshTokenInterceptor，而后再执行 LoginInterceptor，通过 orde 方法设置拦截器执行顺序，值越小，则执行顺序越优先。

    1. package com.hmdp.config;
    2.  
    3. import com.hmdp.utils.LoginInterceptor;
    4. import com.hmdp.utils.RefreshTokenInterceptor;
    5. import org.springframework.beans.factory.annotation.Autowired;
    6. import org.springframework.context.annotation.Configuration;
    7. import org.springframework.data.redis.core.StringRedisTemplate;
    8. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
    9. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
    10.  
    11. import javax.annotation.Resource;
    12.  
    13. @Configuration
    14. public class MvcConfig implements WebMvcConfigurer {
    15.  
    16.     @Autowired
    17.     private StringRedisTemplate stringRedisTemplate;
    18.  
    19.     @Override
    20.     public void addInterceptors(InterceptorRegistry registry) {
    21.         registry.addInterceptor(new LoginInterceptor())
    22.                 .excludePathPatterns(
    23.                         "/shop/**",
    24.                         "/voucher/**",
    25.                         "/user/login",
    26.                         "/user/code",
    27.                         "/shop-type/**",
    28.                         "/upload/**"
    29.                 ).order(1);
    30.         registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    31.     }
    32. }
    33.

  • 相关阅读:
    Kubernetes调度器：资源分配与优化之道
    6种应用部署策略对比
    golang 发起 http 请求，获取访问域名的 ip 地址（net, httptrace）
    java源码系列：链表是什么？数组和它有何不同?（2022-07-28更新完毕）
    TeamViewer 可信设备的信任管理
    贷款五级分类
    （附源码）基于微服务架构的餐饮系统的设计与实现-计算机毕设 86393
    mysql——mysqlbinlog
    【基本数据结构 三】线性数据结构：栈
    分享大数据培训班班型
  • 原文地址：https://blog.csdn.net/weixin_51472505/article/details/126360496