Springboot入门教程（5）-结合redis自动刷新token

上一篇教程中我梳理了如何用jwt做用户的登录拦截，token验证，这里作为实际项目使用会有个问题，即jwt无法将生成的token无效化，故为了安全性，jwt生成的token有效时间不能设定的太长，但是如果每次token过期后都要让用户重新登录的话，对用户来说体验又非常不好。所以在用户无感知的情况下做token刷新也是非常有必要的。
本篇我就结合redis的使用，来说明如何自动刷新token。token的刷新方案并非固定，我这里主要参考的是这篇博客中的方案https://segmentfault.com/a/1190000014545422。
预备环境：安装redis并启动，参考菜鸟教程-Redis 安装

首先引入依赖包

implementation 'org.springframework.boot:spring-boot-starter-data-redis'

接着配置application.properties

# Redis数据库索引（默认为0）
spring.redis.database=0 
# Redis服务器地址
spring.redis.host=localhost
# Redis服务器连接端口
spring.redis.port=6379 
# Redis服务器连接密码（默认为空）
spring.redis.password=
#连接池最大连接数（使用负值表示没有限制）
spring.redis.jedis.pool.max-active=8
# 连接池最大阻塞等待时间（使用负值表示没有限制）
spring.redis.jedis.pool.max-wait=-1
# 连接池中的最大空闲连接
spring.redis.jedis.pool.max-idle=8
# 连接池中的最小空闲连接
spring.redis.jedis.pool.min-idle=0
# 连接超时时间（毫秒）
spring.redis.timeout=300

由于我这里基本采用了默认的配置，所以这一步其实也可以省略。

之后由于Springboot中一般使用RedisTemplate提供的方法来操作Redis，所以需要配置RedisTemplate，在utils包中新建一个配置类RedisConfig。

@Configuration
@EnableCaching //开启注解
public class RedisConfig extends CachingConfigurerSupport {

    /**
     * retemplate相关配置
     * @param factory
     * @return
     */
    @Bean
    public RedisTemplate<String, Object> redisTemplate(RedisConnectionFactory factory) {

        RedisTemplate<String, Object> template = new RedisTemplate<>();
        // 配置连接工厂
        template.setConnectionFactory(factory);

        //使用Jackson2JsonRedisSerializer来序列化和反序列化redis的value值（默认使用JDK的序列化方式）
        Jackson2JsonRedisSerializer jacksonSeial = new Jackson2JsonRedisSerializer(Object.class);

        ObjectMapper om = new ObjectMapper();
        // 指定要序列化的域，field,get和set,以及修饰符范围，ANY是都有包括private和public
        om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);
        // 指定序列化输入的类型，类必须是非final修饰的，final修饰的类，比如String,Integer等会跑出异常
        om.activateDefaultTyping(LaissezFaireSubTypeValidator.instance,ObjectMapper.DefaultTyping.NON_FINAL);
        jacksonSeial.setObjectMapper(om);

        // 值采用json序列化
        template.setValueSerializer(jacksonSeial);
        //使用StringRedisSerializer来序列化和反序列化redis的key值
        template.setKeySerializer(new StringRedisSerializer());

        // 设置hash key 和value序列化模式
        template.setHashKeySerializer(new StringRedisSerializer());
        template.setHashValueSerializer(jacksonSeial);
        template.afterPropertiesSet();

        return template;
    }
}

这部分的代码主要作用就是配置序列化器，这里配置的是用jackson来序列化redis中value的值，使redis可以支持json格式数据的存储和读取。

然后在utils包中新建一个redis的工具类RedisUtil。

@Component
public class RedisUtil {
    @Autowired
    private RedisTemplate<String, Object> redisTemplate;

    public RedisUtil(RedisTemplate<String, Object> redisTemplate) {
        this.redisTemplate = redisTemplate;
    }

    //============================String=============================
    /**
     * 普通缓存获取
     * @param key 键
     * @return 值
     */
    public Object get(String key){
        return key==null?null:redisTemplate.opsForValue().get(key);
    }

    /**
     * 普通缓存放入
     * @param key 键
     * @param value 值
     * @return true成功 false失败
     */
    public boolean set(String key,Object value) {
        try {
            redisTemplate.opsForValue().set(key, value);
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }

    /**
     * 普通缓存放入并设置时间
     * @param key 键
     * @param value 值
     * @param time 时间(秒) time要大于0 如果time小于等于0 将设置无限期
     * @return true成功 false 失败
     */
    public boolean set(String key,Object value,long time){
        try {
            if(time>0){
                redisTemplate.opsForValue().set(key, value, time, TimeUnit.SECONDS);
            }else{
                set(key, value);
            }
            return true;
        } catch (Exception e) {
            e.printStackTrace();
            return false;
        }
    }
}

这里我们目前只写了3个方法，其中set方法也主要使用设定时间的。

之后修改UserController中的登录方法，在生成token之后将username和token以键值对保存到redis中

String token = JWTUtil.genToken(map, new Date(System.currentTimeMillis() + 60L* 1000L * 30L));
redisUtil.set(username, token, 60 * 60 * 2);

最后在TokenInterceptor中添加token过期后刷新的逻辑

@Override
    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
        if (request.getMethod().equals("OPTIONS")){
            response.setStatus(HttpServletResponse.SC_OK);
            return true;
        }
        response.setCharacterEncoding("utf-8");
        String token = request.getHeader("token");
        String responseData = "{\"code\":401,\"message\":\"Unauthorized\"}";
        //token不存在
        if(null != token) {
            Map<String, String> login = JWTUtil.verifyToken(token);
            String username = request.getHeader("username");
            //解密token后的loginId与用户传来的loginId不一致，一般都是token过期
            if(null != username && null != login) {
                if(username.equals(login.get("username"))) {
                    return true;
                }
                else{
                    // 刷新token逻辑 start
                    String redisCache = (String) redisUtil.get(username);
                    if(token.equals(redisCache)){
                        Map<String, String> map = new HashMap<String, String>();
                        map.put("username", username);
                        String newToken = JWTUtil.genToken(map, new Date(System.currentTimeMillis() + 60L* 1000L * 30L));
                        redisUtil.set(username, newToken, 60 * 60 * 2);
                        responseData = "{\"code\":100,\"message\":\"Token expired, a new token generated.\",\"token\":\"" + newToken + "\"}";
                        System.out.println(responseData);
                        responseMessage(response, response.getWriter(), responseData);
                        return false;
                    }
                    // 刷新token逻辑 end
                    responseMessage(response, response.getWriter(), responseData);
                    return false;
                }
            }
            else
            {
                responseMessage(response, response.getWriter(), responseData);
                return false;
            }
        }
        else
        {
            responseMessage(response, response.getWriter(), responseData);
            return false;
        }
    }

这样如果在30分钟后2小时以内token过期，则可以在redis中找到缓存的username对应的token，允许刷新token，返回给前端，前端接收到新的token后替换，重新发送请求。这样只要用户两次操作间隔时间不超过2小时，便不用重新登录。

本篇教程中的代码依旧可以参考我在github上面的代码https://github.com/ahuadoreen/studentmanager

本篇参考文档
https://segmentfault.com/a/1190000014545422
https://www.jianshu.com/p/5596c3a4978d
https://blog.csdn.net/qq_36781505/article/details/86612988