点评项目（Redis中间件）&第三部分&短信登录，查询缓存

发布于：2025-09-12 ⋅ 阅读:(26) ⋅ 点赞:(0)

可以直接看后面Redis实现功能的部分

基于session实现短信登录

发送短信验证码

前端请求样式

业务层代码

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

    @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();
    }
}
关于参数httpsession

  • 来源：Spring框架（Servlet容器）自动注入。

  • 机制：这是Spring MVC一个非常强大的特性，叫做参数解析（Handler Method Argument Resolution）。当你在一个控制器方法中声明某个类型的参数时，Spring会查看它注册的众多 HandlerMethodArgumentResolver 组件，找到一个能处理该类型的解析器，然后自动为你创建或获取该对象，并传入方法。

    • 对于 HttpSession 类型，Spring使用的是 ServletWebRequest 等相关解析器。这个解析器会：

      1. 检查当前的HTTP请求对象 (HttpServletRequest)。

      2. 调用 request.getSession() 方法来获取当前请求关联的Session。

        • getSession() 方法非常智能：如果Session已经存在，则返回它；如果不存在，则创建一个新的Session并返回。

HttpSession 参数不是前端发送来的，而是Spring框架根据你的参数类型，自动从当前HTTP请求中获取并“注入”到方法中的。它的作用是提供一种在服务器端存储用户相关数据并在多次请求间共享的机制。

登录功能

前端请求样式

业务层代码

黑马给的代码里面，工具类的相关注解有一处错误

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

返回ture是无效验证码

之所以一直使用反向验证是因为正向验证会使得代码有很多if的嵌套

业务层代码

@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.从redis获取验证码并校验
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
        String code = loginForm.getCode();
        if (cacheCode == null || !cacheCode.equals(code)) {
            // 不一致，报错
            return Result.fail("验证码错误");
        }

        // 4.一致，根据手机号查询用户 select * from tb_user where phone = ?
        User user = query().eq("phone", phone).one();

        // 5.判断用户是否存在
        if (user == null) {
            // 6.不存在，创建新用户并保存
            user = createUserWithPhone(phone);
        }

        // 7.保存用户信息到 redis中
        // 7.1.随机生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        // 7.2.将User对象转为HashMap存储
        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()));
        // 7.3.存储
        String tokenKey = LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
        // 7.4.设置token有效期
        stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

        // 8.返回token
        return Result.ok(token);
    }

如果保存可能会导致一些泄露问题，而且我们也不需要那么多信息，只需要唯一标识，所以我们把user对象转换成userdto对象，转换代码上面有，还是使用的BeanUtil工具类来实现。

验证拦截功能

这个功能放到拦截器里面，方便所有的可控制器都可以实现用户校验。然后将拦截到的用户信息传递到控制器里面去。不过这里有线程安全问题，所以我们需要使用threadlocal保证安全。

线程安全问题

简单来说，线程安全的根源在于：多个线程同时读写共享的可变数据（状态）时，如果没有正确的同步，就会导致不确定的结果。

特征 线程安全 线程不安全
数据来源 局部变量、方法参数、不可变对象 共享的成员变量、非线程安全容器
操作类型 单纯的读操作、无状态的计算 复合操作（如 i++）、"检查-然后-执行"
代码示例 return a + b; String s = "hello"; count++; if (map.contains(key)) { map.put(key, value); }
核心原因 没有共享 或 共享不可变 共享且可变，且未正确同步
变量类型 存储位置 共享范围 线程安全问题来源
实例变量
(非 static)		 堆内存 (Heap)
（每个对象内）		 同一个对象实例被多个线程引用 高发区。因为容易被忽略，人们常常以为“非static就是安全的”，却忘了单个实例被多线程共享这一常见场景。
类变量
(static)		 方法区 (Method Area) 整个JVM内的所有线程和所有实例 显而易见。因为大家都知道
拦截器代码（实现Redis最终版）

在工具类里面写一个拦截器，需要实现一个接口，以及三个接口方法

  1. preHandle：在Controller方法执行之前被调用。通常用于身份验证、日志记录、权限检查等。如果返回 false，则中断请求流程。

  2. postHandle：在Controller方法执行之后，但视图渲染之前被调用。通常用于向模型添加公共数据、记录执行时间等。

  3. afterCompletion：在整个请求完成之后（即视图渲染完毕）被调用。通常用于资源清理、记录最终日志等。

package com.hmdp.utils;

import org.springframework.web.servlet.HandlerInterceptor;

import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginInterceptor implements HandlerInterceptor {

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

需要一个mvc config类（实现Redis最终版）

package com.hmdp.config;

import com.hmdp.utils.LoginInterceptor;
import com.hmdp.utils.RefreshTokenInterceptor;
import org.springframework.context.annotation.Configuration;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

import javax.annotation.Resource;

@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);
    }
}

里面有些控制器不需要被拦截所以我们需要排除在外。

共享问题

替代办法

Redis

使用Redis实现session登录

获取并保存验证码

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

        // 4.保存验证码到 session
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);

        // 5.发送验证码
        log.debug("发送短信验证码成功，验证码：{}", code);
        // 返回ok
        return Result.ok();
    }

验证码发送的功能很复杂，这里直接用日志代替。

TimeUnit.MINUTES - 时间单位

短信登录以及注册功能

登录之后用户的信息还要存储到redis里面，key就用一个随机的token，存储对象转换成哈希，这个token会返回给前端。

public Result login(LoginFormDTO loginForm, HttpSession session) {
        // 1.校验手机号
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)) {
            // 2.如果不符合，返回错误信息
            return Result.fail("手机号格式错误！");
        }
        // 3.从redis获取验证码并校验
        String cacheCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);
        String code = loginForm.getCode();
        if (cacheCode == null || !cacheCode.equals(code)) {
            // 不一致，报错
            return Result.fail("验证码错误");
        }

        // 4.一致，根据手机号查询用户 select * from tb_user where phone = ?
        User user = query().eq("phone", phone).one();

        // 5.判断用户是否存在
        if (user == null) {
            // 6.不存在，创建新用户并保存
            user = createUserWithPhone(phone);
        }

        // 7.保存用户信息到 redis中
        // 7.1.随机生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        // 7.2.将User对象转为HashMap存储
        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()));
        // 7.3.存储
        String tokenKey = LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
        // 7.4.设置token有效期
        stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

        // 8.返回token
        return Result.ok(token);
    }

  • 先检查 cacheCode 是否为 null（防止空指针异常）

  • 如果是 null，直接进入if块，不会执行后面的equals

  • 如果不是 null，再比较内容是否相等

token来源

UUID是一个全球唯一的标识符，就像每个人的身份证号一样，几乎不可能重复。

  1. 唯一性 - 几乎不可能重复

  2. 安全性 - 难以猜测，适合做token

  3. 分布式 - 不同服务器生成也不会冲突

  4. 无需协调 - 不需要中央机构分配

下一步就是redis的语法应用了，将信息存储到redis里面。

// 7.1.随机生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        // 7.2.将User对象转为HashMap存储
        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()));
        // 7.3.存储
        String tokenKey = LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
        // 7.4.设置token有效期
        stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

        // 8.返回token
        return Result.ok(token);

这里面用beantil工具把bean转换成了一个map对象，然后使用

设置token有效期，

String tokenKey = LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(tokenKey, userMap);
        // 7.4.设置token有效期
        stringRedisTemplate.expire(tokenKey, LOGIN_USER_TTL, TimeUnit.MINUTES);

另外只要用户在不断访问我们就要不断的更新redis的时间限制，在拦截器里面添加更新逻辑。

null - 不存在

  • 对象根本不存在

  • 没有分配内存空间

  • 相当于"无中生有"

isEmpty() - 存在但为空

  • 对象存在，但内容为空

  • 已经分配了内存空间

  • 相当于"空盒子"

刷新token时间的拦截器

因为有一些功能是不需要校验的，所以为了这些功能也有刷新token的功能所以我们重新创建一个新的拦截器。

package com.hmdp.utils;

import cn.hutool.core.bean.BeanUtil;
import cn.hutool.core.util.StrUtil;
import com.hmdp.dto.UserDTO;
import org.springframework.data.redis.core.StringRedisTemplate;
import org.springframework.web.servlet.HandlerInterceptor;

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

import static com.hmdp.utils.RedisConstants.LOGIN_USER_KEY;
import static com.hmdp.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 {
        // 1.获取请求头中的token
        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)) {
            return true;
        }
        // 2.基于TOKEN获取redis中的用户
        String key  = LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
        // 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(key, LOGIN_USER_TTL, TimeUnit.MINUTES);
        // 8.放行
        return true;
    }

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

拦截器的代码我们在前面就是放的最终版的，两个拦截器需要设置先后顺序，我们使用order设置大小，越小的越先执行。

网站公告

今日签到

点亮在社区的每一天
去签到

热门文章

最新发布