黑马点评--记录

黑马点评–记录

仅作学习记录

1. 使用session实现单点登录

思路：浏览器点击发送验证码，发出请求http://localhost:8080/api/user/code?phone=15626，controller层调用service层的sendCode方法，随机生成6位数验证码，并将验证码保存到Session中。浏览器输入验证码，点击登录，发出请求：http://localhost:8080/api/user/login，controller层调用service层的login方法，比对用户输入的验证码和Session中验证码，如果失败，返回错误结果。如果成功，根据用户输入的手机，由于Service层实现了IService<>接口，里面包含了Mybaits的基础单表增删改查，所以可以直接利用getOne()等方法直接到数据库中查询有无相关用户。如果有，直接存在Session，如果没有则调用save()方法直接在数据库新增一个用户，同时将该用户数据存到Session中。
登录校验：并不是所有资源都可以被请求的，某些资源需要在用户登录后才能访问，因此需要做登录校验。思路-----利用拦截器的preHandle实现登录校验，就是查看Session是否包含用户信息，同时利用ThreadLocal保存用户基本信息，然后才放行请求。

1.1 发送短信验证码

UserController调用UserService的sendCode()，并将生成的验证码保存到Session中

    /**
     * 发送手机验证码
     * @RequestParam 请求参数在URL后面
     */
    @PostMapping("code")
    public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
        // TODO 发送短信验证码并保存验证码
        return userService.sendCode(phone, session);
    }

 @Override
    public Result sendCode(String phone, HttpSession session) {
        //校验手机号
        if (RegexUtils.isPhoneInvalid(phone)){
            return Result.fail("手机格式有误");
        }
        //符合 生成验证码
        String numbers = RandomUtil.randomNumbers(6);
        // 保存到Session
        session.setAttribute("code",numbers);
        // 发送验证码
        log.debug("发送短信成功，验证码:{}", numbers);
        // 返回Ok
        return Result.ok();
    }

1.2 短信验证码登录注册

UserController调用UserService的login()

  /**
     * 登录功能
     * @param loginForm 登录参数，包含手机号、验证码；或者手机号、密码
     * @RequestBody  因为前端传的是json
     */
    @PostMapping("/login")
    public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
        // TODO 实现登录功能
        return userService.login(loginForm,session);
    }

@Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //校验手机号和验证码
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)){
            return Result.fail("手机格式有误");
        }

        Object cashCode = session.getAttribute("code");
        String code = loginForm.getCode();
        //不一致，报错
        if (cashCode == null || !cashCode.toString().equals(code)){
            return Result.fail("验证码错误");
        }
        //一致，根据手机号到数据库中查询用户
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getPhone, phone);
        User user = this.getOne(queryWrapper);
        //用户不存在，创建新用户到数据库
        if ( user == null){
            user = new User();
            user.setPhone(phone);
            user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
            this.save(user);
        }
        //无论存不存在，都保存用户数据到session（因为不存在也已经新建了）
        //用户数据包含密码等敏感信息，所以存user部分数据就可以了
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);
        session.setAttribute("user", userDTO);
        return Result.ok(userDTO);

1.3 使用拦截器实现登录校验，利用ThreadLocal保存用户信息

1.4 在工具类中编写拦截器

主要是实现HandlerInterceptor接口的三个方法。因为preHandle是在请求到达controller层之前的处理，所以先在preHandle方法中实现登录校验，并使用ThreadLocal保存用户信息

public class LoginInterceptor implements HandlerInterceptor {
    @Override//在请求到controller之前处理
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        // 获取请求携带的session
        HttpSession session = request.getSession();
        // 获取session中的用户
        Object user = session.getAttribute("user");
        // 判断用户是否存在
        if (user == null){
            // 401 --无权限
            response.setStatus(401);
            return false;
        }
        // 存在，将用户信息存到Threadlocal
        UserHolder.saveUser((UserDTO) user);
        // 放行
        return true;
    }

    @Override// controller执行之后
    public void postHandle(HttpServletRequest request, HttpServletResponse response, Object handler, ModelAndView modelAndView) throws Exception {

    }

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

1.5 在配置类中编写配置拦截器

//配置拦截器
@Configuration
public class MvcConfigurer implements WebMvcConfigurer {

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

2. 基于Redis实现共享Session登录

2.1 为啥用Redis（集群Session的共享问题）

2.2 思路

第一步变化不大，只是由Redis来保存验证码。第二步变化略大，因为登录校验之前是利用Session中用户信息来实现放行的，但是Redis的token(第二行)不会自动保存在浏览器中，也即浏览器发送的请求不像之前包含SessionId进而找到tomcat中对应Session中的用户信息。因此，我们在短信登录后，需要把token传给前端，由前端浏览器保存token，保证每次请求都能携带该token。在拦截器部分，会通过request.getHeader()获取token，然后去redis中根据token这个key去查其value（UserDto对象）,查到了就刷新这条redis数据的TTL

2.3 发送验证码

几乎和基于session的方法没有什么区别，只是一个存session,一个存在redis中

    @Override
    public Result sendCode(String phone, HttpSession session) {
        //校验手机号
        if (RegexUtils.isPhoneInvalid(phone)){
            return Result.fail("手机格式有误");
        }
        //符合 生成验证码
        String numbers = RandomUtil.randomNumbers(6);
//        // 保存到Session
//        session.setAttribute("code",numbers);
        // 使用redis来保存验证码
        stringRedisTemplate.opsForValue()
                .set(LOGIN_CODE_KEY+phone, numbers,2, TimeUnit.MINUTES);


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

2.4 短信验证码登录login()

这里有一个常用操作—将数据库查到的user对象转成userDto(避免敏感数据在网络中传输)。此外，如何将一个对象存入redis中也是经常遇到的需求，第一时间想到的是使用hash结构，key用来标识对象，字段标识对象属性名，value标识对象属性值。因此，可以先将对象转成Map类型，再通过stringRedisTemplate.opsForHash().putAll(key, map)直接存入Redis中。随之而来，又有一个新问题，redis中存入的数据都是String类型，因此需要将对象的属性值都转成String--------------------------解决方法----使用hutool工具类的BeanUtil.beanToMap())，将一个对象转成Map类型，可以通过CopyOptions.create().setFieldValueEditor()将属性值都转成String类型

    @Override
    public Result login(LoginFormDTO loginForm, HttpSession session) {
        //校验手机号和验证码
        String phone = loginForm.getPhone();
        if (RegexUtils.isPhoneInvalid(phone)){
            return Result.fail("手机格式有误");
        }
//        // 从Session中获取验证码
//        Object cashCode = session.getAttribute("code");
        //TODO 从redis中获取验证码并校验
        String cashCode = stringRedisTemplate.opsForValue().get(LOGIN_CODE_KEY + phone);

        String code = loginForm.getCode();

        //不一致，报错
        if (cashCode == null || !cashCode.equals(code)){
            return Result.fail("验证码错误");
        }
        //一致，根据手机号到数据库中查询用户
        LambdaQueryWrapper<User> queryWrapper = new LambdaQueryWrapper<>();
        queryWrapper.eq(User::getPhone, phone);
        User user = this.getOne(queryWrapper);
        //用户不存在，创建新用户到数据库
        if ( user == null){
            user = new User();
            user.setPhone(phone);
            user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
            this.save(user);
        }
        //用户数据包含密码等敏感信息，所以存user部分数据就可以了
        UserDTO userDTO = BeanUtil.copyProperties(user, UserDTO.class);

//        //无论存不存在，都保存用户数据到session，方便在拦截器部分将user信息存到ThreadLocal
//        session.setAttribute("user", userDTO);

        //TODO 将用户信息存到reids中
        // 1.随机生成token，作为登录令牌
        String token = UUID.randomUUID().toString(true);
        String tokenkey = LOGIN_USER_KEY + token;
        // 2. 将user对象以Hash存储到redis中，注意stringRedisTemplate的key和value都是string
        Map<String, Object> map = BeanUtil.beanToMap(userDTO, new HashMap<>(),
                CopyOptions.create().setIgnoreNullValue(true)
                                    .setFieldValueEditor((fieldName, fieldValue) -> fieldValue.toString()));
        stringRedisTemplate.opsForHash().putAll(tokenkey,map);
        // 3. 设置token有效时间
        stringRedisTemplate.expire(tokenkey,LOGIN_USER_TTL, TimeUnit.MINUTES);

        //将tokenkey返回前端，前端需要保存该token,保证前端的请求带有token,（类似于cookie中的SessionId）
        return Result.ok(tokenkey);
    }

2.5 拦截器+ThreadLocal实现校验登录

单个拦截器实现校验登录存在的问题：正常情况下，用户已经登录，并且访问需要拦截的路径，redis中token就会更新，但是长时间访问不需要拦截的路径，比如首页，店铺信息等等，redis中用户信息可能会过期而自动销毁失效，这是用户如果访问了需要拦截的路径就会访问失败。

使用两个拦截器实现登录校验：第一个拦截器会拦截所有路径，根据token查询redis中是否存在用户，如果有就说明目前是有用户登录的，因此刷新token有效时间并放行。如果没有，也放行，反正下一个拦截器会拦截没有token的请求。这样就保证了用户登录情况下，所有请求都会触发刷新token有效期的动作

第一个拦截器：这里有一个常用操作，将redis中存储的Hash结构的value（在Java中一般都是Map类型）拿出来，也即stringRedisTemplate.opsForHash().entries(key)，然后通过BeanUtil.fillBeanWithMap(userMap, new UserDTO())

public class RefreshTokenInterceptor implements HandlerInterceptor {

    //不能使用Resource或者Autowire等注解实现依赖注入，因为当前LoginInterceptor类没有加注解等
    // 这个类的对象是由我们手动new出来，由spring创建的对象实现依赖注入
    // 所以这里使用构造函数 传入stringRedisTemplate
    private StringRedisTemplate stringRedisTemplate;

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

    @Override//在请求到controller之前处理
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {

        String token = request.getHeader("authorization");
        if (StrUtil.isBlank(token)){
            return true;
        }
        //2. 根据token从redis中获取用户数据
        String key = token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
        //3. 判断用户是否存在
        if (userMap.isEmpty()){
            return true;
        }
        //5.存在，将得到的userMap转回 UserDto对象
        UserDTO userDTO = BeanUtil.fillBeanWithMap(userMap, new UserDTO(), false);

        //6.将UserDto存到ThreadLocal中
        UserHolder.saveUser(userDTO);
        //7. 刷新token时间，总不可能用户登录30分钟后就不许访问资源了吧
        stringRedisTemplate.expire(key,RedisConstants.LOGIN_USER_TTL, TimeUnit.MINUTES);
        //8. 放行
        return true;
    }

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

第二个拦截器：

public class LoginInterceptor implements HandlerInterceptor {

    @Override//在请求到controller之前处理
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //TODO 利用redis实现登录校验
        //1. 从请求头中获取token
        // 判断是否需要拦截，（ThreadLocal中是否由用户）
        if( UserHolder.getUser() == null){
            response.setStatus(401);
            return false;
        }
        return true;
    }
}

配置拦截器：

@Configuration
public class MvcConfigurer implements WebMvcConfigurer {
    //在这里实现依赖注入，给拦截器传入stringRedisTemplate
    @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);
        //token刷新拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate))
                .addPathPatterns("/**")
                .order(0);
    }
}

预告—记录利用Redis缓存信息