背景

session 共享问题：如果后端服务是集群模式，由于多台机器之间并不共享 session 存储空间，当请求切换到不同服务时会导致数据丢失的问题
session 的替代方案应该满足：
1.数据共享
2.内存存储
3.key、value 结构
Redis 能够满足以上的要求，因此可以采用 Redis 来实现共享登录

实现流程

这里以短信登录的业务作为示例，主要包括三个功能：
1.发送短信验证码的接口
2.短信验证码登录、注册接口
3.校验登录状态拦截器
流程图如下所示：

这里采用的策略是，发送验证码时，将对应的手机号作为 key，验证码作为 value
登录、注册时，需要使用手机号将验证码取出，并且以随机 token 作为 key，用户信息作为 value 保存用户数据，这里的用户数据用 hash 类型保存。最后还需要将这个 token 返回给前端
之后在校验登录状态时，前端的每次请求都需要携带这个 token 值，以便服务端能取出相应的用户信息
这里使用随机 token 而不使用手机号作为 key 的目的在于，浏览器是需要存储这个 key 的，以便校验登录状态，如果使用手机号会不安全

代码实现


实体类

1. @Data
   
2. @EqualsAndHashCode(callSuper = false)
   
3. @Accessors(chain = true)
   
4. @TableName("tb_user")
   
5. public class User implements Serializable {
   
6. 
   
7.     private static final long serialVersionUID = 1L;
   
8. 
   
9.     /**
   
10.      * 主键
    
11.      */
    
12.     @TableId(value = "id", type = IdType.AUTO)
    
13.     private Long id;
    
14. 
    
15.     /**
    
16.      * 手机号码
    
17.      */
    
18.     private String phone;
    
19. 
    
20.     /**
    
21.      * 密码，加密存储
    
22.      */
    
23.     private String password;
    
24. 
    
25.     /**
    
26.      * 昵称，默认是随机字符
    
27.      */
    
28.     private String nickName;
    
29. 
    
30.     /**
    
31.      * 用户头像
    
32.      */
    
33.     private String icon = "";
    
34. 
    
35.     /**
    
36.      * 创建时间
    
37.      */
    
38.     private LocalDateTime createTime;
    
39. 
    
40.     /**
    
41.      * 更新时间
    
42.      */
    
43.     private LocalDateTime updateTime;
    
44. 
    
45. 
    
46. }

复制代码

dto 类

1. @Data
   
2. public class UserDTO {
   
3.     private Long id;
   
4.     private String nickName;
   
5.     private String icon;
   
6. }

复制代码

这里单独抽取 dto 的原因在于，我们不希望将密码等敏感字段返回给前端

1. @Data
   
2. public class LoginFormDTO {
   
3.     private String phone;
   
4.     private String code;
   
5.     private String password;
   
6. }

复制代码

结果返回类

1. @Data
   
2. @NoArgsConstructor
   
3. @AllArgsConstructor
   
4. public class Result {
   
5.     private Boolean success;
   
6.     private String errorMsg;
   
7.     private Object data;
   
8.     private Long total;
   
9. 
   
10.     public static Result ok(){
    
11.         return new Result(true, null, null, null);
    
12.     }
    
13.     public static Result ok(Object data){
    
14.         return new Result(true, null, data, null);
    
15.     }
    
16.     public static Result ok(List<?> data, Long total){
    
17.         return new Result(true, null, data, total);
    
18.     }
    
19.     public static Result fail(String errorMsg){
    
20.         return new Result(false, errorMsg, null, null);
    
21.     }
    
22. }

复制代码

常量类

1. public class RedisConstants {
   
2.     public static final String LOGIN_CODE_KEY = "login:code:";
   
3.     public static final Long LOGIN_CODE_TTL = 2L;
   
4.     public static final String LOGIN_USER_KEY = "login:token:";
   
5.     public static final Long LOGIN_USER_TTL = 30L;
   
6. }

复制代码

工具类

1. public class ObjectMapUtils {
   
2. 
   
3.     // 将对象转为 Map
   
4.     public static Map<String, String> obj2Map(Object obj) throws IllegalAccessException {
   
5.         Map<String, String> result = new HashMap<>();
   
6.         Class<?> clazz = obj.getClass();
   
7.         Field[] fields = clazz.getDeclaredFields();
   
8.         for (Field field : fields) {
   
9.             // 如果为 static 且 final 则跳过
   
10.             if (Modifier.isStatic(field.getModifiers()) && Modifier.isFinal(field.getModifiers())) {
    
11.                 continue;
    
12.             }
    
13.             field.setAccessible(true); // 设置为可访问私有字段
    
14.             Object fieldValue = field.get(obj);
    
15.             if (fieldValue != null) {
    
16.                 result.put(field.getName(), field.get(obj).toString());
    
17.             }
    
18.         }
    
19.         return result;
    
20.     }
    
21. 
    
22.     // 将 Map 转为对象
    
23.     public static Object map2Obj(Map<Object, Object> map, Class<?> clazz) throws Exception {
    
24.         Object obj = clazz.getDeclaredConstructor().newInstance();
    
25.         for (Map.Entry<Object, Object> entry : map.entrySet()) {
    
26.             Object fieldName = entry.getKey();
    
27.             Object fieldValue = entry.getValue();
    
28.             Field field = clazz.getDeclaredField(fieldName.toString());
    
29.             field.setAccessible(true); // 设置为可访问私有字段
    
30.             String fieldValueStr = fieldValue.toString();
    
31.             // 根据字段类型进行转换
    
32.             if (field.getType().equals(int.class) || field.getType().equals(Integer.class)) {
    
33.                 field.set(obj, Integer.parseInt(fieldValueStr));
    
34.             } else if (field.getType().equals(boolean.class) || field.getType().equals(Boolean.class)) {
    
35.                 field.set(obj, Boolean.parseBoolean(fieldValueStr));
    
36.             } else if (field.getType().equals(double.class) || field.getType().equals(Double.class)) {
    
37.                 field.set(obj, Double.parseDouble(fieldValueStr));
    
38.             } else if (field.getType().equals(long.class) || field.getType().equals(Long.class)) {
    
39.                 field.set(obj, Long.parseLong(fieldValueStr));
    
40.             } else if (field.getType().equals(String.class)) {
    
41.                 field.set(obj, fieldValueStr);
    
42.             } else if(field.getType().equals(LocalDateTime.class)) {
    
43.                 field.set(obj, LocalDateTime.parse(fieldValueStr));
    
44.             }
    
45. 
    
46.         }
    
47.         return obj;
    
48.     }
    
49. 
    
50. }

复制代码

控制层

1. @Slf4j
   
2. @RestController
   
3. @RequestMapping("/user")
   
4. public class UserController {
   
5.     @Resource
   
6.     private IUserService userService;
   
7.    
   
8.     /**
   
9.      * 发送手机验证码
   
10.      */
    
11.     @PostMapping("code")
    
12.     public Result sendCode(@RequestParam("phone") String phone) {
    
13.         return userService.sendCode(phone);
    
14.     }
    
15.    
    
16.     /**
    
17.      * 登录功能
    
18.      * @param loginForm 登录参数，包含手机号、验证码；或者手机号、密码
    
19.      */
    
20.     @PostMapping("/login")
    
21.     public Result login(@RequestBody LoginFormDTO loginForm){
    
22.         return userService.login(loginForm);
    
23.     }
    
24. }

复制代码

服务层

1. @Service
   
2. public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
   
3. 
   
4.     @Autowired
   
5.     private StringRedisTemplate redisTemplate;
   
6. 
   
7.     @Override
   
8.     public Result sendCode(String phone/*, HttpSession session*/) {
   
9.         // 校验手机号
   
10.         if(RegexUtils.isPhoneInvalid(phone)) {
    
11.             return Result.fail("手机号格式错误");
    
12.         }
    
13.         // 生成验证码
    
14.         String code = RandomUtil.randomNumbers(6);
    
15.         /*// 保存验证码到 session
    
16.         session.setAttribute("code", phone + "-" + code);*/
    
17.         // 保存验证码到 redis
    
18.         redisTemplate.opsForValue().set(RedisConstants.LOGIN_CODE_KEY + phone, code,
    
19.                 RedisConstants.LOGIN_CODE_TTL, TimeUnit.MINUTES);
    
20.         // 发送验证码
    
21.         log.debug("发送验证码：" + code + "，手机号：" + phone);
    
22.         return Result.ok();
    
23.     }
    
24. 
    
25.     @Override
    
26.     public Result login(LoginFormDTO loginForm/*, HttpSession session*/) {
    
27.         String phone = loginForm.getPhone();
    
28.         String code = loginForm.getCode();
    
29.         /*// 从 session 取出手机号和验证码
    
30.         String[] phoneAndCode = session.getAttribute("code").toString().split("-");
    
31.         // 校验手机号和验证码
    
32.         if(!phoneAndCode[0].equals(phone) || !phoneAndCode[1].equals(code)) {
    
33.             return Result.fail("手机号或验证码错误");
    
34.         }*/
    
35.         // 从 redis 中取出验证码
    
36.         String realCode = redisTemplate.opsForValue().get(RedisConstants.LOGIN_CODE_KEY + phone);
    
37.         if(StringUtils.isBlank(realCode) || !realCode.equals(code)) {
    
38.             return Result.fail("验证码错误");
    
39.         }
    
40.         // 根据手机号查询用户
    
41.         LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
    
42.         queryWrapper.eq(User::getPhone, phone);
    
43.         User user = this.getOne(queryWrapper);
    
44.         // 用户如果不存在，则创建新用户
    
45.         if(user == null) {
    
46.             user = createUserWithPhone(phone);
    
47.         }
    
48.         /*// session 保存用户信息
    
49.         session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));*/
    
50.         // redis 保存用户信息
    
51.         String token = UUID.randomUUID().toString(true);
    
52.         String tokenKey = RedisConstants.LOGIN_USER_KEY + token;
    
53.         try {
    
54.             // 将 User 转为 UserDTO 再转为 Map
    
55.             Map<String, String> userMap = ObjectMapUtils.obj2Map(BeanUtil.copyProperties(user, UserDTO.class));
    
56.             redisTemplate.opsForHash().putAll(tokenKey, userMap);
    
57.             redisTemplate.expire(tokenKey, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
    
58.         } catch (IllegalAccessException e) {
    
59.             throw new RuntimeException(e);
    
60.         }
    
61.         // 将 token 返回
    
62.         return Result.ok(token);
    
63.     }
    
64. 
    
65.     // 根据手机号创建新用户
    
66.     public User createUserWithPhone(String phone) {
    
67.         User user = new User();
    
68.         user.setPhone(phone);
    
69.         user.setNickName(SystemConstants.USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
    
70.         // 保存至数据库
    
71.         this.save(user);
    
72.         return user;
    
73.     }
    
74. 
    
75. }

复制代码

拦截器及其配置类

这里会使用两个拦截器，一个是拦截一切路径的刷新拦截器，主要用途就是如果用户在 token 有效期内访问了系统，那么就会刷新超时时间；另一个是拦截部分路径的登录校验拦截器，主要就是检验用户是否登录
添加刷新拦截器的原因在于，如果用登录校验拦截器进行刷新工作，由于排除了部分路径，因此如果用户一直访问这些被排除的部分路径，会导致用户 token 的有效期不会被刷新。所以需要单独添加一个拦截所有路径的拦截器

1. @Configuration
   
2. public class MvcConfig implements WebMvcConfigurer {
   
3. 
   
4.     @Autowired
   
5.     private StringRedisTemplate redisTemplate;
   
6. 
   
7.     @Override
   
8.     public void addInterceptors(InterceptorRegistry registry) {
   
9.         // 刷新拦截器
   
10.         registry.addInterceptor(new RefreshTokenInterceptor(redisTemplate)).order(10);
    
11.         // 登录拦截器
    
12.         registry.addInterceptor(new LoginInterceptor())
    
13.                 .excludePathPatterns( // 排除的拦截路径
    
14.                                // 以下根据业务需求来写
    
15.                         "/shop/**",
    
16.                         "/voucher/**",
    
17.                         "/shop-type/**",
    
18.                         "/upload/**",
    
19.                         "/blog/hot",
    
20.                         "/user/code",
    
21.                         "/user/login"
    
22.                 ).order(20);
    
23.     }
    
24. }

复制代码

1. public class RefreshTokenInterceptor implements HandlerInterceptor {
   
2. 
   
3.     private StringRedisTemplate redisTemplate;
   
4. 
   
5.     public RefreshTokenInterceptor(StringRedisTemplate redisTemplate) {
   
6.         this.redisTemplate = redisTemplate;
   
7.     }
   
8. 
   
9.     @Override
   
10.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    
11.         // 获取用户
    
12.         String token = request.getHeader("authorization");
    
13.         String key = RedisConstants.LOGIN_USER_KEY + token;
    
14.         Map<Object, Object> entries = redisTemplate.opsForHash().entries(key);
    
15.         // 用户不存在，直接放行
    
16.         if(entries.isEmpty()) {
    
17.             return true;
    
18.         }
    
19.         // Map 转为 UserDTO
    
20.         UserDTO user = (UserDTO) ObjectMapUtils.map2Obj(entries, UserDTO.class);
    
21.         // 用户存在，放入 ThreadLocal
    
22.         UserHolder.saveUser(user);
    
23.         // 刷新 token 有效期
    
24.         redisTemplate.expire(key, RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
    
25.         // 放行
    
26.         return true;
    
27.     }
    
28. 
    
29.     @Override
    
30.     public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
    
31.         // 销毁 ThreadLocal
    
32.         UserHolder.removeUser();
    
33.     }
    
34. 
    
35. }

复制代码

1. public class LoginInterceptor implements HandlerInterceptor {
   
2. 
   
3.     @Override
   
4.     public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) {
   
5.         // 用户未登录，拦截
   
6.         if(UserHolder.getUser() == null) {
   
7.             response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
   
8.             return false;
   
9.         }
   
10.         return true;
    
11.     }
    
12. 
    
13. }

复制代码

到此这篇关于基于Redis实现共享Session登录的实现的文章就介绍到这了,更多相关Redis Session共享登录内容请搜索脚本之家以前的文章或继续浏览下面的相关文章希望大家以后多多支持脚本之家！

来源：https://www.jb51.net/database/337078m4q.htm
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！