ToB企服应用市场:ToB评测及商务社交产业平台

标题: day02-短信登录 [打印本页]
作者: 前进之路    时间: 2023-4-19 22:23
标题: day02-短信登录
功能实现02

2.功能01-短信登录

2.1基于Session实现登录

2.1.1思路分析

2.1.2代码实现

2.1.2.1发送短信验证码

发送短信验证码：
发送验证码的接口为：http://127.0.0.1:8080/api/user/code?phone=xxxxx
请求方式：POST
请求路径：/user/code
请求参数：phone，电话号码
返回值：无
部分代码
（1）User类、UserDTO类（DTO类主要是为了存储非敏感数据）
  1. package com.hmdp.entity;
  3. import com.baomidou.mybatisplus.annotation.IdType;
  4. import com.baomidou.mybatisplus.annotation.TableId;
  5. import com.baomidou.mybatisplus.annotation.TableName;
  6. import lombok.Data;
  7. import lombok.EqualsAndHashCode;
  8. import lombok.experimental.Accessors;
  10. import java.io.Serializable;
  11. import java.time.LocalDateTime;
  13. /**
  14. * 用户实体类
  15. *
  16. * @author 李
  17. * @version 1.0
  18. */
  19. @Data
  20. @EqualsAndHashCode(callSuper = false)
  21. //chain = true,则对应字段的setter方法调用后，会返回当前对象
  22. @Accessors(chain = true)
  23. @TableName("tb_user")
  24. public class User implements Serializable {
  26.     private static final long serialVersionUID = 1L;
  27.     //用户id（主键）
  28.     @TableId(value = "id", type = IdType.AUTO)
  29.     private Long id;
  30.     //手机号码
  31.     private String phone;
  32.     //密码
  33.     private String password;
  34.     //昵称
  35.     private String nickName;
  36.     //用户头像
  37.     private String icon = "";
  38.     //创建时间
  39.     private LocalDateTime createTime;
  40.     //更新时间
  41.     private LocalDateTime updateTime;
  42. }
复制代码
  1. package com.hmdp.dto;
  3. import lombok.Data;
  5. @Data
  6. public class UserDTO {
  7.     private Long id;
  8.     private String nickName;
  9.     private String icon;
  10. }
复制代码
（2）UserMapper
  1. package com.hmdp.mapper;
  3. import com.hmdp.entity.User;
  4. import com.baomidou.mybatisplus.core.mapper.BaseMapper;
  6. /**
  7. *  Mapper 接口
  8. *
  9. * @author 李
  10. * @version 1.0
  11. */
  12. public interface UserMapper extends BaseMapper<User> {
  14. }
复制代码
（3）IUserService
  1. package com.hmdp.service;
  3. import com.baomidou.mybatisplus.extension.service.IService;
  4. import com.hmdp.dto.LoginFormDTO;
  5. import com.hmdp.dto.Result;
  6. import com.hmdp.entity.User;
  8. import javax.servlet.http.HttpSession;
  10. /**
  11. *  服务类
  12. *
  13. * @author 李
  14. * @version 1.0
  15. */
  16. public interface IUserService extends IService<User> {
  17.     Result sendCode(String phone, HttpSession session);
  18. }
复制代码
（4）UserServiceImpl.java
  1. package com.hmdp.service.impl;
  3. import cn.hutool.core.util.RandomUtil;
  4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  5. import com.hmdp.dto.Result;
  6. import com.hmdp.entity.User;
  7. import com.hmdp.mapper.UserMapper;
  8. import com.hmdp.service.IUserService;
  9. import com.hmdp.utils.RegexUtils;
  10. import lombok.extern.slf4j.Slf4j;
  11. import org.springframework.stereotype.Service;
  13. import javax.servlet.http.HttpSession;
  15. /**
  16. * 服务实现类
  17. *
  18. * @author 李
  19. * @version 1.0
  20. */
  21. @Slf4j
  22. @Service
  23. public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
  25.     @Override
  26.     public Result sendCode(String phone, HttpSession session) {
  27.         //1.校验手机号
  28.         boolean phoneInvalid = RegexUtils.isPhoneInvalid(phone);
  29.         //2.如果不符合，返回错误信息
  30.         if (phoneInvalid) {//true表示不符合格式
  31.             return Result.fail("手机号格式错误！");
  32.         }
  33.         //3.符合，生成验证码
  34.         String code = RandomUtil.randomNumbers(6);//生成6位数的随机号码
  35.         //4.保存验证码
  36.         session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
  37.         //5.发送验证码(由于这里涉及到一些其他方的工具，先不做)
  38.         log.debug("发送短信验证码成功，验证码={}", code);
  39.         //6.返回OK
  40.         return Result.ok();
  41.     }
  42. }
复制代码
（2）UserController.java
  1. package com.hmdp.controller;
  4. import com.hmdp.dto.LoginFormDTO;
  5. import com.hmdp.dto.Result;
  6. import com.hmdp.entity.UserInfo;
  7. import com.hmdp.service.IUserInfoService;
  8. import com.hmdp.service.IUserService;
  9. import lombok.extern.slf4j.Slf4j;
  10. import org.springframework.web.bind.annotation.*;
  12. import javax.annotation.Resource;
  13. import javax.servlet.http.HttpSession;
  15. /**
  16. * 前端控制器
  17. *
  18. * @author 李
  19. * @version 1.0
  20. */
  21. @Slf4j
  22. @RestController
  23. @RequestMapping("/user")
  24. public class UserController {
  25.     @Resource
  26.     private IUserService userService;
  28.     /**
  29.      * 发送手机验证码
  30.      * @param phone 用户输入的手机号码
  31.      * @param session session域
  32.      * @return
  33.      */
  34.     @PostMapping("code")
  35.     public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
  36.         //发送短信验证码并保存验证码
  37.         return userService.sendCode(phone,session);
  38.     }
  39. }
复制代码
测试：输入手机号，点击发送验证码，后台输出如下：

2.1.2.2短信验证码登录/注册


当点击登录的时候，前端发送的请求如下：

发送验证码的接口为：http://127.0.0.1:8080/api/user/login
请求方式：POST
请求路径：/user/login
请求参数：phone，code
返回值：无
部分代码
（1）修改IUserService.java，声明login()方法
  1. package com.hmdp.service;
  3. import ...
  5. /**
  6. * 服务类
  7. *
  8. * @author 李
  9. * @version 1.0
  10. */
  11. public interface IUserService extends IService<User> {
  12.     Result login(LoginFormDTO loginForm, HttpSession session);
  13. }
复制代码
（3）修改UserServiceImpl.java，实现login()
  1. package com.hmdp.service.impl;
  3. import cn.hutool.core.util.RandomUtil;
  4. import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
  5. import com.hmdp.dto.LoginFormDTO;
  6. import com.hmdp.dto.Result;
  7. import com.hmdp.entity.User;
  8. import com.hmdp.mapper.UserMapper;
  9. import com.hmdp.service.IUserService;
  10. import com.hmdp.utils.RegexUtils;
  11. import lombok.extern.slf4j.Slf4j;
  12. import org.springframework.stereotype.Service;
  14. import javax.servlet.http.HttpSession;
  16. import static com.hmdp.utils.SystemConstants.USER_NICK_NAME_PREFIX;
  18. /**
  19. * 服务实现类
  20. *
  21. * @author 李
  22. * @version 1.0
  23. */
  24. @Slf4j
  25. @Service
  26. public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
  27.     //...
  29.         @Override
  30.     public Result login(LoginFormDTO loginForm, HttpSession session) {
  31.         //1.校验手机号
  32.         String phone = loginForm.getPhone();
  33.         if (RegexUtils.isPhoneInvalid(phone)) {
  34.             //如果不符合，返回错误信息
  35.             return Result.fail("手机号格式错误！");
  36.         }
  38.         //2.校验验证码
  39.         Object cacheCode = session.getAttribute("code");
  40.         String code = loginForm.getCode();
  41.         if (cacheCode == null || !cacheCode.toString().equals(code)) {
  42.             //cacheCode == null 说明没有发过验证码，因为session里面没有存放
  43.             //!cacheCode.toString().equals(code) == true
  44.             //说明用户输入的验证码和session的不一致
  45.             return Result.fail("验证码错误");
  46.         }
  48.         //3.根据手机号查询用户是否已经注册
  49.         User user = query().eq("phone", phone).one();
  50.         if (user == null) {
  51.             //若不存在，则在创建用户
  52.             user = createUserWithPhone(phone);
  53.         }
  55.         //4.保存用户到session(这里只保存id、昵称、手机号)
  56.         session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
  58.         return Result.ok();
  59.     }
  61.     private User createUserWithPhone(String phone) {
  62.         //1.创建用户
  63.         User user = new User();
  64.         //设置手机号
  65.         user.setPhone(phone);
  66.         //设置昵称，初始值为随机的15位字符串
  67.         user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
  68.         //2.保存用户到DB
  69.         save(user);
  70.         return user;
  71.     }
  72. }
复制代码
（3）修改UserController
  1. /**
  2. * 登录功能
  3. * @param loginForm 登录参数：包含手机号+验证码，或手机号+密码
  4. * @param session session域
  5. */
  6. @PostMapping("/login")
  7. public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
  8.     //实现登录功能
  9.     return userService.login(loginForm,session);
  10. }
复制代码
（4）测试：前端输入手机号码，和验证码，点击登录
后台输出：
2.1.2.3校验登录状态


以上的逻辑放到拦截器去实现，并使用ThreadLocal去保存用户信息，实现线程安全。
（1）创建拦截器 LoginInterceptor
  1. package com.hmdp.interceptor;
  3. import cn.hutool.http.HttpStatus;
  4. import com.hmdp.dto.UserDTO;
  5. import com.hmdp.entity.User;
  6. import com.hmdp.utils.UserHolder;
  7. import org.springframework.web.servlet.HandlerInterceptor;
  9. import javax.servlet.http.HttpServletRequest;
  10. import javax.servlet.http.HttpServletResponse;
  11. import javax.servlet.http.HttpSession;
  13. /**
  14. * @author 李
  15. * @version 1.0
  16. * 登录拦截器
  17. */
  18. public class LoginInterceptor implements HandlerInterceptor {
  19.     @Override
  20.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  21.         //1.获取session中的用户
  22.         HttpSession session = request.getSession();
  23.         UserDTO userDTO = (UserDTO) session.getAttribute("user");
  24.         //2.判断用户是否登录过
  25.         if (userDTO == null) {
  26.             //如果没有登录过，拦截，返回状态码-401
  27.             response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
  28.             return false;//拦截
  29.         }
  30.         //3.如果存在，保存用户到ThreadLocal
  31.         UserHolder.saveUser(userDTO);//这里是一个工具类，自动创建ThreadLocal
  32.         ThreadLocal<UserDTO> userThreadLocal = new ThreadLocal<UserDTO>();
  33.         userThreadLocal.set(userDTO);
  34.         //4.放行
  35.         return true;
  36.     }
  38.     @Override
  39.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  40.         //移除用户（根据当前线程，移除用户信息）
  41.         /**
  42.          * 为什么要移除用户？
  43.          * 因为ThreadLocal对应的是一个线程的中数据
  44.          * 每次http请求，tomcat都会创建一个新的线程
  45.          * 但是一次http请求结束后，如果web容器使用了线程池（线程被重复利用），
  46.          * 问题一：ThreadLocal的生命周期不等于一次Request的生命周期，造成获取threadLocal内数据异常
  47.          * 问题二：内存溢出，ThreadLocal依赖没有释放，无法GC
  48.          * 因此，需要手动移除数据
  49.          */
  50.         UserHolder.removeUser();
  51.     }
  52. }
复制代码
（2）配置拦截器 MvcConfig
  1. package com.hmdp.config;
  3. import com.hmdp.interceptor.LoginInterceptor;
  4. import org.springframework.context.annotation.Configuration;
  5. import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
  6. import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;
  8. /**
  9. * @author 李
  10. * @version 1.0
  11. */
  12. @Configuration
  13. public class MvcConfig implements WebMvcConfigurer {
  14.     @Override
  15.     public void addInterceptors(InterceptorRegistry registry) {
  16.         registry.addInterceptor(new LoginInterceptor())
  17.                 .addPathPatterns().
  18.                 excludePathPatterns(
  19.                         "/shop/**",
  20.                         "/voucher/**",
  21.                         "/shop-type/**",
  22.                         "/upload/**",
  23.                         "/blog/hot",
  24.                         "/user/login",
  25.                         "/user/code"
  26.                 );
  27.     }
  28. }
复制代码
（3）修改UserController，获取当前登录用户信息，并返回
  1. /**
  2. * @return 返回当前登录用户的信息
  3. */
  4. @GetMapping("/me")
  5. public Result me() {
  6.     //获取当前登录的用户并返回
  7.     UserDTO user = UserHolder.getUser();
  8.     return Result.ok(user);
  9. }
复制代码
（4）测试：登录用户
后台输出：
返回的响应：
前端成功显示登录后的用户信息：
2.2集群的session共享问题

集群的Session共享问题：多台Tomcat并不共享它们之间的Session存储空间，如果有多台tomcat服务器，当请求切换到不同tomcat服务时，会导致数据丢失的问题。
（1）问题具体分析：
如上，当请求进入Nginx时，Nginx会做一个负载均衡（一般是对tomcat集群进行轮询）。
假设用户的请求第一次被负载均衡到了tomcat_1，例如之前的登录验证，那么tomcat_1就会将信息保存到它的session域中；
如果用户第二次的请求被负载均衡到了tomcat_2，当tomcat_2要去获取验证码或者用户信息的时候，由于多台tomcat不能共享它们之间的Session存储空间，导致tomcat_2不能获取存储在tomcat_1的session数据，表现出来就是数据丢失的问题。
（2）解决方案：
如图，session的替代方案必须满足：数据共享、内存存储（快）、k-v结构（方便存/取数据）。
如果使用redis，则刚好可以满足这些需求：
首先，redis是在tomcat之外的一个存储方案，所有的tomcat都可以访问到，解决了数据共享问题；
其次，redis是内存存储，性能很强，读写很快，读写延时基本上是在微秒级别；
最后，redis是k-v结构，方便数据的存取。
综上，我们下面将会使用redis来实现session登录。
2.3基于Redis实现共享session登录

2.3.1思路分析

（1）发送短信验证码：
如左图所示，当用户发送短信验证码时，将生成的验证码存入到redis中，为了让一个手机号码对应一个验证码，这里使用手机号作为key，value则是验证码。（使用Redis-String类型）
（2）短信验证码登录、注册：
使用redis代替之后，我们在获取短信验证码的时候，也使用手机号为key去取验证码，这就解决了发送和登录手机号可能不一致的问题。如果需要保存用户信息，可以使用Redis-Hash类型。
（3）登录状态校验：
session机制：之前直接使用session存储用户信息后，tomcat会自动给浏览器返回一个cookie（包含jsessionid），每次向服务端发送请求时，都会自动携带。这样tomcat根据jsessionid，就能自动找到session，也就能找到session里的数据。
登录成功后，会存储一个token到redis中作为key，value就是用户信息。我们可以模仿jsessionid，存储token到redis时，同时将token放到cookie中，返回给客户端，之后每次客户端发送请求，都会携带token，服务器就可以获取token，到redis去获取用户信息，从而进行一系列业务流程。
登录凭证token保存在前端浏览器：前端代码会存储token到SessionStorage中，设置request拦截器，将用户token放入请求头中。这样，每次发送请求的时候都会使用token作为请求头。我们在服务端就可以获取token数据校验。
2.3.2代码实现

2.3.2.1发送短信验证码

在2.1代码的基础上修改
修改UserServiceImpl.java的sendCode()方法
  1. @Resource
  2. private StringRedisTemplate stringRedisTemplate;
  4. @Override
  5. public Result sendCode(String phone, HttpSession session) {
  6.     //1.校验手机号
  7.     boolean phoneInvalid = RegexUtils.isPhoneInvalid(phone);
  8.     //2.如果不符合，返回错误信息
  9.     if (phoneInvalid) {//true表示不符合格式
  10.         return Result.fail("手机号格式错误！");
  11.     }
  12.     //3.符合，生成验证码
  13.     String code = RandomUtil.randomNumbers(6);//生成6位数的随机号码
  15.     //4.保存验证码到 redis中，这里的 key 最好使用业务前缀作为区分
  16.     // set key value ex
  17.     stringRedisTemplate.opsForValue()
  18.             .set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);
  19.    
  20.     //5.发送验证码(由于这里涉及到一些其他方的工具，先不做)
  21.     log.debug("发送短信验证码成功，验证码={}", code);
  22.     //6.返回OK
  23.     return Result.ok();
  24. }
复制代码
2.3.2.2短信验证码登录/注册

修改UserServiceImpl.java的login()方法
  1. @Override
  2. public Result login(LoginFormDTO loginForm, HttpSession session) {
  3.     //1.校验手机号
  4.     String phone = loginForm.getPhone();
  5.     if (RegexUtils.isPhoneInvalid(phone)) {
  6.         //如果不符合，返回错误信息
  7.         return Result.fail("手机号格式错误！");
  8.     }
  10.     //2.从redis获取验证码并校验
  11.     String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
  12.     String code = loginForm.getCode();
  13.     if (cacheCode == null || !cacheCode.equals(code)) {
  14.         return Result.fail("验证码错误");
  15.     }
  17.     //3.根据手机号查询用户是否已经注册
  18.     User user = query().eq("phone", phone).one();
  19.     if (user == null) {
  20.         //若不存在，则在创建用户
  21.         user = createUserWithPhone(phone);
  22.     }
  24.     //4.保存用户到redis中 (这里只保存id、昵称、手机号)
  25.     //随机生成token，作为登录令牌
  26.     String token = UUID.randomUUID().toString(true);
  27.     //将user对象转为redis-hash
  28.     UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
  29.     //使用工具类转(指定转换后的数据类型为String)
  30.     Map<String, Object> map = BeanUtil.beanToMap(userDTO, new HashMap<>(),
  31.                     CopyOptions.create()
  32.                     .setIgnoreNullValue(true)
  33.                             .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
  34.     //存储到redis中,设置有效期为30分钟
  35.     stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + token, map);
  36.     stringRedisTemplate.expire(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.MINUTES);
  39.     //5.将token返回客户端
  40.     return Result.ok(token);
  41. }
复制代码
2.3.2.3校验登录状态

（1）修改LoginInterceptor.java
在上述代码中，我们设置了token在redis中的过期时间。但是和session不同，redis的过期时间是绝对时间，即在设定的时间内，无论有没有使用到token，从设定的那一刻起一直到第30分钟，该数据都会被删除。
因此，我们需要在拦截器中重新设置redis的token信息：每当用户有操作时，拦截器就重新设置过期时间。
  1. package com.hmdp.interceptor;
  3. import cn.hutool.core.bean.BeanUtil;
  4. import cn.hutool.core.util.StrUtil;
  5. import cn.hutool.http.HttpStatus;
  6. import com.hmdp.dto.UserDTO;
  7. import com.hmdp.utils.UserHolder;
  8. import org.springframework.data.redis.core.StringRedisTemplate;
  9. import org.springframework.web.servlet.HandlerInterceptor;
  11. import javax.servlet.http.HttpServletRequest;
  12. import javax.servlet.http.HttpServletResponse;
  13. import java.util.Map;
  14. import java.util.concurrent.TimeUnit;
  16. import static com.hmdp.utils.RedisConstants.LOGIN_USER_KEY;
  17. import static com.hmdp.utils.RedisConstants.LOGIN_USER_TTL;
  19. /**
  20. * @author 李
  21. * @version 1.0
  22. * 登录拦截器
  23. */
  24. public class LoginInterceptor implements HandlerInterceptor {
  26.     private StringRedisTemplate stringRedisTemplate;
  28.     //不能使用注解@Component将拦截器注入到spring容器中！！
  29.     //因为拦截器是在spring容器初始化之前执行的
  30.     //因此这里使用构造器设置，在注册拦截器的时候去注入
  31.     public LoginInterceptor(StringRedisTemplate stringRedisTemplate) {
  32.         this.stringRedisTemplate = stringRedisTemplate;
  33.     }
  35.     @Override
  36.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  37.         //1.获取请求头中的token
  38.         String token = request.getHeader("authorization");
  39.         //如果浏览器的token为空
  40.         if (StrUtil.isBlank(token)) {
  41.             //拦截，返回状态码-401
  42.             response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
  43.             return false;//拦截
  44.         }
  45.         //2.基于token获取redis中的用户
  46.         String key = LOGIN_USER_KEY + token;
  47.         Map<Object, Object> userMap =
  48.                 stringRedisTemplate.opsForHash().entries(key);
  49.         //3.判断用户是否存在
  50.         if (userMap.isEmpty()) {
  51.             //拦截，返回状态码-401
  52.             response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
  53.             return false;//拦截
  54.         }
  55.         //4.如果存在，将查询到的Hash数据转为UserDTO对象
  56.         UserDTO userDTO =
  57.                 BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
  58.         //5.然后保存到ThreadLocal
  59.         UserHolder.saveUser(userDTO);
  60.         //6.刷新token有效期(30mins)
  61.         stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
  62.         //7.放行
  63.         return true;
  64.     }
  66.     @Override
  67.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  68.         //移除用户（根据当前线程，移除用户信息）
  69.         UserHolder.removeUser();
  70.     }
  71. }
复制代码
（2）修改配置类 MvcConfig.java
不能使用注解@Component将拦截器注入到spring容器中！！因为拦截器是在spring容器初始化之前执行的，因此这里使用构造器设置，在注册拦截器的时候去注入
2.3.2.4测试

（1）启动redis服务器，重启项目。
（2）输入手机号，输入验证码，点击登录
（3）成功登录，显示个人主页
（4）redis存储的数据如下：
短信验证码：
token：
测试通过。
2.3.3总结

（1）基于Redis实现实现短信登录改造的点：
（2）Redis代替Session需要考虑的问题：
2.3.4登录拦截器的优化

（1）问题分析
在之前的登录拦截器中，它的作用为：
但是，该拦截器不是拦截的所有请求，比如浏览首页的操作。当一个用户登录后，再去浏览首页，因为该操作不会经过登录拦截器，也就不会刷新token有效期，那么经过有限的时间内，用户的登录状态就会自动失效，这显然是不合理的。
（2）解决方案
我们可以再增加一个拦截器，该拦截器拦截所有路径，我们可以将刷新token的操作放到这个拦截器中进行，真正拦截的动作放到登录拦截器中进行。也就是说：
第一个拦截器的核心工作是得到用户，保存起来并刷新；
第二个拦截器的核心工作才是登录拦截。
（1）RefreshTokenInterceptor.java，token刷新拦截器（不进行真正的拦截）
  1. package com.hmdp.interceptor;
  3. import cn.hutool.core.bean.BeanUtil;
  4. import cn.hutool.core.util.StrUtil;
  5. import com.hmdp.dto.UserDTO;
  6. import com.hmdp.utils.UserHolder;
  7. import org.springframework.data.redis.core.StringRedisTemplate;
  8. import org.springframework.web.servlet.HandlerInterceptor;
  10. import javax.servlet.http.HttpServletRequest;
  11. import javax.servlet.http.HttpServletResponse;
  12. import java.util.Map;
  13. import java.util.concurrent.TimeUnit;
  15. import static com.hmdp.utils.RedisConstants.*;
  17. /**
  18. * @author 李
  19. * @version 1.0
  20. * 作用是刷新token，不进行拦截
  21. */
  22. public class RefreshTokenInterceptor implements HandlerInterceptor {
  23.     private StringRedisTemplate stringRedisTemplate;
  25.     public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
  26.         this.stringRedisTemplate = stringRedisTemplate;
  27.     }
  29.     @Override
  30.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  31.         //1.获取请求头中的token
  32.         String token = request.getHeader("authorization");
  33.         //如果浏览器的token为空,就放行，不用刷新了
  34.         if (StrUtil.isBlank(token)) {
  35.             return true;
  36.         }
  37.         //2.基于token获取redis中的用户
  38.         String key = LOGIN_USER_KEY + token;
  39.         Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
  40.         //3.判断用户是否存在
  41.         if (userMap.isEmpty()) {
  42.             return true;
  43.         }
  44.         //4.如果存在，将查询到的Hash数据转为UserDTO对象
  45.         UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
  46.         //5.然后保存到ThreadLocal
  47.         UserHolder.saveUser(userDTO);
  48.         //6.刷新token有效期(30mins)
  49.         stringRedisTemplate.expire(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
  50.         //7.放行
  51.         return true;
  52.     }
  54.     @Override
  55.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  56.         //移除用户（根据当前线程，移除用户信息）
  57.         UserHolder.removeUser();
  58.     }
  59. }
复制代码
（2）LoginInterceptor.java，检验是否需要拦截
  1. package com.hmdp.interceptor;
  3. import com.hmdp.utils.UserHolder;
  4. import org.springframework.web.servlet.HandlerInterceptor;
  6. import javax.servlet.http.HttpServletRequest;
  7. import javax.servlet.http.HttpServletResponse;
  9. /**
  10. * @author 李
  11. * @version 1.0
  12. * 登录拦截器
  13. */
  14. public class LoginInterceptor implements HandlerInterceptor {
  15.     @Override
  16.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
  17.         //判断是否需要拦截(ThreadLocal中是否有用户)
  18.         if (UserHolder.getUser() == null) {
  19.             //没有，需要拦截，设置状态码
  20.             response.setStatus(401);
  21.             //拦截
  22.             return false;
  23.         }
  24.         //如果有用户，则放行
  25.         return true;
  26.     }
  28.     @Override
  29.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
  30.         //移除用户（根据当前线程，移除用户信息）
  31.         UserHolder.removeUser();
  32.     }
  33. }
复制代码
（3）注册拦截器
  1. package com.hmdp.config;
  3. import com.hmdp.interceptor.LoginInterceptor;
  4. import com.hmdp.interceptor.RefreshTokenInterceptor;
  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;
  10. import javax.annotation.Resource;
  12. /**
  13. * @author 李
  14. * @version 1.0
  15. */
  16. @Configuration
  17. public class MvcConfig implements WebMvcConfigurer {
  18.     @Resource
  19.     private StringRedisTemplate stringRedisTemplate;
  21.     @Override
  22.     public void addInterceptors(InterceptorRegistry registry) {
  23.         //登录拦截器
  24.         registry.addInterceptor(new LoginInterceptor())
  25.                 .addPathPatterns().
  26.                 excludePathPatterns(
  27.                         "/shop/**",
  28.                         "/voucher/**",
  29.                         "/shop-type/**",
  30.                         "/upload/**",
  31.                         "/blog/hot",
  32.                         "/user/login",
  33.                         "/user/code"
  34.                 ).order(1);
  35.         //token刷新拦截器
  36.         registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate))
  37.                 .addPathPatterns("/**").order(0);
  38.     }
  39. }
复制代码
这样，无论我们在前端页面做什么操作，只要有token（登录过），都会刷新token的有效期

免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！



欢迎光临 ToB企服应用市场:ToB评测及商务社交产业平台 (https://dis.qidao123.com/) Powered by Discuz! X3.4