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

已于 2022-12-09 13:56:02 修改
阅读量2.4k 收藏 14
点赞数 2
分类专栏： java个人笔记 redis个人笔记 redis 文章标签： redis spring boot java
于 2022-10-28 08:33:03 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_42094345/article/details/127538007
版权
该博客介绍了使用Java和Spring Boot结合Redis实现Token登录验证的方法。Redis用于存储Token及登录有效期，每次请求延长过期时间，若规定时间内无请求则登录失效。还给出了创建相关Java类、配置文件的步骤，以及Controller登录处理和请求例子。

摘要生成于 C知道 ，由 DeepSeek-R1 满血版支持， 前往体验 >

条件

  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. 请求例子
    在这里插入图片描述

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

Springboot+Jwt+Redis 完成Token登录认证
weixin_44914766的博客
04-14 6781
Springboot+Jwt+Redis 完成Token登录认证前言大致流程知识点一、Token二、JWT三、Redis实现部分引入依赖详细代码1.用户注册2.用户登录密码校验 前言 本章内容建立在Springboot 基础框架搭建好的基础上进行整合jwt+redis 实现token登录认证 大致流程 前端 ：前端拿到登录名和密码，使用JSEncrypt实现rsa将密码进行加密（这个部分网上有很...
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实现JWT+延续token过期时间+修改密码失效token -超简单
qq_39909614的博客
09-09 1万+
废话不多说直接上代码，五步完成第一步引入依赖 第二步JWT工具类,分别实现了【创建token】【获取用户信息】【验证用户是否修改过密码】【是否需要生成新token】 第三步自定义个注解，用来标注哪些方法是需要验证token的 第四步创建一个拦截器 第五步 配置拦截器 大功告成 用就可以了...
springboot 集成jwt设置过期时间_玩转springboot2.x之整合JWT篇
weixin_39638859的博客
11-26 905
点击上方"Java学习之道"，选择"关注"公众号优秀文章，第一时间收到！文章已获得原作者授权，原文地址：https://zhuoqianmingyue.blog.csdn.net/article/details/827517871 如何学习jwt在这里我们来探讨一下如何学习一门新的技术，我个人总结为 RSA。1、R：read 去读官方文档 ，2、S：search 谷歌或百度先关技术文章或...
【SpringBoot】最佳实践——JWT结合Redis实现双Token无感刷新
k123456kah的博客
03-15 1532
JWT是全称是JSON WEB TOKEN，是一个开放标准，用于将各方数据信息作为JSON格式进行对象传递，可以对数据进行可选的数字加密，可使用RSA或ECDSA进行公钥/私钥签名。JWT最常见的使用场景就是缓存当前用户登录信息，当用户登录成功之后，拿到JWT，之后用户的每一个请求在请求头携带上字段来辨别区分请求的用户信息。且不需要额外的资源开销。
Redis实现JWT（JSON Web TOKEN）自动延长TOKEN过期时间
m0_58032776的博客
02-28 2467
JWT是JSON WEB TOKEN的简写，常用于生成及校验Token。常见的使用场景为：用户携带name和秘钥访问后端服务器，应用后端在校验通过后使用JWT生成并返回一串Token，后续用户只需要携带此Token就可以访问服务器，在此不多赘述。本文目的是基于redis实现token自动更新其过期时间，在校验用户姓名和密码后使用JWT工具类生成会过期的Token，当用户携带此Token访问服务器后会自动延长其过期时间。
springboot 使用redis 实现token自动存储和设定过期时间
gaohechao的博客
05-09 9144
使用场景：用户登录系统后，一定时间不使用后，再访问相关接口提示用户此session已经过期，请重新登录 功能大致流程： 首先用户登录成功后，在redis添加一条缓存并设置一个有效时间，标识这个用户登录过系统了。 然后访问其他接口时，添加一个拦截器，获取Header的token是否存在，是否失效。如果没有问题就更新下redis的这条缓存防止他过期。然后调用到接口 比如：我这里调用一个登录接口："user/login" 接口 登录成功后，将token存到redis里，然后将 token 返回给前台，让..
SpringBoot3+Jwt+Redis的Token有效性检查以及自动续期的实现
fatfish517的博客
12-17 2160
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+shiro+redis+jwt .zip
01-03
当JWT过期时，客户端可以通过刷新令牌（Refresh Token）向服务器请求新的JWT，这样用户就不需要重新登录。 项目中的`demo`可能包含了以下组件和配置： 1. `pom.xml`：Maven配置文件，包含了`SpringBoot`、`Shiro`、...
前端刷新token，判断token是否过期（jwt鉴权）
qq_45641978的博客
10-17 4758
4.1 什么是 JWTJWT 是 Auth0 提出的通过 对 JSON 进行加密签名来实现授权验证的方案；就是登录成功后将相关用户信息组成 JSON 对象，然后对这个对象进行某种方式的加密，返回给客户端；客户端在下次请求时带上这个 Token；服务端再收到请求时校验 token 合法性，其实也就是在校验请求的合法性。4.2 JWT 的组成JWT 由三部分组成： Header 头部、 Payload 负载 和 Signature 签名。
SpringBoot 实现 JWT token 自动续期
weixin_43924444的博客
01-19 583
接上次说的jwt作为用户登陆验证token，这次聊一下token的自动续期实战。
springboot集成JWT生成token并自定义拦截器及解决拦截器失效问题
javaXingzhe的博客
03-09 2105
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 1万+
SpringBoot整合SaToken，token自动续期+token定期刷新+注解鉴权
spring session+redis存储session，实现用户登录功能，并在拦截器里面判断用户session是否过期，过期就跳转到登录页面
Java程序员专栏
05-29 2580
在Spring应用中，使用Redis存储Session是一种常见的方式，可以实现分布式环境下的Session管理。：在Spring配置文件中配置Redis连接信息，以便Spring Session能够正确地将Session存储在Redis中。：在你的项目中添加Spring Session和Spring Data Redis的依赖。：首先，确保你的项目中包含Spring Session和Spring Data Redis的相关依赖。：将拦截器配置到Spring MVC中，以便它能够拦截请求并执行相关逻辑。
java服务-springboot拦截器实现用户登录Token及权限校验
码者人生的技术博客
05-30 4663
springboot拦截器主要目标： 拦截请求，验证请求的用户对访问的资源是否有访问权限； 需要排除一些不在权限控制范围内的url，如swagger的接口文档列表； 需要排除的url，在配置文件中进行配置； 双拦截器
利用JWT、注解拦截请求并验证token
立刻有，不强求
06-16 504
在Web应用程序中，注解是一种方便的方式来拦截和处理请求。可以通过在代码中添加注解来定义一些特殊的行为，比如拦截器（Interceptor）等。 拦截器是一种处理请求的技术，它可以在请求被处理之前或之后对请求进行处理。通过使用拦截器，可以在处理请求之前或之后添加额外的逻辑，例如身份验证、权限检查等
Java生成Token并添加拦截器校验Token，实现判断用户是否登录
SongZhengxing_的博客
06-25 2016
添加 TokenConfig，设置需要过滤的接口信息，不在过滤中的接口都将配拦截校验是否存在token。在不加Token的情况下，或者Token已经过期的情况下， 发起请求，返回401。将得到的Token加在请求头中，再次发起请求。可以看到本次请求正常返回200。现在生成一个Token，
Springboot+redis+JWT
最新发布
03-19
### 使用 Spring Boot、Redis 和 JWT 实现身份验证 在现代 Web 应用程序开发中，使用 JWT（JSON Web Token）作为无状态的身份验证机制是一种常见的方式。为了增强系统的安全性并支持分布式部署场景下的会话管理，可以结合 Redis 来存储和管理 JWT 的相关信息。 以下是基于 Spring Boot 3 + Spring Security 6 + JWT + Redis 的实现方案： #### 1. **项目依赖** 首先，在 `pom.xml` 文件中添加必要的依赖项： ```xml <dependencies> <!-- Spring Boot Starter --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-web</artifactId> </dependency> <!-- Spring Security --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-security</artifactId> </dependency> <!-- JWT --> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-api</artifactId> <version>0.11.5</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-impl</artifactId> <scope>runtime</scope> <version>0.11.5</version> </dependency> <dependency> <groupId>io.jsonwebtoken</groupId> <artifactId>jjwt-jackson</artifactId> <scope>runtime</scope> <version>0.11.5</version> </dependency> <!-- Redis --> <dependency> <groupId>org.springframework.boot</groupId> <artifactId>spring-boot-starter-data-redis</artifactId> </dependency> <!-- MySQL and MyBatis (Optional, if using database for user management) --> <dependency> <groupId>mysql</groupId> <artifactId>mysql-connector-java</artifactId> </dependency> <dependency> <groupId>org.mybatis.spring.boot</groupId> <artifactId>mybatis-spring-boot-starter</artifactId> <version>2.3.1</version> </dependency> </dependencies> ``` --- #### 2. **JWT 工具类** 创建一个工具类用于生成和解析 JWT Token。 ```java import io.jsonwebtoken.Claims; import io.jsonwebtoken.Jwts; import io.jsonwebtoken.SignatureAlgorithm; public class JwtUtil { private static final String SECRET_KEY = "your_secret_key"; // 密钥需安全保存 public String generateToken(String username) { return Jwts.builder() .setSubject(username) .signWith(SignatureAlgorithm.HS256, SECRET_KEY) .compact(); } public Claims parseToken(String token) { return Jwts.parser() .setSigningKey(SECRET_KEY) .parseClaimsJws(token) .getBody(); } } ``` --- #### 3. **Redis 配置** 通过 Redis 缓存用户的 Token 及其有效期。 ```java @Configuration public class RedisConfig { @Bean public LettuceConnectionFactory redisConnectionFactory() { return new LettuceConnectionFactory(); // 默认连接本地 Redis } @Bean public RedisTemplate<String, Object> redisTemplate() { RedisTemplate<String, Object> template = new RedisTemplate<>(); template.setConnectionFactory(redisConnectionFactory()); template.setValueSerializer(new GenericJackson2JsonRedisSerializer()); // JSON序列化 return template; } } ``` --- #### 4. **登录逻辑** 当用户成功登录后，生成 JWT 并将其存储到 Redis 中。 ```java @RestController @RequestMapping("/auth") public class AuthController { @Autowired private UserService userService; // 假设有一个服务来处理用户数据 @Autowired private JwtUtil jwtUtil; @Autowired private RedisTemplate<String, Object> redisTemplate; @PostMapping("/login") public ResponseEntity<?> login(@RequestBody LoginRequest request) { User user = userService.authenticate(request.getUsername(), request.getPassword()); if (user != null) { String token = jwtUtil.generateToken(user.getUsername()); // 将 Token 存入 Redis，设置过期时间为 1 天 redisTemplate.opsForValue().set("AUTH:" + token, user.getId(), Duration.ofDays(1)); return ResponseEntity.ok(Map.of("token", token)); } else { throw new RuntimeException("Invalid credentials"); } } } ``` --- #### 5. **拦截器与过滤器** 在请求到达控制器之前，检查 Token 是否有效以及是否存在 Redis 中。 ```java @Component public class JwtAuthenticationFilter extends OncePerRequestFilter { @Autowired private JwtUtil jwtUtil; @Autowired private RedisTemplate<String, Object> redisTemplate; @Override protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException { String authHeader = request.getHeader("Authorization"); if (authHeader != null && authHeader.startsWith("Bearer ")) { try { String token = authHeader.substring(7); // 提取 Token // 检查 Token 是否存在于 Redis 中 Boolean existsInRedis = redisTemplate.hasKey("AUTH:" + token); if (!existsInRedis) { response.setStatus(HttpServletResponse.SC_UNAUTHORIZED); return; } // 解析 Token 获取用户名 Claims claims = jwtUtil.parseToken(token); UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken( claims.getSubject(), null, Collections.emptyList() ); SecurityContextHolder.getContext().setAuthentication(authentication); } catch (Exception e) { response.setStatus(HttpServletResponse.SC_FORBIDDEN); return; } } filterChain.doFilter(request, response); } } ``` --- #### 6. **Spring Security 配置** 配置 Spring Security 以启用自定义过滤器。 ```java @EnableWebSecurity public class SecurityConfig { @Bean public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception { http.csrf().disable() .authorizeHttpRequests() .requestMatchers("/auth/login").permitAll() .anyRequest().authenticated() .and() .addFilterBefore(new JwtAuthenticationFilter(), UsernamePasswordAuthenticationFilter.class); return http.build(); } } ``` --- ### 总结 上述方法展示了如何利用 Spring Boot、Redis 和 JWT 构建一套完整的身份验证解决方案[^1]。该方案不仅实现了无状态的 Token 认证，还借助 Redis 提供了高效的 Token 管理能力[^4]。
评论 3
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

打赏作者

zhopq

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

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

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

打赏作者

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

抵扣说明：

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

余额充值