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

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

Redis实战案例2-基于Redis实现共享session短信登录_第1张图片
Redis实战案例2-基于Redis实现共享session短信登录_第2张图片

保存用户登录信息采用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;

Redis实战案例2-基于Redis实现共享session短信登录_第3张图片

在前端的有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分钟,这里需要在登录校验处(登录校验拦截器)进行处理;


<dependency>
    <groupId>cn.hutoolgroupId>
    <artifactId>hutool-allartifactId>
    <version>5.7.17version>
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,继承了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的用户是否存在即可;

Redis实战案例2-基于Redis实现共享session短信登录_第4张图片

第一个拦截器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);
    }
}

你可能感兴趣的:(Redis,redis,java,数据库)