当前位置：首页 > news >正文

Spring Security 6 系列之九 - 集成JWT

news 来源：原创 2025/5/17 10:46:31

之所以想写这一系列，是因为之前工作过程中使用Spring Security，但当时基于spring-boot 2.3.x，其默认的Spring Security是5.3.x。之后新项目升级到了spring-boot 3.3.0，结果一看Spring Security也升级为6.3.0，关键是其风格和内部一些关键Filter大改，导致在配置同样功能时，多费了些手脚，因此花费了些时间研究新版本的底层原理，这里将一些学习经验分享给大家。

注意：由于框架不同版本改造会有些使用的不同，因此本次系列中使用基本框架是 spring-boo-3.3.0（默认引入的Spring Security是6.3.0），JDK版本使用的是19，所有代码都在spring-security-study项目上：https://github.com/forever1986/spring-security-study.git

1 JWT

1.1 为什么使用JWT

最开始的前后端分离之间的交互是通过保持状态的Session方式，也就服务器通过生成Session信息保存在服务器中并返回给客户端，客户端（通常是浏览器）将信息存入Cookie里面，每次访问都是拿着Cookie访问（一般浏览器自动完成），服务器通过客户端传输的信息与服务器的Session进行比对验证。因为Session属于有状态的，因此有这么两个大缺点：

缺点一：服务器要存储Session信息，如果并发量较大，对于服务器来说需要占用很大内存
缺点二：Session信息默认存储在服务器上，这对于集群部署来说就不适用，还需要一个同一个存储的地方，比如Redis（系列6中已经讲过）

基于以上两个缺点，JWT就出现了。

JWT是一种无状态，也就是认证的时候，服务器给客户端一个token之后，服务器无需保留token
由于无状态，因此解决集群部署问题，客户端携带token的访问，在任何服务器都可以鉴权
JWT包括3部分：header（声明和加密算法）、Payload（有效数据）、Signature（签名，是整个数据的认证信息，保证认证安全性和有效性）。

1.2 JWT格式

JWT 包含三部分数据：

Header：头部，通常头部有两部分信息：
声明类型(typ)，这里是JWT
加密算法(alg)，自定义

这部分会采用 Base64编码，得到数据。

Payload：载荷，就是设置想要存储的数据，你可以将部分信息放在token中，以下是规范中的内置对象：

iss (issuer)：表示签发人
exp (expiration time)：表示token过期时间
sub (subject)：内容，可以使用json放置用户基本信息
aud (audience)：受众
nbf (Not Before)：生效时间
iat (Issued At)：签发时间
jti (JWT ID)：编号

这部分会采用 Base64编码，得到数据。

Signature：签名，是对数据进行认证的签名。根据前两步的数据+密钥 secret（密码可以是对称或非对称），通过 Header 中配置的加密算法(alg)进行验证。用于验证整个数据完整和可靠性。

以下是一个JWT数据，可以使用在线JWT解析工具解析：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.eyJqdGkiOiJkMDk0MDBmODY5ZmY0MjgxOGYxOTFjZTE4ZDEwNjU2ZiIsInN1YiI6InVzZXI6NCIsImlzcyI6InNwcmluZy1zZWN1cml0eS1zdHVkeSIsImlhdCI6MTczNDQ4ODkzNywiZXhwIjoxNzM0NDg5MjM3fQ.X9V8DgX8ay8vQRLdA7tV8-MHKJxPv9e2gLqDs3Fpk9s

2 Spring Security集成JWT

代码参考lesson09子模块

本项目说明：

本项目依赖mysq和Redis，其中mysq中创建一个数据库，名为spring_security_study，创建用户表t_user（参考系列2）
采用基于数据库用户的认证
采用前后端分离，会自定义登录和登出接口，同时会屏蔽默认登录登出页面
使用JWT生成token认证，因此会屏蔽默认Session管理，由于没有Session管理，因此我们需要自己做token管理。这里使用Redis存储token，同时自定义JwtAuthenticationTokenFilter过滤器，用于在访问时验证token，设置SecurityContext。

2.1 项目新建

1）新建lesson09子模块，其pom引入依赖如下：

<dependencies><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-web</artifactId></dependency><dependency><groupId>org.projectlombok</groupId><artifactId>lombok</artifactId><optional>true</optional></dependency><!--Spring Boot 提供的 Security 启动器 --><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-security</artifactId></dependency><dependency><groupId>com.baomidou</groupId><artifactId>mybatis-plus-spring-boot3-starter</artifactId></dependency><dependency><groupId>mysql</groupId><artifactId>mysql-connector-java</artifactId><scope>runtime</scope></dependency><dependency><groupId>com.alibaba</groupId><artifactId>druid-spring-boot-starter</artifactId></dependency><dependency><groupId>com.alibaba</groupId><artifactId>fastjson</artifactId></dependency><dependency><groupId>io.jsonwebtoken</groupId><artifactId>jjwt</artifactId></dependency><dependency><groupId>org.springframework.boot</groupId><artifactId>spring-boot-starter-data-redis</artifactId></dependency><dependency><groupId>javax.xml.bind</groupId><artifactId>jaxb-api</artifactId></dependency></dependencies>

2）创建com.demo.lesson09包，并创建启动类SecurityLesson09Application

3）在controller包下，新增DemoController，用于测试

@RestController
public class DemoController {@GetMapping("/demo")public String demo() {return"demo";}}

4）在resources下新增yaml，配置Mysql、redis和mybatis配置

server:port: 8080
spring:# 配置数据源datasource:type: com.alibaba.druid.pool.DruidDataSourcedriver-class-name: com.mysql.cj.jdbc.Driverurl: jdbc:mysql://127.0.0.1:3306/spring_security_study?serverTimezone=Asia/Shanghai&useUnicode=true&characterEncoding=utf-8&zeroDateTimeBehavior=convertToNull&useSSL=false&allowPublicKeyRetrieval=trueusername: rootpassword: rootdruid:initial-size: 5min-idle: 5maxActive: 20maxWait: 3000timeBetweenEvictionRunsMillis: 60000minEvictableIdleTimeMillis: 300000validationQuery: select 'x'testWhileIdle: truetestOnBorrow: falsetestOnReturn: falsepoolPreparedStatements: falsefilters: stat,wall,slf4jconnectionProperties: druid.stat.mergeSql=true;druid.stat.slowSqlMillis=5000;socketTimeout=10000;connectTimeout=1200#redis配置data:redis:host: 127.0.0.1mybatis-plus:global-config:banner: falsemapper-locations: classpath:mappers/*.xmltype-aliases-package: com.demo.lesson05.entityconfiguration:cache-enabled: falselocal-cache-scope: statement

2.2 返回异常处理类

1）增加result包和handler包，里面的类参考lesson07子模块，拷贝以下类：

IResultCode
Result
ResultCode
DemoAccessDeniedHandler ：授权异常处理
DemoAuthenticationEntryPoint ：认证异常处理

2.3 自定义基于数据库的用户

1）不清楚的可以回顾lesson03子模块，这里做了一些小改动

2）在entity包下新增LoginUserDetails类，自定义类为了能够Redis序列化，之前使用Security默认的User，在Redis反序列化会报错

@Data
@NoArgsConstructor
@AllArgsConstructor
@JsonIgnoreProperties(ignoreUnknown = true)
public class LoginUserDetails implements UserDetails {private TUser tUser;@Override@JsonIgnorepublic Collection<? extends GrantedAuthority> getAuthorities() {return List.of();}@Overridepublic String getPassword() {return tUser.getPassword();}@Overridepublic String getUsername() {return tUser.getUsername();}@Overridepublic boolean isAccountNonExpired() {return true;}@Overridepublic boolean isAccountNonLocked() {return true;}@Overridepublic boolean isCredentialsNonExpired() {return true;}@Overridepublic boolean isEnabled() {return true;}
}

3）定义entity包下的TUser和对应mapper包下的TUserMapper

@Data
public class TUser {@TableId(type = IdType.ASSIGN_ID)private Long id;private String username;private String password;private String email;private String phone;}

@Mapper
public interface TUserMapper {// 根据用户名，查询用户信息@Select("select * from t_user where username = #{username}")TUser selectByUsername(String username);}

4）在service包下，建立JdbcUserDetailsServiceImpl（实现UserDetailsService），用于基于数据库查询用户

@Service
public class JdbcUserDetailsServiceImpl implements UserDetailsService {@Autowiredprivate TUserMapper tUserMapper;@Overridepublic UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {// 查询自己数据库的用户信息TUser user = tUserMapper.selectByUsername(username);if(user == null){throw new UsernameNotFoundException(username);}return new LoginUserDetails(user);}}

2.4 Redis配置

1）在config包下，新增RedisConfiguration，用于Redis的序列化配置

@Configuration
public class RedisConfiguration {/*** 主要做redis配置。redis有2种不同的template（2种的key不能共享）* 1.StringRedisTemplate：以String作为存储方式：默认使用StringRedisTemplate，其value都是以String方式存储* 2.RedisTemplate：*    1）使用默认RedisTemplate时，其value都是根据jdk序列化的方式存储*    2）自定义Jackson2JsonRedisSerializer序列化，以json格式存储，其key与StringRedisTemplate共享，返回值是LinkedHashMap*    3）自定义GenericJackson2JsonRedisSerializer序列化，以json格式存储，其key与StringRedisTemplate共享，返回值是原先对象(因为保存了classname)*/@Bean@ConditionalOnMissingBean({RedisTemplate.class})public RedisTemplate redisTemplate(RedisConnectionFactory factory) {RedisTemplate<String, Object> template = new RedisTemplate();template.setConnectionFactory(factory);//本实例采用GenericJackson2JsonRedisSerializerObjectMapper om = new ObjectMapper();om.setVisibility(PropertyAccessor.ALL, JsonAutoDetect.Visibility.ANY);GenericJackson2JsonRedisSerializer jackson2JsonRedisSerializer = new GenericJackson2JsonRedisSerializer();StringRedisSerializer stringRedisSerializer = new StringRedisSerializer();template.setKeySerializer(stringRedisSerializer);template.setHashKeySerializer(stringRedisSerializer);template.setValueSerializer(jackson2JsonRedisSerializer);template.setHashValueSerializer(jackson2JsonRedisSerializer);template.afterPropertiesSet();return template;}@Bean@ConditionalOnMissingBean({StringRedisTemplate.class})public StringRedisTemplate stringRedisTemplate(RedisConnectionFactory factory) {StringRedisTemplate template = new StringRedisTemplate();template.setConnectionFactory(factory);return template;}}

2.5 自定义登录和登出接口

1）在entity包下定义LoginDTO类，用于前后端参数传输

@Data
@AllArgsConstructor
@NoArgsConstructor
public class LoginDTO {private String username;private String password;
}

2）在service包下，定义LoginService接口以及实现类LoginServiceImpl，做登录和登出逻辑

public interface LoginService {Result<String> login(LoginDTO loginDTO);Result<String> logout();
}

@Service
public class LoginServiceImpl implements LoginService {// 注入AuthenticationManagerBuilder，用于获得authenticationManager@Autowiredprivate AuthenticationManagerBuilder authenticationManagerBuilder;@Autowiredprivate RedisTemplate redisTemplate;private static String PRE_KEY = "user:";@Overridepublic Result<String> login(LoginDTO loginDTO) {String username = loginDTO.getUsername();String password = loginDTO.getPassword();UsernamePasswordAuthenticationToken authenticationToken = UsernamePasswordAuthenticationToken.unauthenticated(username, password);try {Authentication authentication = authenticationManagerBuilder.getObject().authenticate(authenticationToken);if(authentication!=null && authentication.isAuthenticated()){SecurityContextHolder.getContext().setAuthentication(authentication);LoginUserDetails user = (LoginUserDetails)authentication.getPrincipal();String subject = PRE_KEY + user.getTUser().getId();String token = JwtUtil.createToken(subject, 1000*60*5L);redisTemplate.opsForValue().set(subject, user, 1000*60*5L, TimeUnit.MILLISECONDS);return Result.success(token);}}catch (AuthenticationException e){return Result.failed(e.getLocalizedMessage());}catch (Exception e){e.printStackTrace();}return Result.failed("认证失败");}@Overridepublic Result<String> logout() {if(SecurityContextHolder.getContext().getAuthentication()!=null){LoginUserDetails user = (LoginUserDetails)SecurityContextHolder.getContext().getAuthentication().getPrincipal();if(user!=null){String key = PRE_KEY + user.getTUser().getId();redisTemplate.delete(key);}else {return Result.failed("登出失败，用户不存在");}}return Result.success("登出成功");}
}

3）在controller包下，新增LoginController ，对外发布登录和登出

@RestController
public class LoginController {@Autowiredprivate LoginService loginService;@PostMapping("/login")public Result<String> login(@RequestBody LoginDTO loginDTO) {return loginService.login(loginDTO);}@PostMapping("/logout")public Result<String> logout() {return loginService.logout();}}

2.6 JWT配置

1）在utils包下面新建JwtUtil工具类，用来生成token和验证token。

这里采用HS256对称加密，密钥我们这里就直接写在代码中，有兴趣朋友可以改为如AES非对称加密算法

/*** JWT工具类*/
public class JwtUtil {//有效期为public static final Long JWT_TTL = 60 * 60 * 1000L; // 60 * 60 *1000  一个小时//设置秘钥明文public static final String JWT_KEY = "moo";public static String getUUID(){return UUID.randomUUID().toString().replaceAll("-", "");}/*** 创建token*/public static String createToken(String subject) {return getJwtBuilder(subject, null, getUUID());// 设置过期时间}/*** 创建token*/public static String createToken(String subject, Long ttlMillis) {return getJwtBuilder(subject, ttlMillis, getUUID());// 设置过期时间}/*** 创建token*/public static String createToken(String id, String subject, Long ttlMillis) {return getJwtBuilder(subject, ttlMillis, id);// 设置过期时间}/*** 解析token*/public static String parseJWT(String token) throws Exception {SecretKey secretKey = generalKey();return Jwts.parser().setSigningKey(secretKey).parseClaimsJws(token).getBody().getSubject();}private static String getJwtBuilder(String subject, Long ttlMillis, String uuid) {SignatureAlgorithm signatureAlgorithm = SignatureAlgorithm.HS256;SecretKey secretKey = generalKey();long nowMillis = System.currentTimeMillis();Date now = new Date(nowMillis);if(ttlMillis==null){ttlMillis=JwtUtil.JWT_TTL;}long expMillis = nowMillis + ttlMillis;Date expDate = new Date(expMillis);return Jwts.builder().setHeaderParam(Header.TYPE, Header.JWT_TYPE).setId(uuid)            //唯一的ID.setSubject(subject)    // 主题  可以是JSON数据.setIssuer("spring-security-study")       // 签发者.setIssuedAt(now)       // 签发时间.signWith(signatureAlgorithm, secretKey)    //使用HS256对称加密算法签名, 第二个参数为秘钥.setExpiration(expDate).compact();}/*** 生成加密后的秘钥 secretKey*/private static SecretKey generalKey() {byte[] encodedKey = Base64.getDecoder().decode(JwtUtil.JWT_KEY);SecretKey key = new SecretKeySpec(encodedKey, 0, encodedKey.length, "AES");return key;}}

2）定义自己的Filter（JwtAuthenticationTokenFilter），通过该Filter进行token验证，并模拟设置SecurityContext。

我们知道访问资源最终在AuthorizationFilter过滤器会验证你的权限，是通过获取SecurityContext得到登录信息
但是使用前后端分离，且不使用Session管理，这就意味着登录之后，第二次请求Security会认为没有登录（这个可以去看看SecurityContextHolderFilter，会发现不再使用HttpSessionSecurityContextRepository）这也就意味着SecurityContext不会被设置
从Security Context原理中我们知道每个请求都是通过Filter过滤链验证，那么只需要我们在链中加入自己的认证，并设置SecurityContext，就能够达到一样的效果。
注意：

这里JwtAuthenticationTokenFilter 继承OncePerRequestFilter 而不是GenericFilterBean，只是为了保证每次请求只走一次JwtAuthenticationTokenFilter
JWT验证失败返回BadCredentialsException异常，这个在自定义异常处理讲过其原理，通过抛出BadCredentialsException可以被exceptionHandling处理

@Component
public class JwtAuthenticationTokenFilter extends OncePerRequestFilter {@Autowiredprivate RedisTemplate redisTemplate;@Overrideprotected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {// 过滤login接口if("/login".equals(request.getRequestURI())){filterChain.doFilter(request, response);return;}// 从请求头获取tokenString token = request.getHeader("access_token");// 检查获取到的token是否为空或空白字符串。(判断给定的字符串是否包含文本)if (!StringUtils.hasText(token)) {// 如果token为空，则直接放行请求到下一个过滤器，不做进一步处理并结束当前方法，不继续执行下面代码。filterChain.doFilter(request, response);return;}// 解析tokenString userAccount;try {userAccount = JwtUtil.parseJWT(token);} catch (Exception e) {e.printStackTrace();throw new BadCredentialsException("token非法");}// 临时缓存中 获取 键 对应 数据Object object = redisTemplate.opsForValue().get(userAccount);LoginUserDetails loginUser = (LoginUserDetails)object;if (Objects.isNull(loginUser)) {throw new BadCredentialsException("用户未登录");}// 将用户信息存入 SecurityConText// UsernamePasswordAuthenticationToken 存储用户名 密码 权限的集合UsernamePasswordAuthenticationToken authenticationToken = new UsernamePasswordAuthenticationToken(loginUser, null, null);// SecurityContextHolder是Spring Security用来存储当前线程安全的认证信息的容器。// 将用户名 密码 权限的集合存入SecurityContextHolderSecurityContextHolder.getContext().setAuthentication(authenticationToken);// 放行filterChain.doFilter(request, response);}
}

2.7 SecurityConfig的配置

1）在config包下，配置SecurityConfig

@Configuration
@EnableWebSecurity
public class SecurityConfig {@Autowiredprivate JwtAuthenticationTokenFilter jwtAuthenticationTokenFilter;@Beanpublic SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {http.authorizeHttpRequests(auth->auth//允许/login访问.requestMatchers("/login").permitAll().anyRequest().authenticated())// 异常处理.exceptionHandling(handling-> handling.accessDeniedHandler(new DemoAccessDeniedHandler()).authenticationEntryPoint(new DemoAuthenticationEntryPoint()))// 禁用csrf，因为登录和登出是post请求，csrf会屏蔽掉post请求.csrf(AbstractHttpConfigurer::disable)// 添加到过滤器链路中，确保在AuthorizationFilter过滤器之前.addFilterBefore(jwtAuthenticationTokenFilter, AuthorizationFilter.class)// 由于采用token方式认证，因此可以关闭session管理.sessionManagement(SessionManagementConfigurer::disable)// 禁用原来登录页面.formLogin(AbstractHttpConfigurer::disable)// 禁用系统原有的登出.logout(LogoutConfigurer::disable);return http.build();}
}