SpringBoot+JWT+redis实现拦截器(每次请求更新token过期时间)

原创 已于 2022-12-09 13:56:02 修改 · 2.5k 阅读 · 14 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#redis #spring boot #java

于 2022-10-28 08:33:03 首次发布
该博客介绍了使用Java和Spring Boot结合Redis实现Token登录验证的方法。Redis用于存储Token及登录有效期，每次请求延长过期时间，若规定时间内无请求则登录失效。还给出了创建相关Java类、配置文件的步骤，以及Controller登录处理和请求例子。

条件

  1. redis(用来存储token以及登录有效期,如果没有不用redis,token可以存在session或者cookie里)
  2. 每次请求延长过期时间.生成的token有效期设置长一些,存到redis里面,每次请求查看redis是否有token,如果有请求成功redis延长,如果没有就代表在规定时间内没有请求过则登录失效,重新登录,以此循环.

废话不多说,上代码(看注释)

  1. pom.xml
		<dependency>
            <groupId>com.auth0</groupId>
            <artifactId>java-jwt</artifactId>
            <version>3.19.1</version>
        </dependency>
  1. 创建JwtUtil.java 用token获取用户id,以及使用用户id生成token(可以加上其他信息一起)
package com.ly.remind.common.util;

import com.auth0.jwt.JWT;
import com.auth0.jwt.JWTCreator;
import com.auth0.jwt.algorithms.Algorithm;
import com.auth0.jwt.interfaces.DecodedJWT;
import com.ly.remind.common.constants.CommonConstants;
import lombok.Data;

import java.util.Calendar;

/**
 * @ClassName: JWTUtil.java
 * @Program: com.ly.remind.common.util.JwtUtil
 * @Date: 2022/10/26 上午10:27
 * @Author: Zhaop
 * @Description: jwt token util
 */
@Data
public class JwtUtil {
    // 任意字符串
    private static final String SING = "!A;E]R'T'!S-*G-S*'S[;HS.HH]D*S-VS+D=GS-=";

    private static String token;
    
    // 过期时间 小时 可以设的长一点,通过redis的过期时间来决定用户登录的有效时长
    private static final Integer EXPIRATION_TIME = 24*30;


    /***
     *@Author: Zhaop
     *@Params: [id, ttlMinute:过期时间,分钟]
     *@Return: java.lang.String
     *@Date: 2022/10/26 下午12:31
     *@Description: 生成用户token
     *@Notes:
     */
    public static String getJWToken(String id) {

        Calendar instance = Calendar.getInstance();
        // 设置过期时间
        instance.add(Calendar.HOUR, EXPIRATION_TIME);

        JWTCreator.Builder builder = JWT.create();
        // 指定标识字段
        builder.withClaim(CommonConstants.JwtConstants.TOKEN_KEY, id);
        // 指定过期时间
        token = builder.withExpiresAt(instance.getTime())
                // 指定生成算法及签名
                .sign(Algorithm.HMAC256(SING));

        return token;
    }

    /***
     *@Author: Zhaop
     *@Params: [token]
     *@Return: boolean
     *@Date: 2022/10/26 下午12:36
     *@Description: 验证token, 返回true或false
     *@Notes:
     */
    public static boolean verify(String token) {
        try {
            JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
            return true;
        } catch (Exception e) {
            return false;
        }
    }

    /****
     *@Author: Zhaop
     *@Params: [token]
     *@Return: com.auth0.jwt.interfaces.DecodedJWT
     *@Date: 2022/10/26 下午12:35
     *@Description: 验证token, 正确通过, 否则抛出异常
     *@Notes:
     */
    public static DecodedJWT verifyToken(String token) {
        return JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
    }

    /***
     *@Author: Zhaop
     *@Params: [token]
     *@Return: int
     *@Date: 2022/10/26 下午12:35
     *@Description: 从token中获取用户id
     *@Notes:
     */
    public static String getIdByToken(String token) {
        DecodedJWT verify = JWT.require(Algorithm.HMAC256(SING)).build().verify(token);
        return verify.getClaim(CommonConstants.JwtConstants.TOKEN_KEY).asString();
    }


}
  1. 创建jwt.yaml 也可以直接写在方法里或者application.properties/yaml里,写在这方便维护看自己需求
jwt:
  # 需要拦截的路径,逗号分割 不能带引号
  verify: /**
  # 需要放行的路径,逗号分割 不能带引号
  skip: /api/**
  1. 创建WebMvcConfig.java 实现WebMvcConfigurer接口做拦截逻辑(重要)
package com.ly.remind.config;

import com.auth0.jwt.exceptions.AlgorithmMismatchException;
import com.auth0.jwt.exceptions.SignatureVerificationException;
import com.auth0.jwt.exceptions.TokenExpiredException;
import com.ly.remind.common.constants.CommonConstants;
import com.ly.remind.common.constants.RedisConstants;
import com.ly.remind.common.enums.ResponseEnum;
import com.ly.remind.common.util.JwtUtil;
import com.ly.remind.common.util.RedisUtil;
import lombok.Data;
import org.apache.commons.lang3.StringUtils;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Value;
import org.springframework.boot.context.properties.ConfigurationProperties;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.context.annotation.PropertySource;
import org.springframework.web.method.HandlerMethod;
import org.springframework.web.servlet.HandlerInterceptor;
import org.springframework.web.servlet.config.annotation.CorsRegistry;
import org.springframework.web.servlet.config.annotation.InterceptorRegistry;
import org.springframework.web.servlet.config.annotation.WebMvcConfigurer;

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

/**
 * @ClassName: WebMvcConfig.java
 * @Program: com.ly.remind.config.WebMvcConfig
 * @Date: 2022/10/26 上午10:33
 * @Author: Zhaop
 * @Description: 拦截器以及拦截处理
 * 
 */
@Data
@Configuration
@ConfigurationProperties(prefix = "jwt") 
@PropertySource(value = {"classpath:jwt.yaml"})
public class WebMvcConfig implements WebMvcConfigurer {
    @Value("${verify}")
    private String[] verify;
    @Value("${skip}")
    private String[] skip;

    @Autowired
    private RedisUtil redisUtil;
    /***
     *@Author: Zhaop
     *@Params: [request, response, handler]
     *@Return: boolean
     *@Date: 2022/10/26 下午6:35
     *@Description: 拦截处理
     *@Notes: 
     */
    @Override
    public void addInterceptors(InterceptorRegistry registry) {
        // 用户拦截器
        registry.addInterceptor(
                new HandlerInterceptor() {
                    @Override
                    public boolean preHandle(HttpServletRequest request, HttpServletResponse response, Object handler) throws Exception {
                        // 如果不是映射到方法直接通过
                        if (!(handler instanceof HandlerMethod)) {
                            return true;
                        }
						
						// 从请求中获取token
                        String token = request.getHeader("token");

                        // 捕获刚刚JWT中抛出的异常,并封装对应的返回信息
                        try {
                             // 通过token获取id
                            String userId = JwtUtil.getIdByToken(token);
                            String s = redisUtil.get(RedisConstants.USER_TOKEN_KEY + userId);
                            // token不存在，或者token不同均不放行
                            if (StringUtils.isBlank(s) || !token.equals(s)) {
                                throw new TokenExpiredException("未登录!");
                            }
                            //请求成功 redis 延长登录的过期时间
                            redisUtil.setExOfMill(RedisConstants.USER_TOKEN_KEY + userId, token, CommonConstants.JwtConstants.EXPIRATION_TIME_30M);
                            // 验证通过刷新redis-token
                            return true;
                        } catch (SignatureVerificationException e) {
                            // 无效签名
                            ResponseEnum.USER_NOT_LOGGED_IN.assertNotNull(null);
                        } catch (TokenExpiredException e) {
                            // 已过期
                            ResponseEnum.USER_NOT_LOGGED_IN.assertNotNull(null);
                        } catch (AlgorithmMismatchException e) {
                            // 算法不一致
                            ResponseEnum.USER_NOT_LOGGED_IN.assertNotNull(null);
                        } catch (Exception e) {
                            // 无效身份信息
                            ResponseEnum.USER_NOT_LOGGED_IN.assertNotNull(null);
                        }
                        return false;
                    }
                }
        )
                // 需要拦截的请求
                .addPathPatterns(verify)
                // 需要放行的请求
                .excludePathPatterns(skip);
    }

    /**
     * 跨域支持
     *
     * @param registry
     */
    @Override
    public void addCorsMappings(CorsRegistry registry) {
        registry.addMapping("/**");
    }

    @Bean
    public WebMvcConfig getWebMvcConfig() {
        return new WebMvcConfig();
    }

}
  1. Controller登录中的处理 主要是登录之后的处理
package com.ly.remind.controller;


import com.ly.remind.common.constants.CommonConstants;
import com.ly.remind.common.constants.RedisConstants;
import com.ly.remind.common.resp.ResultMessage;
import com.ly.remind.common.util.JwtUtil;
import com.ly.remind.common.util.RedisUtil;
import com.ly.remind.service.IUserService;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RestController;

import javax.annotation.Resource;

/**
 * <p>
 * 用户信息表 前端控制器
 * </p>
 *
 * @author Zhaop
 * @since 2022-10-25
 */
@RestController
public class UserController {
    @Resource
    private IUserService iUserService;
    @Resource
    private RedisUtil redisUtil;

    @PostMapping("/api/loggin")
    public ResultMessage login() {
    	// user-id123就是用户id,我这里直接写死了,程序中改成动态的
        String token = JwtUtil.getJWToken("user-id123");
        // 存储到redis中，在禁用用户的同时可以强制踢下线 过期时间30分钟
        redisUtil.setExOfMill(RedisConstants.USER_TOKEN_KEY + "user-id123", token, CommonConstants.JwtConstants.EXPIRATION_TIME_30M);
        ResultMessage resultMessage = new ResultMessage();
        resultMessage.setCode(1);
        resultMessage.setMsg("ok");
        // token返回给前端,每次请求需带上(放在请求头)
        resultMessage.setData(token);
        return resultMessage;
    }

    @GetMapping("/user/userinfo")
    public ResultMessage userinfo() {
        ResultMessage resultMessage = new ResultMessage();
        resultMessage.setCode(1);
        resultMessage.setMsg("ok");
        return resultMessage;
    }
}
  1. 请求例子
    在这里插入图片描述

点赞加关注,代码不迷路~
点赞加关注,代码不迷路~
点赞加关注,代码不迷路~

Redis实现JWT（JSON Web TOKEN）自动延长TOKEN过期时间
m0_58032776的博客
02-28 2780
JWT是JSON WEB TOKEN的简写，常用于生成及校验Token。常见的使用场景为：用户携带name和秘钥访问后端服务器，应用后端在校验通过后使用JWT生成并返回一串Token，后续用户只需要携带此Token就可以访问服务器，在此不多赘述。本文目的是基于redis实现token自动更新其过期时间，在校验用户姓名和密码后使用JWT工具类生成会过期的Token，当用户携带此Token访问服务器后会自动延长其过期时间。
Springboot+Jwt+Redis 完成Token登录认证
weixin_44914766的博客
04-14 6917
Springboot+Jwt+Redis 完成Token登录认证前言大致流程知识点一、Token二、JWT三、Redis实现部分引入依赖详细代码1.用户注册2.用户登录密码校验 前言 本章内容建立在Springboot 基础框架搭建好的基础上进行整合jwt+redis 实现token登录认证 大致流程 前端 ：前端拿到登录名和密码，使用JSEncrypt实现rsa将密码进行加密（这个部分网上有很...
最新SpringBoot实现JWT+延续token过期时间+修改密码失效token -超简单
qq_39909614的博客
09-09 1万+
废话不多说直接上代码，五步完成第一步引入依赖 第二步JWT工具类,分别实现了【创建token】【获取用户信息】【验证用户是否修改过密码】【是否需要生成新token】 第三步自定义个注解，用来标注哪些方法是需要验证token的 第四步创建一个拦截器 第五步 配置拦截器 大功告成 用就可以了...
springboot 集成jwt设置过期时间_玩转springboot2.x之整合JWT篇
weixin_39638859的博客
11-26 943
点击上方"Java学习之道"，选择"关注"公众号优秀文章，第一时间收到！文章已获得原作者授权，原文地址：https://zhuoqianmingyue.blog.csdn.net/article/details/827517871 如何学习jwt在这里我们来探讨一下如何学习一门新的技术，我个人总结为 RSA。1、R：read 去读官方文档 ，2、S：search 谷歌或百度先关技术文章或...
springboot 使用redis 实现token自动存储和设定过期时间
gaohechao的博客
05-09 9259
使用场景：用户登录系统后，一定时间不使用后，再访问相关接口提示用户此session已经过期，请重新登录 功能大致流程： 首先用户登录成功后，在redis添加一条缓存并设置一个有效时间，标识这个用户登录过系统了。 然后访问其他接口时，添加一个拦截器，获取Header的token是否存在，是否失效。如果没有问题就更新下redis的这条缓存防止他过期。然后调用到接口 比如：我这里调用一个登录接口："user/login" 接口 登录成功后，将token存到redis里，然后将 token 返回给前台，让..
SpringBoot3+Jwt+Redis的Token有效性检查以及自动续期的实现
fatfish517的博客
12-17 2400
1. 续期在后端完成，只给前端传递一个token，不采用两个token的方式，从而不增加前端工作量 2. 默认情况下解析Jwt token 时过期的token将抛出过期错误，因为需要自动续期，因此应忽略该错误。 3. token等信息保存在Redis中，并设置过期时间为token的过期时间。过期后保存信息自动删除 。修改此处过期时间实现延期 4. 记录每次前端请求的时间至Redis中。 5. 验证token有效性时，若距离最近一次请求的时差未超过定义的过期时间增量，则尝试进行续期操作
基于springboot+jwt实现刷新token过程解析
08-19
在拦截器中，我们使用JwtUtil.verify()方法来验证Token的有效期，如果 Token 已经过期，则重新登录。 优点和缺点 在线刷新Token的方式可以实时刷新Token，提高了系统的安全性。但是，这种方式需要频繁地访问Redis，...
springboot整和jwt、shiro、redis实现token自动刷新
08-19
此外，还需要编写一个TokenFilter，这个过滤器会在每次请求时检查请求头中的JWT，如果发现Token即将过期，就调用刷新接口获取新的Token。这个过程应该设计为无感知的，即用户在正常使用应用时，后台自动完成Token的...
SpringBoot+JWT+Redis实现单点登录功能
weixin_39388918的博客
08-02 1万+
代码结构图 代码，从上往下 AESSecretUtil： package com.jwt.demo; import org.apache.commons.lang3.ArrayUtils; import org.apache.commons.lang3.StringUtils; import javax.crypto.Cipher; import javax.crypto.KeyGenera...
SpringBoot+shiro+redis+jwt .zip
01-03
当JWT过期时，客户端可以通过刷新令牌（Refresh Token）向服务器请求新的JWT，这样用户就不需要重新登录。 项目中的`demo`可能包含了以下组件和配置： 1. `pom.xml`：Maven配置文件，包含了`SpringBoot`、`Shiro`、...
前端刷新token，判断token是否过期（jwt鉴权）
qq_45641978的博客
10-17 5255
4.1 什么是 JWTJWT 是 Auth0 提出的通过 对 JSON 进行加密签名来实现授权验证的方案；就是登录成功后将相关用户信息组成 JSON 对象，然后对这个对象进行某种方式的加密，返回给客户端；客户端在下次请求时带上这个 Token；服务端再收到请求时校验 token 合法性，其实也就是在校验请求的合法性。4.2 JWT 的组成JWT 由三部分组成： Header 头部、 Payload 负载 和 Signature 签名。
SpringBoot 实现 JWT token 自动续期
weixin_43924444的博客
01-19 645
接上次说的jwt作为用户登陆验证token，这次聊一下token的自动续期实战。
springboot集成JWT生成token并自定义拦截器及解决拦截器失效问题
javaXingzhe的博客
03-09 2198
1.导入jwt依赖 <dependency> <groupId>com.auth0</groupId> <artifactId>java-jwt</artifactId> <version>3.10.3</version> </dependency> 2.配置拦截 /** * WebMvcConfig配置 */ @Configuration public class WebM
【SaToken使用】SpringBoot整合SaToken（一）token自动续期+token定期刷新+注解鉴权
热门推荐
weixin_43165220的博客
09-28 2万+
SpringBoot整合SaToken，token自动续期+token定期刷新+注解鉴权
spring session+redis存储session，实现用户登录功能，并在拦截器里面判断用户session是否过期，过期就跳转到登录页面
最新发布
Java程序员专栏
05-29 2823
在Spring应用中，使用Redis存储Session是一种常见的方式，可以实现分布式环境下的Session管理。：在Spring配置文件中配置Redis连接信息，以便Spring Session能够正确地将Session存储在Redis中。：在你的项目中添加Spring Session和Spring Data Redis的依赖。：首先，确保你的项目中包含Spring Session和Spring Data Redis的相关依赖。：将拦截器配置到Spring MVC中，以便它能够拦截请求并执行相关逻辑。
SpringBoot2.0 整合 Shiro+JWT+Redis 实现图形、短信验证码登陆
fenyudelushang的博客
11-17 1409
这里使用到了Redis来实现JWT的过期刷新，话不多说，具体的实现代码如下。 1.自定义AuthenticationToken类 public final class JwtToken implements AuthenticationToken { private static final long serialVersionUID = 1L; private String jwttoken; public JwtToken(String jwttoken) {
JWT登录过期-自动刷新token方案介绍
weixin_42397937的博客
08-14 1万+
JWT登录过期-自动刷新token方案介绍前言方案一、前端控制检测token，无感知刷新刷新方案核心逻辑疑问：RefreshToken有效期那么长，和直接将AccessToken的有效期延长有什么区别缺点：优点：方案二、后端存储判断过期时间优点：缺点：总结 前言 在前后分离场景下，越来越多的项目使用jwt token作为接口的安全机制,但存在jwt过期后，用户无法直接感知，假如在用户操作页面期间，突然提示登录，则体验很不友好，所以就有了token自动刷新需求。 但是这个自动刷新方案，基本都离不开服务端状.
java服务-springboot拦截器实现用户登录Token及权限校验
码者人生的技术博客
05-30 4770
springboot拦截器主要目标： 拦截请求，验证请求的用户对访问的资源是否有访问权限； 需要排除一些不在权限控制范围内的url，如swagger的接口文档列表； 需要排除的url，在配置文件中进行配置； 双拦截器
基于SpringBoot+Redis+JWT实现单点登录与设备控制
为了统一拦截未授权访问，系统设计了全局认证拦截器AuthenticationInterceptor，在请求进入Controller之前进行预处理：解析请求头中的Bearer Token，调用JWT工具类验证其签名有效性与时效性，随后尝试从Redis中查找...
评论 3
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

zhopq

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值