day02-功能实现02

打印 上一主题 下一主题

主题 917|帖子 917|积分 2751

功能实现02

2.功能01-短信登录

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;
  3. @Override
  4. public Result sendCode(String phone, HttpSession session) {
  5.     //1.校验手机号
  6.     boolean phoneInvalid = RegexUtils.isPhoneInvalid(phone);
  7.     //2.如果不符合,返回错误信息
  8.     if (phoneInvalid) {//true表示不符合格式
  9.         return Result.fail("手机号格式错误!");
  10.     }
  11.     //3.符合,生成验证码
  12.     String code = RandomUtil.randomNumbers(6);//生成6位数的随机号码
  13.     //4.保存验证码到 redis中,这里的 key 最好使用业务前缀作为区分
  14.     // set key value ex
  15.     stringRedisTemplate.opsForValue()
  16.             .set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);
  17.    
  18.     //5.发送验证码(由于这里涉及到一些其他方的工具,先不做)
  19.     log.debug("发送短信验证码成功,验证码={}", code);
  20.     //6.返回OK
  21.     return Result.ok();
  22. }
复制代码
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.     }
  9.     //2.从redis获取验证码并校验
  10.     String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
  11.     String code = loginForm.getCode();
  12.     if (cacheCode == null || !cacheCode.equals(code)) {
  13.         return Result.fail("验证码错误");
  14.     }
  15.     //3.根据手机号查询用户是否已经注册
  16.     User user = query().eq("phone", phone).one();
  17.     if (user == null) {
  18.         //若不存在,则在创建用户
  19.         user = createUserWithPhone(phone);
  20.     }
  21.     //4.保存用户到redis中 (这里只保存id、昵称、手机号)
  22.     //随机生成token,作为登录令牌
  23.     String token = UUID.randomUUID().toString(true);
  24.     //将user对象转为redis-hash
  25.     UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
  26.     //使用工具类转(指定转换后的数据类型为String)
  27.     Map<String, Object> map = BeanUtil.beanToMap(userDTO, new HashMap<>(),
  28.                     CopyOptions.create()
  29.                     .setIgnoreNullValue(true)
  30.                             .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
  31.     //存储到redis中,设置有效期为30分钟
  32.     stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + token, map);
  33.     stringRedisTemplate.expire(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.MINUTES);
  34.     //5.将token返回客户端
  35.     return Result.ok(token);
  36. }
复制代码
2.3.2.3校验登录状态

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

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

(1)基于Redis实现实现短信登录改造的点:

  • 发送短信验证码时,把短信验证码作为value,使用手机号作为key,存入redis中。
    确保了:a.每个手机号都有唯一的验证码;b.用户登录时可以基于手机号来获取验证码,从而实现验证
  • 短信登录时,保存用户信息到redis(key-token,value-用户信息),同时返回token给用户浏览器,保存在浏览器的SessionStorage。每次校验登录状态,都会从中取出token进行校验。
(2)Redis代替Session需要考虑的问题:

  • 选择合适的数据结构
  • 选择合适的key
  • 选择合适的存储粒度
2.3.4登录拦截器的优化

(1)问题分析
在之前的登录拦截器中,它的作用为:

  • 获取token
  • 查询redis的用户

    • 若存在,则继续
    • 若不存在,则拦截

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

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

本帖子中包含更多资源

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

x
回复

使用道具 举报

0 个回复

倒序浏览

快速回复

您需要登录后才可以回帖 登录 or 立即注册

本版积分规则

怀念夏天

金牌会员
这个人很懒什么都没写!

标签云

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