Redis实战案例2-基于Redis实现共享session短信登录

最新推荐文章于 2024-03-16 12:50:44 发布

码农.拉格朗日

最新推荐文章于 2024-03-16 12:50:44 发布

阅读量1.8k

点赞数

分类专栏： Redis 文章标签： redis java 数据库

本文链接：https://blog.csdn.net/qq_45681515/article/details/131223027

版权

Redis 专栏收录该内容

31 篇文章 1 订阅

订阅专栏

1. 实现Redis替代session的业务流程

在这里插入图片描述

保存用户登录信息采用Hash结构；
key要保证唯一，用随机生成的token（随机字符串）作为key；
并且要保证客户端可以携带key去redis取出value，之前采用session方式是Tomcat自动把session的id存入cookie，客户端访问会带着cookie访问服务端从而找到session；
这里不采用session方式的登录凭证，而是采取token作为凭证，之后登录携带token作为登录凭证（Tomcat不会自动帮我们携带，而是需要手动写，将token返回给前端，浏览器将会把token保存下来），之后访问就可以携带token去从redis中获取用户了；
登录凭证（token）存储在前端浏览器，为了保证信息的安全也证明了不能采用phone作为key；

在这里插入图片描述

在前端的有request拦截器，将用户token放入头中，所有Ajax请求都会携带请求头（token），之后在服务端获取该请求头，获取token从而实现登录验证，所以登录凭证是存储在前端浏览器的；

2. 业务实现

// 4. 保存验证码
// session.setAttribute("code", code);
stringRedisTemplate.opsForValue().set("login:code:" + phone, code, 2, TimeUnit.MINUTES);

这里存redis的写法可以用一个工具类来替代，方便代码阅读；

public class RedisConstants {
    public static final String LOGIN_CODE_KEY = "login:code:";
    public static final Long LOGIN_CODE_TTL = 2L;
    public static final String LOGIN_USER_KEY = "login:token:";
    public static final Long LOGIN_USER_TTL = 36000L;

    public static final Long CACHE_NULL_TTL = 2L;

    public static final Long CACHE_SHOP_TTL = 30L;
    public static final String CACHE_SHOP_KEY = "cache:shop:";

    public static final String LOCK_SHOP_KEY = "lock:shop:";
    public static final Long LOCK_SHOP_TTL = 10L;

    public static final String SECKILL_STOCK_KEY = "seckill:stock:";
    public static final String BLOG_LIKED_KEY = "blog:liked:";
    public static final String FEED_KEY = "feed:";
    public static final String SHOP_GEO_KEY = "shop:geo:";
    public static final String USER_SIGN_KEY = "sign:";
}

发送短信验证码的逻辑修改为

 @Resource
 private StringRedisTemplate stringRedisTemplate;
 @Override
 public Result sendCode(String phone, HttpSession session) {
     // 1. 校验手机号
     if (RegexUtils.isPhoneInvalid(phone)) {
         // 2. 如果不符合，返回错误信息(采用RegexUtils的isPhoneInvalid()方法，正则表达式判断手机格式是否正确)
         return Result.fail("手机号格式错误");
     }
     // 3. 符合，生成验证码(hutool工具类中到的随机生成方法)
     String code = RandomUtil.randomNumbers(6);
     // 4. 保存验证码
     // session.setAttribute("code", code);
     stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);
     // 5. 发送验证码(模拟发送)
     log.debug("发送短信验证码成功，验证码：{}", code);
     // 返回ok
     return Result.ok();
 }

短信验证码登录注册修改；
不采用session取出验证码，采用redis取出；
随机生成token，作为登录令牌；
将User对象转为Hash存储，因为存储在token字段下的值是一个对象，这个对象采用Hash存储，其中有很多属性字段，所以采用putAll()方法，该方法需要传入一个map参数，就需要BeanUtil工具类将对象转为map键值对的形式（使用该工具类需要导入hutool的坐标）；
需要设置token的有效期，例如30分钟，用户在30分钟只能未进行登录校验行为则失效，但是这里需要解决一个问题，那就是如果用户在有效期内使用了token，则要进行刷新，将有效期进行重置为30分钟，这里需要在登录校验处（登录校验拦截器）进行处理；

<!--hutool-->
<dependency>
    <groupId>cn.hutool</groupId>
    <artifactId>hutool-all</artifactId>
    <version>5.7.17</version>
</dependency>

@Override
public Result login(LoginFormDTO loginForm, HttpSession session) {
    // 1. 校验手机号(从表单中获取phone)
    String phone = loginForm.getPhone();
    if (RegexUtils.isPhoneInvalid(phone)) {
        // 如果不符合，返回错误信息(采用RegexUtils的isPhoneInvalid()方法，正则表达式判断手机格式是否正确)
        return Result.fail("手机号格式错误");
    }
    // 2. 校验验证码
    // 从之前存的session中取出验证码，然后和表单中的验证码进行比较
    // Object cacheCode = session.getAttribute("code");
    // 从redis中获取验证码并校验
    String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
    String code = loginForm.getCode();
    if(cacheCode == null || !cacheCode.toString().equals(code)){
        // 3. 不一致，报错(编码风格采用反向校验，避免出现菱形代码)
        return Result.fail("验证码错误");
    }
    // 4. 一致，根据手机号查询用户(extends ServiceImpl<UserMapper, User>，继承了MP，可以直接实现单表查询)
    User user = query().eq("phone", phone).one();
    // 5. 判断是否用户存在
    if(user == null) {
        // 6. 不存在，创建一个新用户并保存
        user = creatUserWithPhone(phone);
    }
    // 存在，保存用户信息到session中, 使用BeanUtil工具类，自动将user中的属性复制到UserDTO中，UserDTO对象
    // session.setAttribute("user", BeanUtil.copyProperties(user, UserDTO.class));
    // 7. 保存用户信息到redis中
    // 7.1 随机生成token，作为登录令牌
    String token = UUID.randomUUID().toString();
    // 7.2 将User对象转为Hash存储
    UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
    Map<String, Object> userMap = BeanUtil.beanToMap(userDTO);
    // 7.3 存储
    stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + token, userMap);
    // 7.4 设置token有效期
    stringRedisTemplate.expire(token, LOGIN_USER_TTL, TimeUnit.SECONDS);
    // 8. 返回token
    return Result.ok(token);
}

关键点：
在拦截器中引用stringRedisTemplate不能采用spring的自动注入，只能使用构造函数，因为LoginInterceptor的对象是手动创建的而不是spring的注解创建的，只有是spring创建的才能采用依赖注入；
在MvcConfig中用到了LoginInterceptor对象实现拦截放行，这里MvcConfig是由spring管理，所以可以在这里进行依赖注入；

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor(stringRedisTemplate))
                .excludePathPatterns(
                        "/user/code",
                        "/user/login",
                        "/blog/hot",
                        "/shop/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/voucher/**"
                );
    }
}

从而LoginInterceptor就拿到了stringRedisTemplate；
authorization是请求头名称，判断字符串为不为null采用StrUtil工具类；
获取redis中的用户用entries方法接收，并且也要做判断；
BeanUtil工具类对hash数据进行转换，转换为UserDTO对象；
最后对token进行刷新

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

关键点：
stringRedisTemplate.opsForHash().putAll(LOGIN_USER_KEY + token, userMap);当中stringRedisTemplate的key和value值都是string类型，但是在UserDTO中id是long类型，所以把userMap往stringRedisTemplate中写的时候出现了类型转换异常；
所以在把User对象转为HashMap存储时，都需要是string类型；
setFieldValueEditor()对key和value做自定义；

// 7.2 将User对象转为Hash存储
UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
// 自定义key和value
Map<String, Object> userMap = BeanUtil.beanToMap(userDTO, new HashMap<>(),
        CopyOptions.create().setIgnoreNullValue(true)
                            .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));

问题：
用户登录之后一直访问主界面，而主界面并没有设置登录校验（没有被拦截），此时token的有效期过了之后，用户还是继续要进行登录，这里存在不合理；
所以再加上一层拦截器，第一个拦截器查询redis中是否存在该用户，存在就保存不存在就不进行操作，同时都会进行token的刷新，放行；
第二个拦截器则只需要进行查询ThreadLocal的用户是否存在即可；

在这里插入图片描述

第一个拦截器RefreshTokenInterceptor

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 {
        // 1. 获取请求体中的token
        String token = request.getHeader("authorization");
        if(StrUtil.isBlank(token)) {
            // 不存在也直接放行
            return true;
        }
        // 2. 基于token获取redis中的用户
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(LOGIN_USER_KEY + token);
        // 3. 判断用户是否存在
        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(LOGIN_USER_KEY + token, LOGIN_USER_TTL, TimeUnit.SECONDS);
        // 8. 放行
        return true;
    }

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

第二个拦截器LoginInterceptor

public class LoginInterceptor implements HandlerInterceptor {

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


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

重新配置MvcConfig拦截器

@Configuration
public class MvcConfig implements WebMvcConfigurer {

    @Resource
    private StringRedisTemplate stringRedisTemplate;
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        registry.addInterceptor(new LoginInterceptor())
                .excludePathPatterns(
                        "/user/code",
                        "/user/login",
                        "/blog/hot",
                        "/shop/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/voucher/**"
                ).order(1);
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).order(0);
    }
}