Redis实现短信登录

最新推荐文章于 2024-07-09 21:55:58 发布

qq_52425637

最新推荐文章于 2024-07-09 21:55:58 发布

阅读量180

点赞数

分类专栏： redis 文章标签： java redis 缓存

本文链接：https://blog.csdn.net/qq_52425637/article/details/128729112

版权

redis 专栏收录该内容

4 篇文章 0 订阅

订阅专栏

文章详细介绍了如何通过Session实现短信登录功能，包括手机号校验、验证码生成与校验、用户登录及状态校验。接着讨论了Session存在的问题，如多台Tomcat间不共享数据，然后展示了如何利用Redis来优化Session，包括验证码存储、登录功能的改进以及使用拦截器刷新Token的有效期。文章最后提到了安全性和持久化用户信息的注意事项。

摘要由CSDN通过智能技术生成

学习目标

通过session实现短信登录并了解优缺点
通过redis改良短信登录

学习内容

sesion实现短信登录

生成验证码

用户提交手机号到后台，后台会对手机号进行校验，如果不合法会返回信息给用户。

如果合法，后台生成验证码并保存至session

    @Override
    public Result sendCode(String phone, HttpSession session) {
        // 1.校验手机号
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.符合，生成验证码
        String code = RandomUtil.randomNumbers(6);

        // 4.保存验证码到 session
        session.setAttribute("code",code);
        // 5.发送验证码
        log.debug("发送短信验证码成功，验证码："+code);
        // 返回ok
        return Result.ok();
    }

短信验证码登录或注册

用户将验证码和手机号进行输入，后台从session中拿到当前验证码，然后和用户输入的验证码进行校验，如果不一致，则无法通过校验，如果一致，则后台根据手机号查询用户，如果用户不存在，则为用户创建账号信息，保存到数据库，无论是否存在，都会将用户信息保存到session中，方便后续获得当前登录信息

 @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.校验验证码
        Object cacheCode = session.getAttribute("code");
        String code = loginForm.getCode();
        if(cacheCode == null || !cacheCode.toString().equals(code)){
             //3.不一致，报错
            return Result.fail("验证码错误");
        }
        //一致，根据手机号查询用户
        User user = query().eq("phone", phone).one();

        //5.判断用户是否存在
        if(user == null){
            //不存在，则创建
            user =  createUserWithPhone(phone);
        }
        //7.保存用户信息到session中
        session.setAttribute("user",user);

        return Result.ok();
    }

这段代码有点小问题，应该将存储验证码的key设置为手机号，不然拿到验证码后随便一个手机号都可以登录 [滑稽]，不过毕竟主要是学习redis，此处就没有仔细改了。

校验登录状态

用户在请求时候，会从cookie中携带者JsessionId到后台，后台通过JsessionId从session中拿到用户信息，如果没有session信息，则进行拦截，如果有session信息，则将用户信息保存到threadLocal中，并且放行

编写拦截器，拦截需要登陆后才能访问的代码

public class LoginInterceptor implements HandlerInterceptor {

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
       //1.获取session
        HttpSession session = request.getSession();
        //2.获取session中的用户
        Object user = session.getAttribute("user");
        //3.判断用户是否存在
        if(user == null){
              //4.不存在，拦截，返回401状态码
              response.setStatus(401);
              return false;
        }
        //5.存在，保存用户信息到Threadlocal
        UserHolder.saveUser((User)user);
        //6.放行
        return true;
    }
}

注册拦截器

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 登录拦截器
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
        // token刷新的拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    }
}

可以看见的是上述代码存入threadLocal是整个user对象，后台会将所有的user信息返回到前台，这样会导致信息不安全，所以创建UserDTO类来代替User返回至前台。

UserDTO类：

@Data
public class UserDTO {
    private Long id;
    private String nickName;
    private String icon;
}

修改登录代码

//7.保存用户信息到session中
session.setAttribute("user", BeanUtils.copyProperties(user,UserDTO.class));

拦截器部分

//5.存在，保存用户信息到Threadlocal
UserHolder.saveUser((UserDTO) user);

到此为止通过session来实现短信登录就完成了，接下来就是使用redis来优化了。

Redis优化实现

Session存在的问题

多台tomcat并不共享session存储空间，当请求切换到不同的tomcat服务时导致数据丢失的问题。

数据结构选择

验证码采用字符串储存到redis中，需要展示的信息采用hash存储到redis中。

优化验证码生成

生成验证码这块大部分代码都不需要修改，主要是修改储存方式，验证码存储的key采用phone与手机号进行拼接。

@Override
    public Result sendCode(String phone, HttpSession session) {
        //1.校验手机号
        if (RegexUtils.isPhoneInvalid(phone)){
            //2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误");
        }
        //3.符合生成校验码
        String code = RandomUtil.randomNumbers(6);
//        session.setAttribute("code",code);
        //保存验证码到redis
        redisTemplate.opsForValue().set(LOGIN_CODE_KEY+phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES);
        //4.发送校验码
        log.debug("发送短信验证码成功，验证码为：{}",code);
        //返回ok
        return Result.ok();
    }

优化登录功能

用户进行登录后，需要较长时间保存用户信息，此时再采用phone做为key就不合适了，所以此处采用token来作为key，当用户登录后访问界面，发送请求时，在请求头中携带这个token来访问redis中用户的信息。

登录功能：

@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //1.校验手机号
        String phone=loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)){
            //2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误");
        }
        //2.校验验证码
        String cacheCode = redisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
        String code=loginForm.getCode();
        if (cacheCode == null || !cacheCode.equals(code)) {
            //3.不一致报错
            return Result.fail("验证码错误");
        }
        //4.一致，查询用户
        User user = query().eq("phone", phone).one();
        //5.判断用户是否存在
        if(user==null){
            //6.不存在，创建用户
            user=createUserWithPhone(phone);
        }
        //7.保存用户信息到redis
        //生成token
        String token = UUID.randomUUID().toString(true);
        //将user保存到hash
        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()));
        redisTemplate.opsForHash().putAll(LOGIN_USER_KEY+token,userMap);
        redisTemplate.expire(LOGIN_USER_KEY+token,LOGIN_USER_TTL, TimeUnit.MINUTES);
        //返回token
        return Result.ok(token);
    }

当然，仅仅是登录一次，也只是将登录的用户信息保存在redis一段时间，为保证用户长时间操作，我们需要将被保存在redis的信息的过期时间进行刷新，当用户访问一个新的界面时就进行刷新过期时间。此时之前的登录拦截就不够用了，所以需要建立一个新的拦截器来专门进行刷新过期时间。

拦截器

package com.xndianping.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.xndianping.dto.UserDTO;
import org.apache.ibatis.plugin.Interceptor;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.ModelAndView;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.util.Map;
import java.util.concurrent.TimeUnit;

import static com.xndianping.utils.RedisConstants.LOGIN_USER_KEY;
import static com.xndianping.utils.RedisConstants.LOGIN_USER_TTL;

public class RefreshTokenInterceptor implements HandlerInterceptor {
    private StringRedisTemplate stringRedisTemplate;
    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate){
        this.stringRedisTemplate=stringRedisTemplate;
    }
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //从请求头获取token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
          return true;
        }
        //获取用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY+token);
        //判断用户是否存在
        if(userMap.isEmpty()){
          return true;
        }
        //将hash数据转换为对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        //存在，保存用户信息到ThreadLocal
        UserHolder.saveUser(userDTO);
        //刷新token有效期
        stringRedisTemplate.expire(LOGIN_USER_KEY+token,LOGIN_USER_TTL, TimeUnit.MINUTES);
        //放行
        return true;
    }

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

注册拦截器

@Configuration
public class MvcConfig implements WebMvcConfigurer {
    @Autowired
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns("/user/code","/user/login","/blog/hot","/shop/**","/sho-type/**","/upload/**","/voucher/**").order(1);
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);//order值越大，越后执行
    }
}

到此为止，redis实现短信登陆就完成了，当然这仅仅是我所学习到的。

此文章仅供本人学习使用，如有问题，欢迎各位大佬指正与交流。