day02-功能实现02

功能实现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;
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实现实现短信登录改造的点：

• 发送短信验证码时，把短信验证码作为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;
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的有效期

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