使用redis实现手机号登录

咤娃勇闯天涯

已于 2024-03-21 18:15:36 修改

阅读量854

点赞数 12

文章标签： redis java

于 2024-03-21 18:14:30 首次发布

本文链接：https://blog.csdn.net/TTruYi/article/details/136851501

版权

用redis做手机号登录的实现

1.controller(控制层)：验证码服务

（1）前端调用后端的发送验证码接口(需要的参数:手机号)。

（2）调用户业务层发送验证码方法，传入phone。

    @PostMapping("code")
    public Result sendCode(@RequestParam("phone") String phone) {
        // 发送短信验证码并保存验证码

        return userService.sendCode(phone);
    }

2.service(业务层)：验证码服务

(1) 验证手机号格式是否正确(手机号格式验证使用正则表达式，不会百度)，不符合返回错误信息(手机号格式有误)。

(2) 格式正确，生成验证码。

(3) 保存验证码到redis以字符串数据结构(key:login:code+phone 、value:code)。

(4)设置有效期为两分钟。

(5)发送验证码。

(6)返回ok对象。

  @Override
    public Result sendCode(String phone) {
        // 1.校验手机号
        // 2.如果不符合，返回错误信息
        if (RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式有误");
        }

        // 3.符合，生成验证码
        String code = RandomUtil.randomNumbers(6);

        // 4.保存验证码到redis //set key value ex 120
        stringRedisTemplate.opsForValue().set(RedisConstants.LOGIN_CODE_KEY + phone ,code,RedisConstants.LOGIN_CODE_TTL, TimeUnit.MINUTES);
        // 5.发送验证码
        log.debug("发送短信验证码成功,验证码:" + code);
        // 返回ok
        return Result.ok();
    }

3.controller(控制层)：登录服务

（1）前端调用后端的login接口(需要的参数：手机号、验证码)。

（2）调用用户业务层的login方法传入表单信息。

 @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm){
 
        return userService.login(loginForm);
    }

4.service(业务层)：登录服务

（1）验证手机号格式是否正确，不符合返回错误信息（手机号格式有误）。

（2）验证验证码是否和之前发送的验证码是否一致，不一致返回错误信息：验证码有误。

（3）验证无误，根据手机号查询用户是否存在，存在返回user对象，不存在则新增用户。

（4）保存用户信息到redis中。

（5）使用UUID随机生成token，作为登录令牌。（UUID：具有全局唯一性，随机性）

(6) 将User对象转为HashMap存储。

(7) 存储用户信息到redis(采用hash结构：可以针对单个字段进行快速的读取和更新操作，提高查询效率) 。

(8) 返回ok结果对象包含(token)。

  @Override
    public Result login(LoginFormDTO loginForm) {

        // 1.检验手机号
        if (RegexUtils.isPhoneInvalid(loginForm.getPhone())) {
           return Result.fail("手机号格式有误");
        }
        // 2.检验验证码（从redis获取验证码并验证）
        String code = stringRedisTemplate.opsForValue().get(RedisConstants.LOGIN_CODE_KEY + loginForm.getPhone());
        // 3.不一致，报错
        if(loginForm.getCode() == null || !loginForm.getCode().equals((code))){
            return Result.fail("验证码有误");
        }
        // 4.一致根据手机号查询用户
        User user = query().eq("phone", loginForm.getPhone()).one();
        // 5.判断用户是否存在

        if(user == null){
            // 6.不存在，创建用户并保存
            user = createUserWithPhone(loginForm.getPhone());

        }

        // 7，保存用户信息到redis中
        // 7.1随机生成token,作为登录令牌
        String token = UUID.randomUUID().toString(true);
        // 7.2 将User对象转为HashMap存储
        UserDTO userDTO = BeanUtil.copyProperties(user,UserDTO.class);
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
                CopyOptions.create().setIgnoreNullValue(true).setFieldValueEditor((fieldName,fieldValue)-> fieldValue.toString()));
        // 7.3 存储
        String toToken = RedisConstants.LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(toToken,userMap);
        stringRedisTemplate.expire(toToken,30,TimeUnit.MINUTES);
        // 8.返回token
        return Result.ok(token);
    }

5.自定义拦截器

（1）创建一个类LoginInterceptor实现HandlerInterceptor 的预处理方法preHandle()。

（2）获取请求头中的token。

（3）没有token拦截，返回false。设置状态码为401（未授权）。

（3）基于token获取redis中的用户（用于验证token是否过期）。

（4）不存在拦截，返回false。设置状态码为401（未授权）。

（5）将从redis中获取到的用户hash结构数据转为userDto对象。

(6) 把userDto对象存储到到ThreadLocal(让每一个线程之间有一个独立的副本，保证线程之间的数据隔离)。

（7）刷新token有效期（让用户能够持续使用系统而不会因为 token 过期而突然被强制下线）。

（8）实现HandlerInterceptor的方法afterCompletion()，清除ThreadLocal的用户数据避免内存泄漏。

 @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 获取请求头中的token
        String token = request.getHeader("authorization");
        //
        if(StrUtil.isBlank(token)){
            response.setStatus(401);
            // 4.不存在，拦截
            return false;
        }
       // 2.基于token获取redis中的用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(RedisConstants.LOGIN_USER_KEY + token);
        // 3.判断用户是否存在
        if(userMap.isEmpty()){
            response.setStatus(401);
            // 4.不存在，拦截,返回401状态码
            return false;
        }
        // 5.将查询到的Hash数据转为userDto对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6.保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
        // 7.刷新token有效期
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token,30, TimeUnit.MINUTES);
        // 8.放行
        return true;
    }

    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserHolder.removeUser();
    }

6.注册拦截器配置Spring-MVC行为。

（1）创建一个MvcConfig类实现WebMvcConfigurer的自定义拦截方法addInterceptors()用于配置Spring MVC拦截的行为。

（2）调用registry.addInterceptor()方法传入登录拦截对象LoginInterceptor 注册自定义拦截器。

(3) 调用excludePathPatterns配置请求不被拦截器拦截：如login请求。

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {

       registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
               .excludePathPatterns(
                       "/shop/**",
                       "/shop-type/**",
                       "/upload/**",
                       "/blog/hot",
                       "/user/code",
                       "/user/login"
               );
    }
}

通过以上拦截的路径，我们不难发现如果我们访问公开的网页就不会去刷新token有效期。为了提高用户体验，防止用户突然下线。我们改造Spring-MVC的拦截行为。

-------------------------------------------------------------------------------------------------------------------------------

7.改造Spring-MVC拦截行为。

一、创建RefreshTokenInterceptor（拦截所有路径）

（1）创建第二个自定义拦截器类名为RefreshTokenInterceptor实现HandlerInterceptor的preHandle()方法（这个类只做刷新操作）。

（2）获取请求头中的token。token为空放行(true)。

（3）基于token获取redis中的用户。用户为空放行(true)。

（4）将查询到的用户信息转为userDto对象。

（5）保存用户信息到ThreadLocal。

（6）刷新token有效期。

（7）放行。

 @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1. 获取请求头中的token
        String token = request.getHeader("authorization");
        // 2. token为空 放行
        if(StrUtil.isBlank(token)){
            return true;
        }
       // 2.基于token获取redis中的用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(RedisConstants.LOGIN_USER_KEY + token);
        if(userMap.isEmpty()){
            return true;
        }
        // 5.将查询到的Hash数据转为userDto对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        // 6.保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
        // 7.刷新token有效期
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token,30, TimeUnit.MINUTES);
        // 8.放行
        return true;
    }

二、修改LoginInterceptor（只拦截需要做权限验证的路径）

(1) 这个拦截器只需要判断ThreadLocal中有没有用户信息，有用户信息就放行，没有拦截。

（2）请求完移除ThreadLocal中的用户信息（避免内存泄漏）。

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1，判断是否需要拦截（ThreadLocal中是否有用户）
            if(UserHolder.getUser() == null){
                // 没有需要拦截，设置状态码为401
                response.setStatus(401);
                return false;
            }
            //有用户则放行
        return true;
    }

   @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserHolder.removeUser();
    }

三、修改MvcConfig配置文件

（1）通过order()方法修改LoginInterceptor的优先级，设置优先级为1。 (order()用于指定拦截器的顺序,数值越大执行优先级越低)

（2）注册RefreshTokenInterceptor拦截所有路径，设置优先级为0。

    @Override
    public void addInterceptors(InterceptorRegistry registry) {

       registry.addInterceptor(new LoginInterceptor())
               .excludePathPatterns(
                       "/shop/**",
                       "/shop-type/**",
                       "/upload/**",
                       "/blog/hot",
                       "/user/code",
                       "/user/login"
               ).order(1);
       registry.addInterceptor((new RefreshTokenInterceptor(stringRedisTemplate))).addPathPatterns("/**").order(0);
    }