黑马点评实现登录功能--基于redis（通俗易懂）

最新推荐文章于 2025-12-17 20:46:39 发布

原创最新推荐文章于 2025-12-17 20:46:39 发布 · 506 阅读

5 ·

CC 4.0 BY-SA版权

文章标签：

#redis #数据库 #缓存

基于redis产生的变化

首先回想一下使用session实现登录时我们在哪里使用到了session

1.在保存验证码的时候我们使用验证码本身code作为value使用"code"作为key

2.在保存用户信息的时候我们使用用户user对象作为value使用"user"作为key

在redis中还能这么做吗,肯定不行这个key是“code”那不完全重复了吗,session之所以可以是因为每次http请求都是独立的互不影响,但是redis是数据库

解决方案

1.使用手机号作为key就行,一个手机号对应一个验证码,通过手机号取出验证码,使用string存储即可

2.有两种方案存储我们的user对象这里采用hash作为value,使用token作为key

代码实现

用户实现类

@Service
@Slf4j
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    /**
     * 发送验证码
     *
     * @param phone
     * @param session
     * @return
     */
    @Override
    public Result sendCode(String phone, HttpSession session) {
        //使用封装好的类来校验手机号格式
        if(RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误");
        }
        //符合就生成
        String code = RandomUtil.randomNumbers(6);
        //保存验证码，设置过期时间，这里的参数是key,value，时间，时间单位
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone,code,LOGIN_CODE_TTL, TimeUnit.MINUTES);

        log.debug("发送短信验证码成功,验证码:{}",code);

        return Result.ok();
    }

    /**
     * 用户登录
     *
     * @param loginForm
     * @param session
     * @return
     */
    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        String phone = loginForm.getPhone();

        if(RegexUtils.isPhoneInvalid(phone)) {
            return Result.fail("手机号格式错误");
        }
        //用户输入的验证码
        String code = loginForm.getCode();
        //这里直接从redis中获取
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
        //判断验证码是否正确
        if (cacheCode == null || !cacheCode.equals(code)) {
            return Result.fail("验证码错误");
        }
        //
        User user = query().eq("phone", phone).one();

        if (user==null) {
            user = createUerWithPhone(phone);
        }
        //随机生成token
        String token = UUID.randomUUID().toString(true);
        //转化DTO
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        //转化为Map,这里需要将Long类型转化为String
        Map<String, Object> stringObjectMap = BeanUtil.beanToMap(userDTO ,new HashMap<>(),
                CopyOptions.create()
                        .setIgnoreNullValue(true)
                        .setFieldValueEditor((fileName,fileValue) -> fileValue.toString()));

        String tokenKey = LOGIN_CODE_KEY + token;

        stringRedisTemplate.opsForHash().putAll(tokenKey,stringObjectMap);
        //设置token有效期，这么设置有问题用户有操作应该重置，通过拦截器来重新设置过期时间
        stringRedisTemplate.expire(tokenKey,30,TimeUnit.MINUTES);

        session.setAttribute("user",userDTO);

        return Result.ok();
    }

    /**
     * 根据手机号创建用户并保存
     *
     * @param phone
     * @return
     */
    private User createUerWithPhone(String phone) {
        User user = new User();
        user.setPhone(phone);
        user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));

        save(user);
        return user;
    }
}

Key 必须是 String
StringRedisTemplate 的所有操作都要求 key 是 String 类型（包括 Hash 的 key）
Hash 的 field 和 value 必须是 String
当操作 Hash 时：
- Hash 的 field（字段名）必须是 String
- Hash 的 value（字段值）也必须是 String

拦截器

刷新token的拦截器用于token刷新,如果还是使用之前的拦截器,我们只是拦截了部分资源请求并刷新过期时间,但是还有其他访问不需要携带用户信息的资源,那用户一直访问这些资源,按理来说token因该刷新,可是原本的代码无法做到这一点

public class RefreshTokenInterceptor implements HandlerInterceptor {

    // new出来的对象是无法直接注入IOC容器的（LoginInterceptor是直接new出来的）
    // 所以这里需要再配置类中注入，然后通过构造器传入到当前类中
    private StringRedisTemplate stringRedisTemplate;

    public RefreshTokenInterceptor(StringRedisTemplate stringRedisTemplate) {
        this.stringRedisTemplate = stringRedisTemplate;
    }

    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 1、获取token，并判断token是否存在
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)){
            // token不存在，说明当前用户未登录，不需要刷新直接放行
            return true;
        }
        // 2、判断用户是否存在
        String tokenKey = LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(tokenKey);
        if (userMap.isEmpty()){
            // 用户不存在，说明当前用户未登录，不需要刷新直接放行
            return true;
        }
        // 3、用户存在，则将用户信息保存到ThreadLocal中，方便后续逻辑处理，比如：方便获取和使用用户信息，Redis获取用户信息是具有侵入性的
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);
        ThreadLocalUtls.saveUser(BeanUtil.copyProperties(userMap, UserDTO.class));
        // 4、刷新token有效期
        stringRedisTemplate.expire(token, LOGIN_USER_TTL, TimeUnit.MINUTES);
        return true;
    }
}

登录拦截器该拦截器是在token拦截器之后拦截,只是判断用户的登录状态

public class LoginInterceptor implements HandlerInterceptor {

    /**
     * 前置拦截器，用于判断用户是否登录
     */
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 判断当前用户是否已登录
        if (ThreadLocalUtls.getUser() == null){
            // 当前用户未登录，直接拦截
            response.setStatus(HttpStatus.HTTP_UNAUTHORIZED);
            return false;
        }
        // 用户存在，直接放行
        return true;
    }
}

将自定义的拦截器添加到SpringMVC的拦截器表中，使其生效：

@Configuration
public class WebMvcConfig implements WebMvcConfigurer {

    // new出来的对象是无法直接注入IOC容器的（LoginInterceptor是直接new出来的）
    // 所以这里需要再配置类中注入，然后通过构造器传入到当前类中
    @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); // 优先级默认都是0，值越大优先级越低
        // 添加刷新token的拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    }
}