黑马点评redis改 part 1

本篇将主要阐述短信登录的相关知识，感谢黑马程序员开源，感谢提供初始源文件（给到的是实战第7集开始的代码）【Redis实战篇】黑马点评学习笔记（16万字超详细、Redis实战项目学习必看、欢迎点赞⭐收藏）-CSDN博客

1.打开localhost_3306,选中右击"新建数据库"

2.指定数据库名和字符集（可根据sql文件的字符集类型自行选择）

3.选中数据库下的表运行SQL文件

其实我想发在这里的，但是1285行代码太多了

4.选中路径导入

将hmdp.sql导入（本人是mysql8.0.32版本），即可看到包括tb_user:用户表，tb_user_info：用户详情表，tb_shop：商户信息表，tb_shop_type:商户类型表，tb_blog：用户日记表（达人探店日记），tb_follow：用户关注表，tb_voucher:优惠券表，tb_voucher_order:优惠券的订单表的一共11个表

在资料中提供了一个项目源码，hm-dianping，大概看一下，经典的ssm，一眼springboot。修改application.yaml部分，对照自己的即可

java 复制代码

server:
  port: 8081
spring:
  application:
    name: hmdp
  datasource:
    driver-class-name: com.mysql.jdbc.Driver
    url: jdbc:mysql://localhost:3306/hmdp?useSSL=false&serverTimezone=UTC
    username: root
    password: root
  redis:
    host: 192.168.169.133
    port: 6379
    password: 123321
    lettuce:
      pool:
        max-active: 10
        max-idle: 10
        min-idle: 1
        time-between-eviction-runs: 10s
  jackson:
    default-property-inclusion: non_null # JSON处理时忽略非空字段
mybatis-plus:
  type-aliases-package: com.hmdp.entity # 别名扫描包
logging:
  level:
    com.hmdp: debug

RedissonConfig中也有redis的地址需要修改（错误的，我误打开的完整版代码）

修改pom中你的java版本和mysql版本（java版本不建议太新本人用的jdk13，老师用祖传1.8，因为检查 JCImport 的源码（或反编译）确认字段名：JDK 8：字段为 qualid。JDK 13+：字段可能改为 pid。吗不过java从11开始到大概17基本上没有什么大变化，我猜应该都可以吧，不过jdk23肯定不行）

alt+8打开service，添加 "运行配置类型" springboot。成功运行！

运行前端项目

在nginx所在目录下打开一个cmd窗口

bash 复制代码

start nginx.exe

打开浏览器的手机模式和本地的8080端口即可

基于session实现登录

我们在http://localhost:8080/login.html输入一个合法的手机号码可以看到一个

已完成加载:POST "http://localhost:8080/api/user/code?phone=16883577632"。请求发到api的user

请求方式POST，请求路径/user/code，请求参数phone、电话号码，返回值无

我们要打开UserController，实现发送手机验证码的功能，由于中国大陆的手机号政策，实际上你可以改为邮箱验证，毕竟只是一个简单demo而已。

java 复制代码

@PostMapping("code")
public Result sendCode(@RequestParam("phone") String phone, HttpSession session) {
    // 发送短信验证码并保存验证码
    return userService.sendCode(phone, session);
}

java 复制代码

package com.hmdp.service.impl;

import cn.hutool.core.util.RandomUtil;
import com.baomidou.mybatisplus.extension.service.impl.ServiceImpl;
import com.hmdp.dto.Result;
import com.hmdp.entity.User;
import com.hmdp.mapper.UserMapper;
import com.hmdp.service.IUserService;
import com.hmdp.utils.RegexUtils;
import lombok.extern.slf4j.Slf4j;
import org.springframework.stereotype.Service;

import javax.servlet.http.HttpSession;

/**
 * <p>
 * 服务实现类
 * </p>
 *
 * @author 虎哥
 * @since 2021-12-22
 */
@Service
@Slf4j //log.debug报错的加@Sl4j注解
public class UserServiceImpl extends ServiceImpl<UserMapper, User> implements IUserService {
    @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 //这里推荐使用手机号作为key，验证码作为值
        session.setAttribute("code",code);

        // 5.发送验证码,通过aliyun那些短信平台实现
        log.debug("发送短信验证码成功，验证码：{}", code);
        // 返回ok
        return Result.ok();
    }
}

这时后台可以直接看到发送短信验证码成功，验证码245333

我们仔细看login功能，前端发送的是json格式，所以需要RequestBody解析下，loginFormDTO格式里面包括三个要素，接下来进一步完善controller

java 复制代码

@PostMapping("/login")
public Result login(@RequestBody LoginFormDTO loginForm, HttpSession session){
    // 实现登录功能
    return userService.login(loginForm, session);
}

UserServiceImpl.java修改如下，这里有实际上有一个小保险，发送验证码时应该将手机号保存在session中，在登录时验证是否当前手机号是否是发送验证码的手机号，否则先用自己手机号发送验证码，再用别人手机号登录。总之就是**登录需要校验此手机号和发送验证码的手机号是同一个,**你乐意的话可以加个ip地址校验不过不太好使唤

数据库在中tb_user中有nick_name字段,手机号什么的,这里用lambdaquery的朋友注意了，mp版本要3.5，用老师的这个版本查询为空的时候会报错

java 复制代码

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

        session.setAttribute("user",user);
        return Result.ok();//实际上只需要return null,session就直接写到你的cookie中了
    }


    private User createUserWithPhone(String phone) {
        // 1.创建用户
        User user = new User();
        user.setPhone(phone);
        user.setNickName(USER_NICK_NAME_PREFIX + RandomUtil.randomString(10));
        // 2.保存用户
        save(user);
        return user;
    }

这是mybatisplus在service的方法，不用去初始化mapper

我们在前端,登录后可以跳转一下,但是没有做登录校验功能,你在数据库可以查找到对应的数据

登陆验证功能

事实上的登录验证呢就是这样的一个请求,这个userme查询当前所在的用户信息,如果你能return,那么就成功了.但是这里有点问题，我们在黑马点评里面有很多很多control，其中刚才讲那个userme登录校验属于usercontrol，前端向usercontrol发请求，里面编写这一堆的业务逻辑。但是呢后续随着业务的开发，越来越多的业务都需要去校验用户的登录，显然不能写一堆control。这也是拦截器的由来，所有请求啊都必须先经过拦截器，再由拦截器判断该不该放行到达control

拦截器确实可以帮助我们实现对用户登录的校验，在其他业务中人家是需要这个用户信息的，校验这是拿到了，所以需要把这个拦截器里拦截得到的用户信息传递到control里面去。而且在传递的过程中需要注意slocal解决线程的安全问题，拦截器拦截信息后保存在slocal（线程序对象）每一个进入tomcat的请求都是一个独立的线程，slocal在每个线程内开辟一个内存的空间保存对应的用户，每个线程互不干扰。

可能是放在Session里你要用的话，这个session参数你要一直传下去，ThreadLocal调用一个API就能实现你说哪个好？

拦截器可以写在utils里面，叫做LoginInterceptor.java

java 复制代码

package com.hmdp.utils;

import com.hmdp.entity.User;
import org.springframework.web.servlet.HandlerInterceptor;

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

public class LoginInterceptor implements HandlerInterceptor {
    @Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        //1.获取session
        HttpSession session= request.getSession();
        //2.获取session中的用户
        Object user = session.getAttribute("user");
        //3.判断用户是否存在
        if (user == null){
            //4.不存在，拦截，返回401状态码
            response.setStatus(401);
            return false;
        }
        //5.存在，保存用户信息到ThreadLocal
        UserHolder.saveUser((User) user);
        //6.放行
        return true;
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserHolder.removeUser();
    }

}

这里userholder，视频是user，而给的源码是userdto，我认为extend一下即可

复制代码

public class User extends UserDTO implements Serializable{

因为ThreadLocal底层是ThreadLocalMap，当期线程Threadlocal作为key(弱引用)，user作为value(强引用) 这里涉及到了ThreadLocal的相关知识，不懂为啥要移除，避免内存泄漏的，建议查询资料

ThreadLocal维护了一个ThreadLocalMap，在map中的Entry继承了WeakReference，其中key为使用了弱引用的ThreadLocal实例，注意这里他发给我们的是UserDTO我们需要创建一个DTO对象（详见userholder）然后进行属性拷贝、不可以直接强转不然会报可能为空的错；移除用户是因为：因为ThreadLocal对应的是一个线程的数据，每次http请求，tomcat都会创建一个新的线程，也就是说，当前的ThreadLocal只在当前的线程中有用；jvm不会把强引用的value回收掉，所以value没被释放；

总之移除用户是因为：因为ThreadLocal对应的是一个线程的数据，每次http请求，tomcat都会创建一个新的线程，也就是说，当前的ThreadLocal只在当前的线程中有用

要想让拦截器生效还要配置拦截器，在config中新建文件MvcConfig，去掉code.login等等等等

java 复制代码

package com.hmdp.config;

import com.hmdp.utils.LoginInterceptor;

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 {

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

做登录校验用到那个叫user/me的一个接口，这个接口最终还需要把当前登录的用户信息返回到前端，拦截器已经把用户放到了userholder里面去了，所以只需要userholder.get即可了

java 复制代码

    @GetMapping("/me")
    public Result me(){
        // 获取当前登录的用户并返回
        UserDTO user = UserHolder.getUser();
        return Result.ok(user);
    }

现在可能会出bug，继续做下一集就ok了

登录校验功能返回的信息有点多，注意：跳转到主页的，需要去修改前端代码，改为跳转到个人详情页

注意：跳转到主页的，需要去修改前端代码，改为跳转到个人详情页，直接跳到首页并且点击我的

或者跳回首页的可以看看前端login部分是不是没有跳到info而是去index了

需要从新登录的在login这里下面返回的改成这个Result.ok(userService.login(loginForm,session))

我们回到me方法，从userholder里得到用户以后就直接返回了，其实也说明取出的信息就是完整的信息，这个消息是拦截器那个session存储的，随着时间推移里面的信息越来越多，也就说明压力也大，其中谁给session信息呢？就是login啊于是就这样了

java 复制代码

UserServiceImpl.java
..............
//7.保存用户信息到session中
session.setAttribute("user",Beanutil.copyProperties(user,UserDTO.class));
return Result.ok();

那么拦截器的对象也就是UserDTO对象了
LoginInterceptor.java
................
//5.存在，保存用户信息到ThreadLocal
UserHolder.saveUser((UserDTO) user);
//6.放行
return true;

顺道再UserHolder里面改为dto
private static final ThreadLocal<UserDTO> tl = new ThreadLocal<>();

public static void saveUser（UserDTO user){
    tl.set(user);
}
很多很多依赖都改成userdto
BlogController的saveBlog和queryMyBlog的第一句， UserController通通改成UserDTO user

集群的session共享问题

session共享问题：多台Tomcat并不共享session存储空间，当请求切换到不同tomcat服务时导致数据丢失的问题。

早期的解决方案是tomcat之间配置拷贝，但是有几个问题，拷贝耗内存，并且有延迟

session的替代方案应该满足：1.数据共享 2.内存存储 3.key、value结构

基于Redis实现共享session登录

redis作为key--value来说，redis 是一个共享的一个内存空间，不管是谁来发请求，在我们服务端是不是只有一个release，大家都往里面去存。如果你的手机号来的时候用code啊，有一个手机又一个code，那么不同的手机号都用code为key，互相就覆盖；那么这个验证码将来是不是就丢失了很多，很多人就登录不上。我们必须确保每一个不同的手机号验证保存的key是不一样的。

手机号作为key 验证码做为value，现在是redis，没有原来的自动每一次请求都会带着Session ID来。现在是客户端还得带着这个信息来取才能验证。那么这样一来我们去校验的时候，可以基于手机号为key，从redis去读取到啊这个验证码然后跟他提交的验证码做比较就行了（这里解决了前面的类bug：发送和登录手机号不一致的问题）

第二要考虑的就是我们这个key，保存验证码的时候我们用的是string类型，因为他大部分是六位数的的数字，用了字符串形式去保存。但在这里呢你保存的是一个用户的对象，保存对象我们应该选择哪种数据类型

当我们在redis中保存对象时一般两种结构，第一种是string结构，第二种是hash： string其实就是把我们的java对象序列化为json的字符串

hash那它的value啊是一个哈希，可以理解为map，它其实就是把我们的java对象中的每一个字段都作为这个value中的一个field和value，string把整个数据变成一个串，而哈希结构呢每个字段是独立的，所以说它可以针对单个字段做crud

对于key的要求：1.保证唯一2.客户端将来能够去携带这样一个呢key方便从redis里再去取出这个值。

不一样的这个项目就是学redis可以不能用jwt啊 jwt就是后端不存储，直接根据jwt解析。

前端登录页面中是用一个axiou的请求啊来去做，在这个请求的响应里面，这个data其实就是我们要返回到前端的这样登录凭证token，它会把它保存在session storage里。在我们前端的commonjs里还有这么一点逻辑：就是从session storage里得到这个token，下边是一个拦截器，而每次发请求都会执行这样一段逻辑。token作为这个请求头，这个头的名字叫authorization，确保以后凡是有axios发起的这种请求都会携带authorization这个头，在服务端就能获取这个头，实现登陆验证

现在修改代码，只有修改验证码发生变化不再是保存到redis时这个key啊不再是code，而是以手机号为key，好我们修改UserServiceImpl

java 复制代码

    @Resource
    private StringRedisTemplate stringRedisTemplate;

    @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
        stringRedisTemplate.opsForValue().set(LOGIN_CODE_KEY + phone, code, LOGIN_CODE_TTL, TimeUnit.MINUTES);

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

其中在util中新建RedisConstants文件来定义（实际上原文件已经定义好了）

java 复制代码

package com.hmdp.utils;

public class RedisConstants {
    public static final String LOGIN_CODE_KEY = "login:code:";
    public static final Long LOGIN_CODE_TTL = 2L;
}

autowired和resource的功能类似只不过autowired是先找类型再找名字，resource是先找名字再找类型，接下来写短信功能

java 复制代码

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

在实现用户登录功能时，首先需要生成一个随机token作为用户身份凭证。这里建议使用UUID（通用唯一识别码），因其具备高唯一性和简便性。具体可采用Hutool工具库提供的UUID方法生成不含中划线的简洁字符串，如UUID.randomUUID().toString(true)。生成token后，需将其作为Redis的key，将用户信息以哈希结构存储。为避免多次与Redis交互，应通过BeanUtil工具将UserDTO对象转换为Map，利用putAll方法一次性存入多个字段。存储时需注意为key添加业务前缀（如login:user:token），并设置30分钟的有效期，防止内存过度占用。具体实现步骤为：校验手机号格式，比对Redis中存储的验证码，查询或创建用户，生成token，转换用户数据为Map结构，存入Redis并设置过期时间，最终返回token给前端。其中，对象转换需使用BeanUtil.copyProperties和BeanUtil.beanToMap方法，同时忽略空值字段并统一字段值类型，确保Redis存储结构的规范性。同样的redisconstants修改

java 复制代码

package com.hmdp.utils;

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

接下来，我们需要对代码中的变量名进行调整。比如原来的login_code现在不再需要了，可以将其改为login_user，因为这是与用户登录相关的业务。相应的，Redis的key前缀也可以命名为login:user:key，而token的有效期则设置为30分钟。这里的token名称可以叫login_token或者user_token，都是可以接受的。然而，仅仅设置30分钟的有效期还不够。目前的逻辑是，从用户登录那一刻开始计时，30分钟后无论用户是否活跃，Redis都会将该用户的登录状态移除。这显然不符合实际需求，因为我们希望的是：只要用户持续访问系统，token的有效期就应该不断刷新，而不是在固定时间后强制失效。

那么问题来了：如何判断用户是否在访问系统？其实，我们之前实现过一个功能------登录拦截器。所有的请求进入系统时，都会经过这个拦截器的校验。如果请求通过了校验，就说明两点：第一，该用户已经登录；第二，该用户当前处于活跃状态。基于这两点，我们可以在拦截器中添加一个逻辑：每次用户访问系统时，更新Redis中对应token的有效期。这样一来，只要用户持续访问系统，token的有效期就会不断延长，只有当用户超过30分钟没有任何操作时，token才会被移除。

因此，在修改登录状态校验的业务逻辑时，我们需要在原有逻辑的基础上增加一个新功能：更新token有效期。接下来，我们可以找到与登录相关的业务代码，这部分逻辑写在拦截器（LoginInterceptor）中。

java 复制代码

public class LoginInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

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

在这个地方，我们无法使用@Autowired、@Resource等注解来进行依赖注入，而只能通过构造函数的方式来实现依赖注入。这是因为当前类的对象是我们手动通过new关键字创建的，而不是由Spring容器管理的。换句话说，这个类的对象并没有通过@Component或其他类似的注解交给Spring来创建和管理，因此Spring无法自动为我们完成依赖注入。对于Spring管理的对象，比如添加了@Autowired注解的类，Spring会自动完成依赖注入；但如果我们手动创建对象，则没有任何机制能够帮助我们完成依赖注入，也就无法使用@Resource等注解。

那么在这种情况下，我们选择通过构造函数注入的方式解决问题。那么谁来负责为我们注入依赖呢？这就需要看是谁在使用这个类了。回顾一下，我们在MvcConfig配置类中的拦截器部分使用了这个类，而这里报错了，说明我们需要对这部分代码进行调整。解决方法是，在MvcConfig中获取RedisTemplate实例。大家可以看到，MvcConfig类上添加了@Configuration注解，这意味着这个类是由Spring来构建和管理的。既然是由Spring管理的类，就可以利用Spring的依赖注入功能，因此我们可以通过@Resource注解直接获取StringRedisTemplate实例，从而完成依赖注入。

所以把这个手动new的换成@Component，就可以用自动装配了；但是不能加Competent，拦截器是一个非常轻量级的组件，只有在需要时才会被调用，并且不需要像控制器或服务一样在整个应用程序中可用。因此，将拦截器声明为一个Spring Bean可能会引导致性能下降。

那MvcConfig这里怎么获取redis template？这个类加了configuration注解说明这个类将来是不是由spring构建的，由spring来构建这个类的对象他就可以做依赖注入，因此可以利用resource注解来获取string redis template啊

java 复制代码

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(stringRedisTemplate))
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
            }
    }
}

回到LoginInterceptor，这里呢就拿到了redistemplate了

java 复制代码

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;

public class LoginInterceptor implements HandlerInterceptor {

    private StringRedisTemplate stringRedisTemplate;

    public LoginInterceptor(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)) {
            // 不存在，拦截，返回401状态码
            response.setStatus(401);
            return false;
        }

// 2.基于TOKEN获取redis中的用户
        String key = RedisConstants.LOGIN_USER_KEY + token;
        Map<Object, Object> userMap = stringRedisTemplate.opsForHash().entries(key);
// 3.判断用户是否存在
        if (userMap.isEmpty()) {
            // 4.不存在，拦截，返回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(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();
    }
}

这一步放在mvcconfig里好一点吧，不然走被拦截的请求就不更新了；启动报错 BeanCreationException的记得给@Resource 的名字改为stringRedisTemplate--或者将注解改为@Autowied这里跟注解的特性有关不多解释了

java.lang.Long cannot be cast to java.lang.String

输入登录，会出现报错了（服务器错误），把我们的usermap向redistemplate写的时候报错了：类型转换long不能转化为string，那么userdto里其实只有id是long类型对吧，redis无法存储。为什么？redis template，string template它有一个什么特点，他要求你的key或者value都是string结构，而我们把数据转成map的时候，我们那个字段id是long类型。

因此确保这里边的每一个值都要以string的形式存储的，是map的key和value都得是string结构。有两种方法，

第一种笨办法，自己new一个map，不再Map<String ，Object> userMap = BeanUtil.beanToMap（userDTO);然后把这个对象里面的字段名作为key；

第二种，Objectbean,Map<String,object>targetMap,CopyOptionscopyOptions ，允许你对key和value做自定义

java 复制代码

 @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()));
/*copyoption就是做数据拷贝时的一个选项，这样就创建出来一个copyoption了。
但是呢这个地方创建出来是默认的，我们要自定义允许你做各种各样的set，比如说呢set 
ignore null value就是忽略一些空的值*/
        // 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);
    }

问题就是StringRedisTemplate是定义一个String类型的key和value，但是再map转换成user的时候无法将string转换成long，所以需要这种方式或者自定义一个map.

转化下map值类型 userMap.forEach((key,value)->{if(null!=value) userMap.put(key, String.valueOf(value)); });

登录后又回来的，记得在login业务里返回token到控制层（要重新登录的看一下是不是login方法ok里有没有返回token 所以拦截器中就没有获取到就给你打回了）controller层的login是retuen userService.login(loginForm,session)

我们的登录功能是基于拦截器做的校验对吧？没有请求进入了拦截器以后，我们会尝试去获取请求头中的 token。那么如果说他之前登录过他的头里一定会有token对不对？那么我们再去根据token到redis里查询对应的用户信息，那么查了以后对用户做一个判断，存在或者是不存在，不存在给你拦截，存在我就继续，继续干什么？用户存在，我就会把它保存到所有的local当中，方便后续的control的业务去使用它，对吧？好，那么保存完了，我们还做了一件事，就是去刷新token的有效期，为什么？因为我们在redis里保存的 Token有效期是30分钟，如果说不去做刷新，用户30分钟后就可能失去了登录状态了，这个就不太友好。

所以我们去做一个刷新，每当用户来访问，我们都会去刷新一次，确保只要用户一直在操作，那么它这个token就不会消失。好，这是我们刷新token的一个目的，那么最后放行就可以了。但是我们现在能不能真正的达成，说是只要用户一直在访问就不会过期，还不太行，为什么？因为拦截器它拦截的路径不是一切路径，它拦的是那些需要做登录校验的路径。

比如说我们的userme，再比如说将来用户的下单支付等等这样的一些对用户信息有需求的路径，或者说被拦截器拦截的路径，但它不是拦截一切。所以这就导致了如果说，我们的用户一直访问的是不需要登录的这样的一些页面。举个例子，我们的首页，商户的详情页，那么这些都是不需要登录就能看的，那么这样拦截器就不生效，那么它就不会去刷新。接下来如果说30分钟以后，尽管用户一直在访问，用户的登录是不是就也消失了，所以这是不太合理的一个点，针对这个点我们该怎么优化，我们可以这么来做。

这里意思是如果你登录了，但是你访问的是主页，主页不需要拦截，既然不能刷新token，就在你看首页或者商家的时候你突然下单，这时token过期就失败了

解决登录状态刷新的问题

在原有这个拦截器的基础上，再加一个新的拦截器，这样用户请求就要先经过第一个连接器，再经过第二个。因为什么？我们的第二个连接器它拦截的是需要登录的那些东西，而不是所有的路径，所以没有办法给所有的请求都做刷新，对不对？我在新加这个连线我就让他干什么？拦截一切路径。也就是说所有请求都会经过我，我是不是可以在拦截器里来做刷新token有效期的动作？

我在这里获取token，获取rest的用户。当然了有的时候你查的时候说万一不存在怎么办？好不存在我放行我不管，只要你存在，我就给你保存到所有logo做刷新的动作。也就是说我这里不做拦截，我这个拦截器虽然是拦截一些路径，但是唯一目的其实就是保存了所有logo和刷新的动作。

好，那么这样是不是可以确保一切请求都会触发创新的动作？拦截的动作在哪做？在第二个拦截器里，在第二个拦截器里我就不用重复上面这5步了，我只需要从ThreadLocal里面查，因为你这个来写已经把它保存到算了对吧？我去查查了以后，如果不存在我就拦截，如果存在我是不是就可以放行了？那也就是第一个联系它的核心工作就是得到用户保存起来，并且刷新。那么第二个引起的核心动作才是做登录拦截，两个分工这个问题就得到解决了。在utils中新建一个RefreshTokenInterceptor

java 复制代码

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;
        /*此处return true是对的，若return false，第一次访问登录页面时就会被拦截；
若return true，第一次访问登录页会进入Login拦截器，由于登录页为放行路径，放行*/
        }
        // 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();
    }
}

修改LoginInterceptor

java 复制代码

package com.hmdp.utils;

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

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

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;
            //有用户，则放行
        }
        /*从登录拦截器的名字LoginInterceptor就能看出
        其实人家只需要做一件事  就是判断线程中有没有用户就可以了  其他事情交给其他类做*/
        return true;
    }
    @Override
    public void afterCompletion(HttpServletRequest request, HttpServletResponse response, Object handler, Exception ex) throws Exception {
        UserHolder.removeUser();
    }

}

我们希望的是refresh先执行，只有他先执行了拿到我们的用户保存到了sever local，那么在拦截才能去做拦截的判断，是不是这样子？所以说这两个其实是有个先后顺序的，那么我们怎么控制拦截器的执行顺序呢？事实上在我们这个地方我们添加拦截器的时候，大家可以根据看一眼，在我们添加拦截器的时候，拦截器其实会被注册成一个东西叫 intercept registration. 就是注册器。

那么注册器里面其实有一个什么东西，有一个order，就是来仪器的执行顺序，在默认情况下，所有联系的顺序都是0，那都是0的情况下他们怎么执行的，按照添加顺序执行。所以说如果简单来说的话，我们其实只需要干什么？先添加addInterceptor再添addInterceptor是不就ok了？但是如果你想控制的严谨一点，你就可以干什么？给他的order调的稍微小一点，然后给哥们的order调到什么大一点，因为值越大，执行的优先级反而越低，越小优先级是越高的，这样的话我们就可以确保什么？下面先执行上面那个后执行了。Ok，那么我们就把两个连接器添加完毕了，是登录拦截器，那么下边那个是token刷新的拦截器。

java 复制代码

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(stringRedisTemplate))
                .excludePathPatterns(
                        "/shop/**",
                        "/voucher/**",
                        "/shop-type/**",
                        "/upload/**",
                        "/blog/hot",
                        "/user/code",
                        "/user/login"
                ).order(1);
        // token刷新的拦截器
        registry.addInterceptor(new RefreshTokenInterceptor(stringRedisTemplate)).addPathPatterns("/**").order(0);
    }
}