【黑马点评|项目日记】第二天完成短信登录-CSDN博客

本文链接：https://blog.csdn.net/2303_78970037/article/details/147858085

1.导入文件，运行项目

当前项目的模型示意图：

模型介绍：

手机或者app端发起请求，请求我们的nginx服务器，nginx基于七层模型走的事HTTP协议，可以实现基于Lua直接绕开tomcat访问redis，也可以作为静态资源服务器，轻松扛下上万并发，负载均衡到下游tomcat服务器，打散流量，我们都知道一台4核8G的tomcat，在优化和处理简单业务的加持下，大不了就处理1000左右的并发，经过nginx的负载均衡分流后，利用集群支撑起整个项目，同时nginx在部署了前端项目后，更是可以做到动静分离，进一步降低tomcat服务的压力，这些功能都得靠nginx起作用，所以nginx是整个项目中重要的一环。
在tomcat支撑起并发流量后，我们如果让tomcat直接去访问Mysql，根据经验Mysql企业级服务器只要上点并发，一般是16或32 核心cpu，32 或64G内存，像企业级mysql加上固态硬盘能够支撑的并发，大概就是4000起~7000左右，上万并发，瞬间就会让Mysql服务器的cpu，硬盘全部打满，容易崩溃，所以我们在高并发场景下，会选择使用mysql集群，同时为了进一步降低Mysql的压力，同时增加访问的性能，我们也会加入Redis，同时使用Redis集群使得Redis对外提供更好的服务。

导入SQL
启动后端项目
- 将后端项目文件导入到IDEA中
- 在application.yaml文件中更改配置，重点修改MySQL数据库配置，Redis配置，运行端口设置
- maven重新编译一下(compile)
启动前端项目
- 复制文件夹到不含中文特殊字符等的项目文件夹里，启动nginx

2.基于session实现登录流程

这里重在理解业务和逻辑，后面会使用Redis替代session

这里流程主要分为三个步骤

2.1.发送短信验证码

/**
 * 发送验证码
 * @param phone
 * @param session
 * @return
 */
@Override
public Result sendCode(String phone, HttpSession session) {
    //1 校验手机号
    if (RegexUtils.isPhoneInvalid(phone)){ //invalid 不合格的
        //2 如果不符合 返回错误信息
        return Result.fail("手机号格式错误！");
    }
    //3 符合 生成验证码
    String code = RandomUtil.randomNumbers(6);
    //4 保存到session
    session.setAttribute("code",code);
    //5 发送验证码（暂时不做）
    log.debug("发送验证码成功：{}",code);
    return Result.ok();
}

2.2.登录拦截

定义LoginInterceptor类重写方法

@Override
public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
    //1 获取session
    HttpSession session = request.getSession();
    //2 从session获取用户  这里获取的其实是userDTO了
    Object user = session.getAttribute("user");
    //3 判断用户是否存在
    if (user == null){
        //不存在 拦截
        response.setStatus(401);
        return false;
    }
    //4 存在 保存到ThreadLocal
    UserHolder.saveUser((UserDTO) user);
    return true;
}


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

定义MvcConfig类让拦截器生效

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

2.3.隐藏用户敏感信息

核心是定义一个UserDTO类里面没有敏感信息

/**
 * 登录
 * @param loginForm
 * @param session
 * @return
 */
@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();
    //4 如果不一致
    if (cacheCode == null || !cacheCode.toString().equals(code)){
        return Result.fail("验证码错误");
    }
    //5 验证码一致 查询用户是否存在
    //mybatis plus
    User user = query().eq("phone", phone).one();
    if (user == null){
        //不存在 则创建新用户
       user = createUserWithPhone(phone);
    }
    //6 保存用户到session
    //因为直接存user到session中的话会导致后面在登录时返回的是user对象，暴露属性过多，这里可以把user对象转成userDTO
    session.setAttribute("user", BeanUtil.copyProperties(user,UserDTO.class));
    
    return Result.ok();
}

3.session共享问题

以上是用session实现整个业务流程，但是这也引出了session共享问题
简单介绍一下session共享问题：

每个tomcat中都有一份属于自己的session,假设用户第一次访问第一台tomcat，并且把自己的信息存放到第一台服务器的session中，但是第二次这个用户访问到了第二台tomcat，那么在第二台服务器上，肯定没有第一台服务器存放的session，所以此时整个登录拦截功能就会出现问题，我们能如何解决这个问题呢？早期的方案是session拷贝，就是说虽然每个tomcat上都有不同的session，但是每当任意一台服务器的session修改时，都会同步给其他的Tomcat服务器的session，这样的话，就可以实现session的共享了

但是这种方案具有两个大问题

1、每台服务器中都有完整的一份session数据，服务器压力过大。
2、session拷贝数据时，可能会出现延迟

所以咱们后来采用的方案都是基于redis来完成，我们把session换成redis，redis数据本身就是共享的，就可以避免session共享的问题了

4.Redis替代session的业务流程

4.1.设计key的结构

首先我们要思考一下利用redis来存储数据，那么到底使用哪种结构呢？由于存入的数据比较简单，我们可以考虑使用String，或者是使用哈希，如下图，如果使用String，同学们注意他的value，用多占用一点空间，如果使用哈希，则他的value中只会存储他数据本身，如果不是特别在意内存，其实使用String就可以了

4.2.设计key的具体细节

关于key的处理，session他是每个用户都有自己的session，但是redis的key是共享的，就不能使用“code”了
这里设计key需要满足两点：

key要具有唯一性
key要方便携带
如果我们采用phone：手机号这个的数据来存储当然是可以的，但是如果把这样的敏感数据存储到redis中并且从页面中带过来毕竟不太合适，所以我们在后台生成一个随机串token，然后让前端带来这个token就能完成我们的整体逻辑了

4.3.整体访问流程

当注册完成后，用户去登录会去校验用户提交的手机号和验证码，是否一致，如果一致，则根据手机号查询用户信息，不存在则新建，最后将用户数据保存到redis，并且生成token作为redis的key，当我们校验用户是否登录时，会去携带着token进行访问，从redis中取出token对应的value，判断是否存在这个数据，如果没有则拦截，如果存在则将其保存到threadLocal中，并且放行。

5.基于Redis实现登录流程

5.1.UserServiceImpl代码

/**
     * 登录
     * @param loginForm
     * @param session
     * @return
     */
    @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();
        //4 如果不一致
        if (cacheCode == null || !cacheCode.equals(code)){
            return Result.fail("验证码错误");
        }
        //5 验证码一致 查询用户是否存在
        //mybatis plus
        User user = query().eq("phone", phone).one();
        if (user == null){
            //不存在 则创建新用户
           user = createUserWithPhone(phone);
        }

        //6 保存用户到Redis
            //6.1 随机生成token，作为登录凭证
        String token = UUID.randomUUID().toString(true);
            //6.2 将user对象转换成HashMap用来存储
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
                //由于usermap中有Long型的id，无法存储到redis，这里需要修改
        Map<String, Object> userMap = BeanUtil.beanToMap(userDTO,new HashMap<>(),
                CopyOptions.create().
                        setIgnoreNullValue(true).
                        setFieldValueEditor((fieldName,fieldValue) -> fieldValue.toString()));
            //6.3 存储到redis中
        String tokenKey = LOGIN_USER_KEY + token;
        stringRedisTemplate.opsForHash().putAll(tokenKey,userMap);
            //6.4设置token有效期
        stringRedisTemplate.expire(tokenKey,LOGIN_USER_TTL,TimeUnit.MINUTES);

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

    private User createUserWithPhone(String phone) {
        User user = new User();
        user.setPhone(phone);
        user.setNickName(SystemConstants.USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
        save(user);
        return null;
    }

6.解决状态登录刷新问题

此时的代码有一个问题，拦截器中拦截的都是一些需要登录才能访问的页面，也就是我的，发表笔记等页面，但如果我一直在首页刷帖子，首页属于都可以访问的一个路径，我们访问的话是不会刷新token的有效期的，这就导致假如你刷着刷着突然提醒你需要登录，这是不应该的，因此我这里的处理方式是在登录拦截器前加一个全局拦截器用来解决token刷新问题

6.1.LoginInterceptor代码：

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

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

6.2.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(RedisConstants.LOGIN_USER_KEY + token);
        //3 判断用户是否存在
        if (userMap.isEmpty()){
            //不拦截
            return true;
        }

        // 4 将查到的Hash数据转换成UserDTO
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);

        //5 存在 保存到ThreadLocal
        UserHolder.saveUser(userDTO);

        //6 刷新token有效期
        stringRedisTemplate.expire(RedisConstants.LOGIN_USER_KEY + token,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        //7 放行
        return true;
    }

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

6.3.MvcConfig代码

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