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

发布时间:2024年01月01日

前言

阅读对象

阅读导航

系列上一篇文章:《

前置知识

笔记正文

一、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安全框架,提供了认证、授权、加密和会话管理

相同点不同点(以SpringSecurity出发)
SpringSecutiry认证功能
授权功能
加密功能
会话管理
缓存支持
rememberMe功能
优点:
1. SpringSecurity以Spring为基础,与Spring生态融合有天然的优势
2. SpringSecurity功能更加丰富些,例如安全防护
3. SpringSecurity社区资源比Shiro丰富

缺点:
1. SpringSecurity使用相对复杂,上手难度大
2. SpringSecurity依赖于Spring容器
Shiro

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

  • 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介绍

文章来源:https://blog.csdn.net/qq_32681589/article/details/135280088
本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。