【分布式微服务专题】SpringSecurity快速入门

前言

阅读对象

阅读导航

系列上一篇文章：《》

前置知识

笔记正文

一、Spring Security介绍

1.1 什么是Spring Security

官方介绍：Spring Security 是一个功能强大且高度可定制的身份验证和访问控制框架。它是用于保护基于 Spring 的应用程序。
Spring Security 是一个框架，侧重于为 Java 应用程序提供身份验证和授权。与所有 Spring 项目一样，Spring 安全性的真正强大之处，在于它很容易扩展以满足定制需求

Spring Security是一个能够为基于Spring的企业应用系统提供声明式的安全访问控制解决方案的安全框架。它提供了一组可以在Spring应用上下文中配置的Bean，充分利用了Spring IoC、DI和AOP功能，类别是安全服务体系。

Spring Security对Web安全性的支持大量地依赖于Servlet过滤器。它可以提供应用程序层的安全解决方案，一个系统的安全还需要考虑传输层和系统层的安全，例如采用Htps协议、服务器部署防火墙等。

此外，Spring Security采用【安全层】的概念，使每一层都尽可能安全，连续的安全层可以达到全面的防护。在Controller层、Service层、DAO层等以加注解的方式来保护应用程序的安全。

1.2 它是干什么的

Spring Security 主要干的就两件事：

1. Authentication：认证（who are you）。用户认证就是判断一个用户的身份是否合法的过程，用户去访问系统资源时系统要求验证用户的身份信息，身份合法方可继续访问，不合法则拒绝访问。常见的用户身份认证方式有：用户名密码登录，二维码登录，手机短信登录，指纹认证等方式
2. Access Control：访问控制（what are you allowed to do）。授权是用户认证通过后，根据用户的权限来控制用户访问资源的过程，拥有资源的访问权限则正常访问，没有权限则拒绝访问

SpringSecurity在架构上将认证与授权分离，并提供了扩展点。

1.3 Spring Security和Shiro比较

在 Java 生态中，目前有 Spring Security 和 Apache Shiro 两个安全框架，可以完成认证和授权的功能。

Shiro：一个功能强大且易于使用的Java安全框架，提供了认证、授权、加密和会话管理

所以，网上有人说，对于常见的安全管理技术栈的组合是：

• SSM + Shiro
• Spring Boot/Spring Cloud +Spring Security

二、快速开始

接下来我们开始使用以下SpringSecutiry，在项目要开始之前，我们需要做一些项目准备。

1）快速新建一个SpringBoot项目
建议直接使用idea的Spring Initializer云上构建一个

2）添加pom依赖

        <!-- 接入spring security-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-security</artifactId>
        </dependency>

        <!-- web配置-->
        <dependency>
            <groupId>org.springframework.boot</groupId>
            <artifactId>spring-boot-starter-web</artifactId>
        </dependency>

3）添加测试接口

    @GetMapping("/user/admin")
    public User admin() {
        User user = new User();
        user.setUserId(1);
        user.setName("admin");
        user.setPhone("10086");
        return user;
    }

4）启动项目，开始测试
引入Spring Security之后 ，访问任何API 接口时，需要首先进行登录，才能进行访问。如下所示：

默认用户名：user，密码可以查看控制台日志获取

输入账号密码之后，访问就正常了

5）退出
Spring security默认实现了logout退出，用户只需要向 Spring Security 项目中发送/logout请求即可

OK，准备工作做完之后，接下来开始进入正题。

2.1 用户认证

2.1.1 设置用户名

2.1.1.1 基于application.yml配置文件

配置内容如下：

spring:
  # Spring Security 配置项，对应 SecurityProperties 配置类
  security:
    user:
      name: user
      password: 123456
      roles:
        - admin

这个方式很容易理解，毕竟，我们在前面提到过了，SpringSecurity会有一个默认的用户。然而我们又没有在数据库里面记录它，所以，它肯定是存在于内存中。所以，SpringSecurity提供了这么一种机制给我们去修改它的默认账号密码。

2.1.1.2 基于Java Config配置方式

代码如下：

@Configuration
@EnableWebSecurity
public class SecurityConfig {
    
    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.builder()
                .username("shen")
                .password("{noop}123456")
                .roles("user")
                .build();

        UserDetails admin = User.builder()
                .username("admin")
                .password("{noop}123456")
                .roles("admin", "user")
                .build();

        return new InMemoryUserDetailsManager(user, admin);
    }
}

注意，上面的密码password("{noop}123456")中的{noop}是表示不需要加密，明文注册到内存中。至于加密，我会在后面提到。若没有上面这个配置，测试的时候会报错：There is no PasswordEncoder mapped for the id "null"

2.1.2 设置加密方式

2.1.2.1 {id}encodedPassword

这种方式是SpringSecurity提供的一种比较普适性的格式。整体分为两个部分：

• {id}：设置的时候必须在{}花括号内。id为加密方式。可选的值如下图所示。大家只要记得{noop}是明文方式就好，其他代表的是不同的加密策略

具体见：org.springframework.security.crypto.factory.PasswordEncoderFactories

• encodePassword：原始密码

简单的使用示例就是我在上个案例写到的，不过在这里我们修改一下shen用户的密码，采用{sha256}加密方式，明文为password：

public class SecurityConfig {

    @Bean
    public UserDetailsService userDetailsService() {
        UserDetails user = User.builder()
                .username("shen")
                .password("{sha256}97cde38028ad898ebc02e690819fa220e88c62e0699403e94fff291cfffaf8410849f27605abcbc0")
                .roles("user")
                .build();

        UserDetails admin = User.builder()
                .username("admin")
                .password("{noop}123456")
                .roles("admin", "user")
                .build();

        return new InMemoryUserDetailsManager(user, admin);
    }
}

2.1.2.2 使用PasswordEncoder加密

这个使用起来就更简单了，就是先注册声明一个Bean到Spring里面就好，比如使用bcrypt，通过上图PasswordEncoderFactories可以看见，需要注册的Bean如下：

    @Bean
    public PasswordEncoder passwordEncoder() {
        return new BCryptPasswordEncoder();
    }

2.1.3 自定义用户信息加载

在我们的开发中，通常是需要自定义的方式从数据库获取用户信息的。这种情况下，我们可以自行实现UserDetailsService接口：

@Service
public class ShenUserService implements UserDetailsService {

    @Resource
    private UserService userService;

    @Resource
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        User byId = userService.getOne(new LambdaQueryWrapper<User>().eq(User::getName, username));
        return org.springframework.security.core.userdetails.User
                .builder()
                .username(byId.getName())
                .password(passwordEncoder.encode("123456"))
                .roles("user")
                .build();
    }
}

2.1.4 自定义登录页面

Spring Security虽然给我们提供了默认登录页面，但通常我们都会自定义自己的登录页面，在项目中，我们想要自定义登录页面，只需要简单的两步：

1）编写登录页面
在resources目录下新建static目录，然后在下面新增login.html文件，内容如下：

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <title>Title</title>
</head>
<body>
    <form action="/user/login" method="post">
        用户名:<input type="text" name="username"/><br/>
        密码：<input type="password" name="password"/><br/>
        <input type="submit" value="提交"/>
    </form>
</body>
</html>

2）配置Spring Security的过滤器链SecurityFilterChain

    @Bean
    public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {
        http.authorizeHttpRequests((authorizeHttpRequests) -> authorizeHttpRequests
                        .requestMatchers(new RequestMatcher() {
                            @Override
                            public boolean matches(HttpServletRequest request) {
                                String requestURI = request.getRequestURI();
                                return "/login.html".equals(requestURI);
                            }
                        }).permitAll() // loginPage 页面不需要身份认证 否则会无限重定向
                        .anyRequest().authenticated() // 其他请求都需要用户认证后访问
                )
                .formLogin((formLogin) -> formLogin
                        .loginPage("/login.html") // 自定义登录页面路径
                        .usernameParameter("username") // 定义从Form中获取用户名的key 与html中的form参数匹配
                        .passwordParameter("password") // 定义从Form中获取密码的key 与html中的form参数匹配
                        .loginProcessingUrl("/user/login") // 认证发起的URL，访问该URL则认证凭证 这样要与HTML中form的提交地址一致
                        .defaultSuccessUrl("/user/admin") // 认证成功之后跳转的路径
                )
                // 禁用httpBasic
                .httpBasic((httpBasic) -> httpBasic.disable())
                // 关闭跨站点请求伪造csrf防护
                .csrf((csrf) -> csrf.disable());
        return http.build();
    }

测试一下，你就会发现跳转到了自定义的界面

2.1.5 前后端分离认证

表单登录配置模块提供了successHandler（）和failureHandler（）两个方法，分别处理登录成功和登录失败的逻辑。携带当前登录用户名及其角色等信息；而failureHandler()方法携带一个AuthenticationException异常参数。

1）新增登录成功处理

    /**
     * 认证成功处理逻辑
     */
    public class LoginSuccessHandler implements AuthenticationSuccessHandler {
        @Override
        public void onAuthenticationSuccess(HttpServletRequest request, HttpServletResponse response, Authentication authentication) throws IOException, ServletException {
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("登录成功");
        }
    }

2）新增登录失败处理

    /**
     * 认证失败处理逻辑
     */
    public class LoginFailureHandler implements AuthenticationFailureHandler {

        @Override
        public void onAuthenticationFailure(HttpServletRequest request, HttpServletResponse response, AuthenticationException exception) throws IOException, ServletException {
            // TODO
            response.setContentType("text/html;charset=utf-8");
            response.getWriter().write("登录失败");
            exception.printStackTrace();
        }
    }

3）设置处理逻辑
修改上一步提到的过滤器链SecurityFilterChain代码，如下：

 .formLogin((formLogin) -> formLogin
                        .loginPage("/login.html") // 自定义登录页面路径
                        .usernameParameter("username") // 定义从Form中获取用户名的key 与html中的form参数匹配
                        .passwordParameter("password") // 定义从Form中获取密码的key 与html中的form参数匹配
                        .loginProcessingUrl("/user/login") // 认证发起的URL，访问该URL则认证凭证 这样要与HTML中form的提交地址一致
                        .defaultSuccessUrl("/user/admin") // 认证成功之后跳转的路径
                        .successHandler(new LoginSuccessHandler()) // 登录成功处理逻辑
                        .failureHandler(new LoginFailureHandler()) // 登录失败处理逻辑

2.1.6 用户认证流程总结

网上找的一个流程图，我跟着走了一遍，大概是这样的，只不过有些类需要自己走一下，确定一下

2.2 访问控制

授权的方式包括 web授权和方法授权，web授权是通过url拦截进行授权，方法授权是通过方法拦截进行授权。

2.2.1 web授权： 基于url的访问控制

Spring Security可以通过http.authorizeRequests()对web请求进行授权保护 ，Spring Security使用标准Filter建立了对web请求的拦截，最终实现对资源的授权访问。配置顺序会影响之后授权的效果，越是具体的应该放在前面，越是笼统的应该放到后面。
代码示例如下：

 @Bean
 public SecurityFilterChain defaultSecurityFilterChain(HttpSecurity http) throws Exception {

     // 其余配置
     http.formLogin((formLogin) -> formLogin
                     .loginPage("/login.html") // 自定义登录页面路径
                     .usernameParameter("username") // 定义从Form中获取用户名的key 与html中的form参数匹配
                     .passwordParameter("password") // 定义从Form中获取密码的key 与html中的form参数匹配
                     .loginProcessingUrl("/user/login") // 认证发起的URL，访问该URL则认证凭证 这样要与HTML中form的提交地址一致
                     .defaultSuccessUrl("/user/admin") // 认证成功之后跳转的路径
                     .successHandler(new LoginSuccessHandler()) // 登录成功处理逻辑
                     .failureHandler(new LoginFailureHandler()) // 登录失败处理逻辑
             )
             // 禁用httpBasic
             .httpBasic(AbstractHttpConfigurer::disable)
             // 关闭跨站点请求伪造csrf防护
             .csrf(AbstractHttpConfigurer::disable);

     // 对请求进行访问控制
     doSetAccessControl(http);

     return http.build();
 }
    
 private void doSetAccessControl(HttpSecurity http) throws Exception {

        // 设置可以直接访问的资源
        http.authorizeHttpRequests((permitAll) -> permitAll.antMatchers(ignoreUrls).permitAll());

        // 设置admin特有资源，只有admin可以访问
        http.authorizeHttpRequests((adminApi) -> adminApi.antMatchers("/sys/**").hasRole("admin"));

        // 设置wallet接口访问权限
        http.authorizeHttpRequests((walletApi) -> walletApi.antMatchers("/wallet/**").hasAuthority("wallet:api"));

        // 其他请求都需要用户认证后访问
        http.authorizeHttpRequests((others) -> others.anyRequest().authenticated());
    }

为了方便测试，我写了一个简单的Controller，然后新增了一些限制API：

@RestController
public class TestController {

    @GetMapping("/test/get")
    public String test() {
        return "获取一个test资源";
    }

    @GetMapping("/sys/get")
    public String sysTest() {
        return "获取一个sys资源";
    }

    @GetMapping("/order/get")
    public String orderTest() {
        return "获取一个order资源";
    }
}

并且，固定我的登录用户只有user:api的权限：

 **/
@Service
public class ShenUserService implements UserDetailsService {

    @Resource
    private UserService userService;

    @Resource
    private PasswordEncoder passwordEncoder;

    @Override
    public UserDetails loadUserByUsername(String username) throws UsernameNotFoundException {

        User byId = userService.getOne(new LambdaQueryWrapper<User>().eq(User::getName, username));
        return org.springframework.security.core.userdetails.User
                .builder()
                .username(byId.getName())
                .password(passwordEncoder.encode("123456"))
                .authorities("user:api")
                .build();
    }
}

2.2.2 方法授权：基于注解的访问控制

Spring Security在方法的权限控制上支持三种类型的注解，JSR-250注解、@Secured注解和支持表达式的注解。这三种注解默认都是没有启用的，需要通过@EnableGlobalMethodSecurity来进行启用。
另外，Spring Security中定义了四个支持使用表达式的注解，分别是@PreAuthorize、@PostAuthorize、@PreFilter和@PostFilter。其中前两者可以用来在方法调用前或者调用后进行权限检查，后两者可以用来对集合类型的参数或者返回值进行过滤。
示例代码如下：

/**
 * @author zhangshen
 * @date 2023/12/29 17:16
 * @slogan 编码即学习，注释断语义
 **/
@RestController
public class TestController {

    @PreAuthorize("hasRole('ROLE_order')")
    @GetMapping("/test/get")
    public String test() {
        return "获取一个test资源";
    }

    @Secured("ROLE_admin")
    @GetMapping("/sys/get")
    public String sysTest() {
        return "获取一个sys资源";
    }

    @Secured("ROLE_order")
    @GetMapping("/order/get")
    public String orderTest() {
        return "获取一个order资源";
    }
}

三、Spring Security整合JWT实现自定义登录认证

3.1 自定义登录认证业务流程

一个简单易用的登录认证授权，可以使用Spring Security + JWT实现。在这个框架下，认证授权流程通常如下：

1. 用户调用登录接口获取token
2. 服务端收到登录请求，校验账号密码
3. 校验通过，服务端使用JWT生成token，并返回给用户
4. 往后前端每次请求都带上token（在请求头上添加Authorization: Bearer Token）
5. 服务端每次收到请求都校验token的合法性
6. 校验通过，进行业务逻辑，返回业务结果

大概的UML活动图如下：

3.2 JWT介绍

官方传送门：《JWT介绍》

3.2.1 什么是JWT

JWT即JSON Web Token，它是一个开放的行业标准（RFC 7519），它定义了一种简介的、自包含的【协议格式】，用于在通信双方【传递json对象】，传递的信息经过数字签名可以被验证和信任。JWT可以使用HMAC算法或使用RSA的公钥/私钥对来签名，防止被篡改。

关键词：【协议格式】、【JSON对象】

它具有如下优点：
JWT令牌的优点：

1. jwt基于json，非常方便解析
2. 可以在令牌中自定义丰富的内容，易扩展
3. 通过非对称加密算法及数字签名技术，JWT防止篡改，安全性高
4. 源服务使用JWT可不依赖授权服务即可完成授权

缺点：

1. JWT令牌较长，占存储空间比较大。
2. 安全性取决于密钥管理。JWT 的安全性取决于密钥的管理。如果密钥被泄露或者被不当管理，那么 JWT 将会受到攻击。因此，在使用 JWT 时，一定要注意密钥的管理，包括生成、存储、更新、分发等等
3. 无法撤销。由于 JWT 是无状态的，一旦 JWT 被签发，就无法撤销。如果用户在使用 JWT 认证期间被注销或禁用，那么服务端就无法阻止该用户继续使用之前签发的 JWT。因此，开发人员需要设计额外的机制来撤销 JWT，例如使用黑名单或者设置短期有效期等等。

使用 JWT 主要用来做下面两点：

• 认证(Authorization)：这是使用 JWT 最常见的一种情况，一旦用户登录，后面每个请求都会包含 JWT，从而允许用户访问该令牌所允许的路由、服务和资源。单点登录是当今广泛使用 JWT 的一项功能，因为它的开销很小。
• 信息交换(Information Exchange)：JWT 是能够安全传输信息的一种方式。通过使用公钥/私钥对 JWT 进行签名认证。此外，由于签名是使用 head 和 payload 计算的，因此你还可以验证内容是否遭到篡改。

3.3 JWT结构

一个JWT实际上就是一个由.分隔成三部分的字符串（有点拗口）。这三部分其实就是：头部（header）、载荷（payload）与签名（signature）。
简洁形式的JWT字符串格式就像这样：xxxxxx.yyyyyy.zzzzzz。具体如下图所示：

3.3.1 JWT头部header

头部用于描述关于该JWT的最基本的信息，通常包含两部分：

• 类型：在这里即JWT
• 签名所用的算法：（如HMACSHA256或RSA）等。

例如：

{
  "alg": "HS256",
  "typ": "JWT"
}

然后将头部进行base64加密（该加密是可以对称解密的)，构成了第一部分：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9

3.3.2 JWT载荷payload

第二部分是载荷，就是存放有效信息的地方。这个名字像是特指飞机上承载的货品，这些有效信息包含三个部分：

• 标准中注册的声明。这些是一组预定义的声明，它们不是强制性的，但推荐使用，以提供一组有用的、可互操作的声明。其中包括:iss(发行者)、exp(过期时间)、sub(主题)、aud(受众)等
• 公共的声明。公共的声明可以添加任何的信息，一般添加用户的相关信息或其他业务需要的必要信息，但不建议添加敏感信息，因为该部分在客户端可解密
• 私有的声明。私有声明是提供者和消费者所共同定义的声明，一般不建议存放敏感信息，因为base64是对称解密的，意味着该部分信息可以归类为明文信息

一个简单的示例：

{
  "sub": "1234567890",
  "name": "John Doe",
  "admin": true
}

然后将其进行base64加密，得到JWT的第二部分：

ewogICJzdWIiOiAiMTIzNDU2Nzg5MCIsCiAgIm5hbWUiOiAiSm9obiBEb2UiLAogICJhZG1pbiI6IHRydWUKfQ==

3.3.3 JWT签名signature

JWT的第三部分是一个签证信息，这个签证信息由三部分组成：

• header (base64后的)
• payload (base64后的)
• secret(盐，一定要保密）

这个部分需要base64加密后的header和base64加密后的payload使用.连接组成的字符串，然后通过header中声明的加密方式进行加盐secret组合加密，然后就构成了JWT的第三部分：

// base64Header + base64Payload 
String encodedString = base64UrlEncode(header) + '.' + base64UrlEncode(payload);

// 以zhangshen作【盐】值，对上面的字符串做HS256加密
String signature = HMACSHA256(encodedString, 'zhangshen'); // khA7TNYc7_0iELcDyTc7gHBZ_xfIcgbfpzUNWwQtzME

3.3.4 组合在一起

将上面三部生成的三部分组成在一起，就构成了一个完整的JWT了：

eyJ0eXAiOiJKV1QiLCJhbGciOiJIUzI1NiJ9.ewogICJzdWIiOiAiMTIzNDU2Nzg5MCIsCiAgIm5hbWUiOiAiSm9obiBEb2UiLAogICJhZG1pbiI6IHRydWUKfQ==.80398fd80672f162495e294c86debfaa9fac06788aa49810c7883451311d9b6d

注意：secret是保存在服务器端的，jwt的签发生成也是在服务器端的，secret就是用来进行jwt的签发和jwt的验证，所以，它就是你服务端的私钥，在任何场景都不应该流露出去。一旦客户端得知这个secret, 那就意味着客户端是可以自我签发jwt了。

3.3.5 如何使用

一般是在请求头里加入Authorization，并加上Bearer标注：

fetch('api/user/1', {
  headers: {
    'Authorization': 'Bearer ' + token
  }
})

3.4 代码实现自定义登录

现在我们来改造实现一下，自定义的JWT登录。需要以下4步：

步骤一：新增JWT工具类

package com.shen.jwt;

import cn.hutool.core.date.DateUtil;
import cn.hutool.json.JSONObject;
import cn.hutool.jwt.JWT;
import cn.hutool.jwt.signers.JWTSignerUtil;

import java.util.Map;

/**
 * @author zhanghuitong
 * @date 2024/1/1 18:13
 * @slogan 编码即学习，注释断语义
 **/
public class JwtUtil {
    private static final String SALT = "zhangshen";
    public static final Integer EXPIRE = 30;

    /**
     * 获取默认过期时间的jwt签名器
     */
    public static JWT getJwt() {
        return getJwt(EXPIRE);
    }

    /**
     * 获取自定义过期时间的jwt签名器
     */
    public static JWT getJwt(Integer expire) {
        return getJWT().setExpiresAt(DateUtil.offsetMinute(DateUtil.date(), expire));
    }

    /**
     * 生成jwt签名器
     *
     * @return
     */
    private static JWT getJWT() {
        return JWT.create().setSigner(JWTSignerUtil.hs256(SALT.getBytes()));
    }

    /**
     * 根据token生成jwt
     *
     * @param token
     * @return
     */
    public static JWT parse(String token) {
        return getJWT().parse(token);
    }

    /**
     * 解析token
     */
    public static JSONObject parseToken(String token) {
        return parse(token).getPayloads();
    }

 /**
     * 生成token
     *
     * @param claims payload声明
     */
    public static String token(Map<String, Object> claims) {
        return getJwt().addPayloads(claims).sign();
    }
}

上面比较重要的方法是，生成JWT以及token的方法

2）实现校验JWT token的过滤器

package com.shen.jwt;

import cn.hutool.core.util.StrUtil;
import cn.hutool.json.JSONObject;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.http.HttpHeaders;
import org.springframework.security.authentication.UsernamePasswordAuthenticationToken;
import org.springframework.security.core.Authentication;
import org.springframework.security.core.context.SecurityContextHolder;
import org.springframework.security.core.userdetails.UserDetails;
import org.springframework.security.core.userdetails.UserDetailsService;
import org.springframework.security.web.authentication.WebAuthenticationDetailsSource;
import org.springframework.stereotype.Component;
import org.springframework.web.filter.OncePerRequestFilter;

import javax.servlet.FilterChain;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;
import java.util.Date;

/**
 * @author zhanghuitong
 * @date 2024/1/1 17:58
 * @slogan 编码即学习，注释断语义
 **/
@Component
public class JwtAuthticationTokenFilter extends OncePerRequestFilter {

    @Autowired
    private UserDetailsService userDetailsService;

    @Override
    protected void doFilterInternal(HttpServletRequest request, HttpServletResponse response, FilterChain filterChain) throws ServletException, IOException {

        // 1. 从请求头获取token
        String token = request.getHeader(HttpHeaders.AUTHORIZATION);
        if (StrUtil.isEmpty(token)) {
            filterChain.doFilter(request, response);
            return;
        }

        // 2. 校验token
        String realToken = token.substring("bearer".length());
        JSONObject tokenObject = JwtUtil.parseToken(realToken);
        Date expireIn = tokenObject.getDate("expireIn");
        if (expireIn.before(new Date())) {

            // token 已经过期
            SecurityContextHolder.getContext().setAuthentication(null);
            filterChain.doFilter(request, response);
            return;
        }

        String username = tokenObject.getStr("username");
        Authentication authentication1 = SecurityContextHolder.getContext().getAuthentication();
        if (StrUtil.isNotEmpty(username) && authentication1 == null) {

            // 获取用户信息
            UserDetails userDetails = userDetailsService.loadUserByUsername(username);
            if (userDetails != null && userDetails.isEnabled()) {
                UsernamePasswordAuthenticationToken authentication = new UsernamePasswordAuthenticationToken(userDetails, null, userDetails.getAuthorities());
                authentication.setDetails(new WebAuthenticationDetailsSource().buildDetails(request));

                // 设置用户登录状态
                SecurityContextHolder.getContext().setAuthentication(authentication);
            }
        }
        filterChain.doFilter(request, response);
    }
}

3）添加自定义JWT过滤器，并添加到账号密码校验过滤器之前

  // 添加JWT过滤器，登录的时候校验token
        JwtAuthticationTokenFilter jwtAuthticationTokenFilter = SpringUtil.getBean(JwtAuthticationTokenFilter.class);
        http.addFilterBefore(jwtAuthticationTokenFilter, UsernamePasswordAuthenticationFilter.class);

4）最后我们来测试一下

3.5 JWT续期问题

JWT（JSON Web Token）通常是在用户登录后签发的，用于验证用户身份和授权。JWT 的有效期限（或称“过期时间”）通常是一段时间（例如1小时），过期后用户需要重新登录以获取新的JWT。然而，在某些情况下，用户可能会在JWT到期之前使用应用程序，这可能会导致应用程序不可用或需要用户重新登录。为了避免这种情况，通常有两种解决方案来处理JWT续期问题：

3.5.1 刷新令牌（Refresh Token）

刷新令牌是一种机制，它允许应用程序获取一个新的JWT，而无需用户进行身份验证。当JWT过期时，应用程序使用刷新令牌向身份验证服务器请求一个新的JWT，而无需提示用户输入其凭据。这样，用户可以继续使用应用程序，而不必重新登录。
以下是一个Java伪代码，演示如何使用Refresh Token来更新JWT

public String refreshAccessToken(String refreshToken) {
 
    // 刷新token校验。检查签名，过期时间等
    boolean isValid = validateRefreshToken(refreshToken);
 
    if (isValid) {
        // 检索与刷新令牌关联的用户信息(例如用户ID)
        String userId = getUserIdFromRefreshToken(refreshToken);
 
        // 重新生成一个新的token
        String newToken= generateToken(userId);
 
        return newAccessToken;
    } else {
        throw new RuntimeException("Invalid refresh token.");
    }
}

在这个示例中，refreshAccessToken方法接收一个刷新令牌作为参数，并使用validateRefreshToken方法验证该令牌是否有效。如果令牌有效，方法将使用getUserIdFromRefreshToken方法获取与令牌关联的用户信息，然后使用generateToken方法生成一个新的JWT访问令牌，并将其返回。如果令牌无效，则抛出异常。

3.5.2 自动延长JWT有效期

在某些情况下，JWT可以自动延长其有效期。例如，当用户在JWT过期前继续使用应用程序时，应用重新设置token过期时间。
要自动延长JWT有效期，您可以在每次请求时检查JWT的过期时间，并在必要时更新JWT的过期时间。以下是一个示例Java代码，演示如何自动延长JWT有效期：

public String getAccessToken(HttpServletRequest request) {
 
    String accessToken = extractAccessTokenFromRequest(request);
 
    if (isAccessTokenExpired(accessToken)) {
        String userId = extractUserIdFromAccessToken(accessToken);
        accessToken = generateNewAccessToken(userId);
    } else if (shouldRefreshAccessToken(accessToken)) {
        String userId = extractUserIdFromAccessToken(accessToken);
        accessToken = generateNewAccessToken(userId);
    }
 
    return accessToken;
}
 
private boolean isAccessTokenExpired(String accessToken) {
    // extract expiration time from the access token
    Date expirationTime = extractExpirationTimeFromAccessToken(accessToken);
 
    // check if the expiration time is in the past
    return expirationTime.before(new Date());
}
 
private boolean shouldRefreshAccessToken(String accessToken) {
    // extract expiration time and current time
    Date expirationTime = extractExpirationTimeFromAccessToken(accessToken);
    Date currentTime = new Date();
 
    // calculate the remaining time until expiration
    long remainingTime = expirationTime.getTime() - currentTime.getTime();
 
    // refresh the token if it expires within the next 5 minutes
    return remainingTime < 5 * 60 * 1000;
}
 
private String generateNewAccessToken(String userId) {
    // generate a new access token with a new expiration time
    Date expirationTime = new Date(System.currentTimeMillis() + ACCESS_TOKEN_EXPIRATION_TIME);
    String accessToken = generateAccessToken(userId, expirationTime);
 
    return accessToken;
}

在这个示例中，getAccessToken方法接收HttpServletRequest对象作为参数，并使用extractAccessTokenFromRequest方法从请求中提取JWT访问令牌。然后，它使用isAccessTokenExpired方法检查JWT的过期时间是否已过期。如果过期，它使用extractUserIdFromAccessToken方法从JWT中提取用户ID，并使用generateNewAccessToken方法生成一个新的JWT访问令牌。如果JWT尚未过期，但即将到期，则使用shouldRefreshAccessToken方法检查JWT是否需要更新。如果是这样，它使用相同的流程生成一个新的JWT访问令牌。

学习总结

1. 学习并且了解了什么是JWT
2. 学会了JWT基本使用及常见问题的解决思路

感谢

感谢官方文章《JWT介绍》

代码007普通

打赏 收藏 海报 链接