Redis进行验证码登录的项目实践

    @PostMapping("code")
    public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
        //发送短信验证码并保存验证码
        return userService.sendCode(phone,session);
    }

 /**
     * 是否是无效手机格式
     * @param phone 要校验的手机号
     * @return true:符合，false：不符合
     */
    public static boolean isPhoneInvalid(String phone){
        return mismatch(phone, RegexPatterns.PHONE_REGEX);
    }
    /**

 /**
     * 手机号正则
     */
    public static final String PHONE_REGEX = "^1([38][0-9]|4[579]|5[0-3,5-9]|6[6]|7[0135678]|9[89])\\d{8}$";

 /**
     * 发送短信验证码
     * @return
     */
    @Override
    public Result sendCode(String phone, HttpSession session) {
        //1.校验手机号

        if(RegexUtils.isPhoneInvalid(phone)){
            //不符合
            return Result.fail("手机号格式错误");
        }
        //符合
        //2.生成验证码
        String code = RandomUtil.randomNumbers(6);
        //3.保存验证码到seesion
        session.setAttribute("code",code);
        //4.发送验证码
        log.debug("发送成功，验证码为:{}", code);


        return Result.ok();
    }

    /**
     * 登录功能
     * @param loginForm 登录参数，包含手机号、验证码；或者手机号、密码
     */
    @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
        //实现登录功能
        return userService.login(loginForm,session);
    }

@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //1.校验手机号
        String phone = loginForm.getPhone();
        if(RegexUtils.isPhoneInvalid(phone)){
            //不一致
            return Result.fail("手机号格式错误");
        }
        //一致
        //2.校验验证码
        //先在session中取出验证码
        Object cacheCode = session.getAttribute("code");
        String code = loginForm.getCode();//前端提交的code
        //不一致
        if(cacheCode==null || !cacheCode.toString().equals(code)){
            return Result.fail("验证码已过期或错误");
        }
            //重新提交验证码
        //一致
        //3.根据手机号查询用户
        User user = query().eq("phone",phone).one();
        //用户不存在
        if(user==null){
            //创建新用户并保存到数据库
            user =  creatUserWithPhone(phone);
            //保存用户到session 在最后一步完成
        }

        //用户存在
        //保存用户到session
        //将user转为dto储存
        session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));

        return Result.ok();
    }

private User creatUserWithPhone(String phone) {

        //1.创建用户
        //由于新用户大部分创建时都有默认参数，因此我们只需要将手机号和昵称传入即可,昵称随机
        //逻辑和大部分创建新用户的软件逻辑一样
        User user = new User();
        user.setPhone(phone);
        user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));

        //2.保存到数据库
        save(user);
        return null;
    }

//校验登录状态
public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //首先由于请求里面带有cookie,我们的request参数例就有session，我们只需要在里面取出即可

        //1.获取session
        HttpSession session = request.getSession();


        //2.获取session中的用户
        Object user = session.getAttribute("user");
        //3.判断用户是否存在
        if(user== null){
            //不存在，拦截,返回false即可拦截,返回401状态码
            response.setStatus(401);
            return false;
        }

        //存在，将用户保存到ThreadLocal中
        UserHolder.saveUser((UserDTO) user);
        //放行
        return true;
    }

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

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    //配置拦截器
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
       registry.addInterceptor(new LoginInterceptor())
               .excludePathPatterns(
                //排除一些路径，不需要拦截的地方
                       //如一些页面可以不需要登录校验
                       "/user/code",
                       "/user/login",
                       "/blog/hot",//查看热点，也与登录无关，可以放行
                       "/shop/**",
                       "/shop-type/**",
                       "/upload/**",
                       "/voucher/**"

               );
    }

        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-data-redis</artifactId>
        </dependency>

    @Resource
    private StringRedisTemplate stringRedisTemplate;

        //3.保存验证码到seesion
//        session.setAttribute("code",code);
        //在key里加上一个前缀来和其他业务里的phone来区分
        //然后设置一个有效期
        stringRedisTemplate.opsForValue().set("login:code:"+phone,code,2, TimeUnit.MINUTES);

 //从Redis获取验证码并校验
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY+phone);
        String code = loginForm.getCode();//前端提交的code

        //保存用户到Redis中

        //3.1生成token作为登录令牌
        String token = UUID.randomUUID().toString(true);
        //3.2将USer对象转为HashMap存储
        UserDTO userDTO= BeanUtil.copyProperties(user,UserDTO.class);
        Map<String,Object> userMap= BeanUtil.beanToMap(userDTO);
        //3.3存储,利用putALL,key可以是多个值，即hashMap,然后设置有效期
        String tokenKey= LOGIN_CODE_KEY+token;
        stringRedisTemplate.opsForHash().putAll(tokenKey,userMap);
        //设置有效期
        stringRedisTemplate.expire(tokenKey,LOGIN_USER_TTL,TimeUnit.MINUTES);
        //但是还有一个问题，就是有效期的逻辑是,只要是在有效期内无论进行访问，只要有效期到了就失效，不会重置有效期
        //因此我们要进行修改逻辑，修改为，只要三十分钟内访问过了就重置有效期，又可以过三十分钟过期

        //我们就可以利用拦截器来实现，只要访问了请求，即触发了拦截器，就实现更新有效期的操作
        //8.返回token给前端
        return Result.ok();

//1.获取请求头中的token,根据前端返回的名字来获取
        String token= request.getHeader("authorization");
        if(StrUtil.isBlank(token)){
            response.setStatus(401);
            return false;
        }


        //2.基于token获取redis中的用户,利用entries来获取所有key里的值组成hashMap
       Map<Object,Object> userMap= stringRedisTemplate.opsForHash().entries(RedisConstants.LOCK_SHOP_KEY+token);
        //3.判断用户是否存在
        if(userMap.isEmpty()){
            //不存在，拦截,返回false即可拦截,返回401状态码
            response.setStatus(401);
            return false;
        }
        //将查询到的hash转为userDto对象
       UserDTO userDTO= BeanUtil.fillBeanWithMap(userMap,new UserDTO(),false);
        //存在，将用户保存到ThreadLocal中
        UserHolder.saveUser(userDTO);

        //刷新token有效期
        stringRedisTemplate.expire(RedisConstants.LOCK_SHOP_KEY+token,30, TimeUnit.MINUTES);
        //放行
        return true;