Skip to content
TheChatArchiveThe Chat Archive
gpt-4o-2024-11-20· OpenAIAi2 WildChat-4.8M (AI2)

springboot3.3.3…

  1. User

    springboot3.3.3 的gateway作为资源服务器集成keycloak,vue3前端也通过oidc-client-ts集成keycloak,现在前端登录成功了,我希望前端访问到gateway时,gateway经过keycloak校验后把用户信息存入session,以便下游服务使用用户信息,因为我用了spring-session-data-redis,或者有没有更好的提议可以实现下游服务获取用户信息

  2. Assistant

    你当前的需求是通过 Spring Gateway 与 Keycloak 集成,同时把用户信息存储在 Redis 中的 session,以供下游服务使用。以下是实现这种架构的一种建议和详细步骤:


    架构设计规划

    1. Keycloak 角色

      • Keycloak 提供 OpenID Connect (OIDC) 登录和 Token 校验功能。
      • 用户登录后由前端 (Vue 3 + oidc-client-ts) 获取 access_token 和 id_token。
    2. Spring Gateway

      • 作为资源服务器,验证前端发过来的 access_token 和解码 id_token。
      • 提取用户信息并存储到 Redis session(支持 Spring Session Data Redis)。
    3. 下游服务

      • 从 Redis session 或请求头中获取用户信息。
    4. 总体工作流程

      • 前端登录成功后用 OIDC 的 access_token 访问网关。
      • 网关解码并验证 JWT Token(通过 Keycloak Public Key 或 .well-known/openid-configuration)。
      • 网关将用户信息(如 用户名、角色 等)存入 Redis session,并将部分信息透传给下游微服务。

    具体实现步骤

    1. 配置 Spring Gateway 作为资源服务器

    Spring Gateway 需要配置为资源服务器,以验证 Keycloak 签发的 JWT token:

    # application.yml
    spring:
      security:
        oauth2:
          resourceserver:
            jwt:
              issuer-uri: "http://<keycloak-host>/realms/<realm-name>"  # Keycloak Realm 的路径
    
    • issuer-uri 会自动获取 Keycloak 的 .well-known/openid-configuration 来装载公钥和解析 token。

    完整配置参考 Keycloak 的 OpenID Connect 文档。


    2. 自定义 GatewayFilter 提取用户信息

    当请求通过网关时可以将 JWT 中的用户信息如 sub(用户ID)、用户名、角色等存储到 Redis 中。

    import org.springframework.cloud.gateway.filter.GatewayFilter;
    import org.springframework.cloud.gateway.filter.factory.AbstractGatewayFilterFactory;
    import org.springframework.http.HttpHeaders;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationToken;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    
    @Component
    public class JwtToSessionFilter extends AbstractGatewayFilterFactory<Object> {
    
        @Override
        public GatewayFilter apply(Object config) {
            return (exchange, chain) -> {
                // 获取认证信息
                if (exchange.getPrincipal().map(principal -> principal instanceof JwtAuthenticationToken).block()) {
                    JwtAuthenticationToken authentication = (JwtAuthenticationToken) exchange.getPrincipal().block();
                    Jwt jwt = authentication.getToken();
    
                    // 提取登录用户信息
                    String username = jwt.getClaimAsString("preferred_username"); // Keycloak Token 设置的字段
                    String email = jwt.getClaimAsString("email");
                    String roles = jwt.getClaimAsString("roles");
    
                    // 存储到 session 或请求属性
                    exchange.getAttributes().put("USER_NAME", username);
                    exchange.getAttributes().put("USER_EMAIL", email);
                    exchange.getAttributes().put("USER_ROLES", roles);
    
                    // 也可以存储到 Redis Session
                    // 使用 exchange.getSession() 获取 Reactive Session 存储数据
                    return exchange.getSession().doOnNext(session -> {
                        session.getAttributes().put("USER_NAME", username);
                        session.getAttributes().put("USER_EMAIL", email);
                        session.getAttributes().put("USER_ROLES", roles);
                    }).then(chain.filter(exchange));
                }
    
                return chain.filter(exchange);
            };
        }
    }
    
    • 通过 JwtAuthenticationToken 解码 JWT。
    • 提取 preferred_username、roles 等信息。
    • 使用 exchange.getSession() 写入 Spring Session 支持的 Redis。

    然后将自定义的 JwtToSessionFilter 添加到 Gateway Filter Chain 中。


    3. 搭配 Spring Session Data Redis

    启用 Spring Session Data Redis 存储网关的 Session:

    spring:
      session:
        store-type: redis
      redis:
        host: <your-redis-host>
        port: <your-redis-port>
    

    引入依赖:

    <dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
    </dependency>
    

    配置完成后,exchange.getSession() 的数据会自动存储到 Redis 中。


    4. 让下游服务获取用户信息

    网关可以直接将用户信息传递给下游服务(通过请求头)。

    import org.springframework.cloud.gateway.filter.GatewayFilter;
    import org.springframework.stereotype.Component;
    import org.springframework.web.server.ServerWebExchange;
    
    @Component
    public class UserToRequestHeaderFilter implements GatewayFilter {
        @Override
        public GatewayFilter apply(GatewayFilterChain chain) {
            return (exchange, chain) -> {
                // 从 Session 或 Attributes 中提取用户信息
                String username = exchange.getSession().map(session -> session.getAttribute("USER_NAME")).block();
                String roles = exchange.getSession().map(session -> session.getAttribute("USER_ROLES")).block();
    
                // 设置到请求头供下游服务使用
                ServerWebExchange mutatedExchange = exchange.mutate()
                    .request(r -> r.headers(h -> h.add("X-USER-NAME", username).add("X-USER-ROLES", roles)))
                    .build();
    
                return chain.filter(mutatedExchange);
            };
        }
    }
    
    • 用户信息通过请求头(如 X-USER-NAME)传递给下游服务。
    • 配置为 Gateway 全局过滤器。

    除此之外,服务也可以直接从 Redis 中读取用户信息。


    5. 前端逻辑

    前端登录后通过 oidc-client-ts 处理完成后,将 access_token 附带在请求头中发给网关:

    axios.get('/api/data', {
      headers: {
        Authorization: `Bearer ${accessToken}`
      }
    });
    

    确保 access_token 是正确签发的,网关会自动完成解析和用户信息提取。


    其他建议

    如果需求中需要频繁访问用户信息,可以考虑以下几个方式:

    1. 用户 Token 缓存:
      • 网关与 Redis 一起缓存 Token 解析后的结果,以便提高性能。
    2. 通过授权中心透传:
      • 考虑将下游服务直接注册到 Keycloak,同时下游服务通过 JWT 自行验证。
    3. 全局用户上下文服务:
      • 构建一套用户-Session 微服务,集中管理登录与用户上下文,所有服务通过它获取用户数据。

    总结

    使用 Spring Gateway + Keycloak 可以轻松完成用户信息的管理。上述方案通过 Redis session 和请求头传递的方式,可满足现有需求。如果你有严格性能或一致性要求,可以考虑更高效的用户上下文服务模块。

  3. User

    下游服务直接注册到 Keycloak 是不是影响性能

  4. Assistant

    "下游服务是否直接注册到 Keycloak" 会产生一些性能上的影响,但影响是否显著,具体需要看方案的实现方式和业务场景的性能需求。以下是详细的分析:


    直接注册到 Keycloak 的场景概述

    当下游服务直接注册到 Keycloak时,下游服务会在每次收到客户端发送的请求时,从请求头解析 access_token,然后通过 Keycloak 的公钥校验JWT Token的签名,并解析 JWT 中的用户信息,而无需依赖上游的网关传递额外的用户信息。


    性能影响分析

    1. 解码和校验 JWT 本身的资源消耗

      • 解码和校验 JWT Token 的过程是很轻量的操作,通常只需要完成解密签名(对于 RSA、HS256 签名)。Spring Security 自带的 JWT 支持(JwtDecoder)底层使用了缓存策略来下载 Keycloak 的公钥信息,这些资源开销可以被控制在非常低的范围。
      • 对于大流量系统或性能要求高的系统,可以使用 KeysCache 来缓存 Keycloak 的公钥信息,从而避免反复向 Keycloak 拉取密钥配置。

      结论:Token 验证开销通常可以忽略,性能影响很低。

    2. Keycloak 服务本身的压力增加

      • 下游服务并不会向 Keycloak 发起反复的校验请求。根据 OAuth 和 OpenID Connect 的规范,JWT 是自包含的(Stateless Token),只需要下游服务拥有 Keycloak 的公钥解码 JWT 即可校验合法性。
      • 即使如此,某些业务场景会需要向 Keycloak 访问 /userinfo 或其他端点来查询 Token 的额外信息。这些频繁的外部调用可能会对 Keycloak 造成一定的压力,尤其在大流量场景下。

      避免该问题的方案:

      • 尽量依赖本地解码和校验(使用公钥或签名信任机制)。
      • 减少直接请求 Keycloak 的 /userinfo 端点的次数。
      • 在下游服务中通过缓存(如 Redis 或 Spring Cache)保存解码后的用户信息,减少重复 JWT 解码的次数。

      结论:避免频繁调用 Keycloak,可以显著降低 Keycloak 的负载。

    3. 跨多个下游服务的性能消耗

      • 如果多个下游服务都独立注册到 Keycloak,那么每个下游服务都需要进行 JWT 解码和用户信息解析,会导致一定程度的重复操作。
      • 如果用户信息转换为自定义的格式或上下文对象(例如:业务逻辑需要的 UserDetails),那么这种转换也需要每个服务独立实现,导致重复逻辑,增加开发维护成本。

      如何优化: 引入共享用户信息服务(User Context Service),缓存或集中管理已经解析的用户信息,下游服务不需要直接解析 JWT,而是通过共享服务统一获取。

      结论:多服务独立进行 Token 解析可能带来部分性能上的浪费,但可以通过引入共享机制优化。


    优化建议:性能与架构并存的解决方案

    如果你的系统对性能非常敏感或者需要处理大量请求,可以通过以下优化方式降低性能影响:

    1. 使用网关做集中校验(推荐网关透传)

    在网关集中解析 Token,同时通过请求头或者统一的 Session 将用户信息传递给下游服务。

    • 优点:
      • 所有的 Token 校验和解析只在网关完成,避免了下游服务的重复校验。
      • 网关可以配置缓存策略,将解析后的用户信息缓存到 Redis 或其他持久层,提高性能。
    • 缺点:
      • 增加了网关的负载(但性能影响通常可以接受)。
      • 如果网关不可用,下游服务无法获取完整的用户信息。

    适用场景:

    • 适合大多数业务场景,尤其是服务数量多、需求简单的微服务架构。

    2. 下游服务直接解码 JWT,避免依赖网关

    如果希望下游服务具备高独立性,可以让下游服务直接从 JWT 解码出用户信息。

    • 优点:
      • 下游服务不依赖网关,获得了更高的独立性。
      • 系统架构更符合分布式的设计思维,每个微服务独立完成认证部分的业务逻辑。
    • 缺点:
      • 不同服务重复进行 Token 验证,会产生一定的资源浪费。
      • 需要每个下游服务维护 Keycloak Public Key 或其他身份认证配置。

    适用场景:

    • 适合微服务数量较少,对性能要求一般,但对服务独立性要求较高的场景。

    3. 引入共享用户上下文服务(推荐用于分布式服务)

    在网关和下游服务之间引入一个独立的共享用户上下文服务:

    • 网关会将用户的 JWT 或基本信息共享给上下文服务。
    • 下游服务通过上下文服务查询用户信息,而无需重复解码或请求 Keycloak。

    架构流程:

    前端  --->  网关(JWT 校验) ---> 用户上下文服务(Redis 缓存)
          --->  下游服务通过上下文服务扩展用户信息
    

    这个方案相当于在网关负责用户认证与鉴权的基础上,多了一层用户信息缓存,最大限度减少负载。 优点:

    • 性能高效,因为缓存了用户信息。
    • 下游服务无需解析 JWT 或依赖 Keycloak。 缺点:
    • 额外的开发和维护开销。
    • 需要确保上下文服务的高可用。

    适用场景:

    • 流量非常大且下游服务较多;同时需要频繁查询用户信息的场景。

    4. 下游服务通过 Keycloak Adapter 完成认证

    Keycloak 提供了 Java Adapter,可以直接帮助下游服务和 Keycloak 集成:

    • 下游服务会通过 Adapter 自动完成权限验证和信息查询,完全脱离网关传递任何用户信息。
    • 适用于已经使用 Keycloak 官方的 Adapter 且下游业务比较独立的情况。

    注意:适用于中小型系统或单体服务,与微服务场景可能会有一定冲突


    总结与建议

    1. 优先使用网关集中校验 Token 的方式:

      • 配合 Spring Session 或 Redis,将解析后的信息传给下游服务。
      • 性能与维护性可控,适用于大多数场景。
    2. 对于性能有更高要求:

      • 考虑引入共享的用户上下文服务,缓存用户信息,减少 JWT 反复解析和校验。
    3. 下游服务直接注册到 Keycloak:

      • 通常不会有太大的性能问题,因为 JWT 的校验和解析是轻量操作。
      • 避免频繁调用 Keycloak 的 API(如 /userinfo),利用缓存或本地解密机制优化性能。

    根据你的场景和需求,结合这些方案选择合适的架构即可!如果还有更多的具体需求,可以继续讨论~ 😊

  5. User

    能把jwt解析结果自动放入spring-session-data-redis吗,我不想自己写代码

  6. Assistant

    在标准的 Spring Security + Spring Session + Spring Boot 配置中,Spring 本身没有默认将 JWT 解码并自动将解析结果存储到 Spring Session(例如 Redis)中的功能。为了实现这个目标,仍然需要一些额外的定制代码。不过,Spring 提供了许多内置的能力,可以大大减少手动编写的逻辑。以下是实现这一目标的详细方法,尽量减少自定义代码。


    核心需求

    我们希望实现这样的功能:

    1. JWT 解码: 对接 Keycloak,验证并解析 JWT。
    2. 用户信息存储: 把解码后的核心用户信息自动存储到 Spring Session(如 Redis),供后续服务使用。
    3. Spring Security 自动集成: 避免手动编写复杂解析逻辑。

    实现方式

    Spring Security 的设计机制中,JwtAuthenticationToken 是 JWT 的解析结果,其中已经包含了用户身份和凭证等信息。将这些数据写入 Spring Session,我们可以利用以下流程:

    1. 开启 Redis 环境支持 Spring Session: 配置 Spring Session Data Redis。
    2. 扩展 Spring Security 用户上下文 Customizer: 自动将解析信息存入 Session,不需要显式编写复杂代码。
    3. 利用 Spring 内置机制处理用户身份管理: 让 Spring 自动存储解码的用户信息。

    以下是完整的实现方案:


    1. 配置 Spring Security 和 Resource Server

    Spring 提供 OAuth2 Resource Server 支持,用于校验 JWT。配置方式如下:

    # application.yml
    spring:
      security:
        oauth2:
          resourceserver:
            jwt:
              issuer-uri: http://<keycloak-host>/realms/<realm-name> # Keycloak 的 Realm URL
    
    spring:
      session:
        store-type: redis  # 启用 Redis 存储 Spring Session
        redis:
          flush-mode: immediate # 使 Session 更快速同步到 Redis
      redis:
        host: localhost  # Redis 的主机地址
        port: 6379       # Redis 的端口号
    

    Spring Boot 会自动加载 Keycloak 的公钥等配置信息。

    添加必要依赖:

    <!-- Spring Security 和 Spring Session 依赖 -->
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
    </dependency>
    

    2. 将解析结果存入 Session:配置 Spring Security

    在 Spring Security 配置中,我们需要增强会话的处理方式,将 Jwt 解析结果自动存入 Spring Session。

    自定义 Spring Security 配置:

    @EnableWebSecurity
    public class SecurityConfig extends WebSecurityConfigurerAdapter {
    
        @Override
        protected void configure(HttpSecurity http) throws Exception {
            http
                .authorizeRequests(authorize -> authorize
                    .anyRequest().authenticated() // 确保所有请求需要认证
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt() // 启用 JWT 解码支持
                )
                .sessionManagement()
                    .maximumSessions(1) // 单用户的最大 session 数
                    .and()
                    .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED); // 启动基于 Session 的会话状态
        }
    }
    

    这里启用了 OAuth2 Resource Server 和基于 Session 的会话管理。


    3. 自动存储用户信息到 Spring Session

    Spring Security 的 Jwt 解码后,默认会生成 JwtAuthenticationToken。我们可以使用 Spring Security Context 将用户信息嵌入到 Session 中,而无需手动操作。

    增强 JwtAuthenticationConverter:

    通过定制 JwtAuthenticationConverter,将解析的用户信息自动存放在 Security Context 中,随后它会被自动存储到 Spring Session Data Redis。

    import org.springframework.context.annotation.Bean;
    import org.springframework.security.core.Authentication;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    import org.springframework.security.web.SecurityFilterChain;
    
    import java.util.HashMap;
    
    @Configuration
    public class JwtConfig {
    
        /**
         * 配置如何将 JWT 的内容解析为 Spring Security 的 Authentication 对象
         */
        @Bean
        public JwtAuthenticationConverter jwtAuthenticationConverter() {
            JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
    
            // 将 JWT 中的“roles”字段作为权限列表
            JwtGrantedAuthoritiesConverter grantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
            grantedAuthoritiesConverter.setAuthorityPrefix("ROLE_");
            grantedAuthoritiesConverter.setAuthoritiesClaimName("roles");
            jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter);
    
            return jwtAuthenticationConverter;
        }
    
        @Bean
        public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
            http
                .authorizeHttpRequests(req -> req.anyRequest().authenticated())
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthenticationConverter()))); // 应用自定义的转换逻辑
    
            return http.build();
        }
    }
    

    在这里,我们解析了自定义的 JWT 字段(比如 roles),并生成了 JwtAuthenticationToken 对象,其中的内容会自动写入 Spring Security Context。


    4. Spring Session 自动与 Redis 集成

    当请求通过网关时,解析后的用户信息自动存储到了 SecurityContextHolder 中,Spring Session 会自动将其序列化到 Redis 中。你无需手动操作,所有数据将自动完成存入和恢复!

    验证步骤:

    1. Redis 中,spring:session:sessions:<session-id> 键会包含序列化的 HTTP Session。
    2. 解析的 JwtAuthenticationToken 将存在其中,包含用户信息。

    验证:如何在下游服务中获取用户信息

    在下游服务中读取用户信息非常简单。由于用户信息存储在 Spring 的 SecurityContextHolder 中,所有下游服务都可以从中获得用户的相关信息。

    示例:在 Controller 层获取用户信息:

    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.context.SecurityContextHolder;
    
    @RestController
    public class UserController {
    
        @GetMapping("/me")
        public Map<String, Object> getUserInfo() {
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
    
            // 提取用户信息
            String username = authentication.getName(); // 用户名
            if (authentication.getCredentials() instanceof Jwt) {
                Jwt jwt = (Jwt) authentication.getCredentials();
                Map<String, Object> claims = jwt.getClaims(); // JWT 声明信息
                return claims;
            }
            return Map.of("username", username);
        }
    }
    

    额外说明:优化性能

    自动存储用户信息到 Redis 会引入序列化 / 反序列化的性能开销。如果性能要求较高:

    1. 尽量精简存储的数据: 避免过于庞大的 Session 数据。
    2. 按需解码: 如果部分下游服务只需要用户 ID 或基本信息,可以直接透传 Token,由服务自行解析。
    3. 启用 Redis 序列化优化: 使用 Jackson2JsonRedisSerializer 缩减数据体积。

    总结

    通过上述配置,你已经实现了如下功能:

    1. JWT 自动解析: 将 Token 解码后的内容写入 JwtAuthenticationToken。
    2. Spring Session 自动存储: 使用 Redis 自动存储会话数据,无需手动管理。
    3. 透明用户访问: 下游服务可以直接从 SecurityContextHolder 中读取用户信息。

    整个流程使用了 Spring 提供的内置功能,非常标准化,完全不需要额外的自定义逻辑,是目前最推荐的实现方式!

  7. User

    springboot3是这个方法: public ServerHttpSecurity sessionManagement(Customizer customizer) { if (this.sessionManagement == null) { this.sessionManagement = new SessionManagementSpec(); } customizer.customize(this.sessionManagement); return this; }

  8. Assistant

    是的,您提到的 ServerHttpSecurity 的 sessionManagement(Customizer<SessionManagementSpec> customizer) 方法属于 Spring Security 5.x 开始引入的 WebFlux 响应式安全配置的一部分,它支持更现代的配置方式,主要用来配置 Session 的管理逻辑。

    如果您的项目是基于 Spring Boot 3.x 和 WebFlux(响应式编程),而不是传统的 Spring MVC,那么确实需要采用这种方法来对 SecurityConfig 进行配置。下面我将基于 WebFlux 和 Spring Boot 3.x 为您详细说明如何正确地集成 JWT 自动解析,并存储相关信息到 Redis(通过 spring-session-data-redis 支持)。


    响应式开发中的 JWT 和 Session 处理

    WebFlux 中的整个安全认证和会话管理体系与传统 Servlet MVC 的方式略有不同。主要的区别包括:

    1. ServerHttpSecurity 替代 HttpSecurity 作为安全配置入口。
    2. 响应式应用中使用的是 ReactiveAuthenticationManager 和 ReactiveSecurityContextHolder。
    3. 会话使用响应式的 WebSession,通过 Reactor 提供的流式操作支持。

    以下是一种完整的适配实现方案,满足以下需求:

    • JWT 解码和校验。
    • 自动存储解码的用户信息到 Redis(通过 Spring Session 集成)。
    • 响应式安全性集成。

    配置步骤

    1. 在 application.yml 中开启会话支持

    spring:
      security:
        oauth2:
          resourceserver:
            jwt:
              issuer-uri: http://<keycloak-host>/realms/<realm-name> # 替换为实际的 Keycloak 机构 URI
      session:
        store-type: redis # 启用 Redis 存储 Spring Session
      redis:
        host: localhost # Redis 的主机名
        port: 6379      # Redis 的端口号
    

    Redis 会负责基于 会话 ID 存储响应式会话数据。在会话中存储的安全上下文数据(如用户信息)会被自动序列化并保存到 Redis。


    2. 配置 ServerHttpSecurity 来支持 JWT 校验

    在 Spring Security 5.x 的响应式安全架构中,您需要使用 ServerHttpSecurity 来代替传统的 HttpSecurity。

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.authentication.ReactiveAuthenticationManager;
    import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
    import org.springframework.security.core.Authentication;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.jwt.ReactiveJwtDecoder;
    import org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    import org.springframework.security.oauth2.server.resource.authentication.ReactiveJwtAuthenticationConverter;
    import org.springframework.security.web.server.SecurityWebFilterChain;
    
    @Configuration
    @EnableWebFluxSecurity
    public class SecurityConfig {
    
        /**
         * 定义响应式安全过滤链
         */
        @Bean
        public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
            http
                .authorizeExchange(exchanges -> exchanges
                    .anyExchange().authenticated() // 所有请求都需要认证
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwtSpec -> jwtSpec
                        .jwtAuthenticationConverter(jwtAuthenticationConverter()) // 自定义 JWT 转换器
                    )
                )
                .sessionManagement(session -> session
                    .sessionCreationPolicy(SessionCreationPolicy.IF_REQUIRED) // 启用会话支持
                );
            return http.build();
        }
    
        /**
         * 自定义 JWT 转换器,将 Token 中内容映射为权限以及其他用户信息
         */
        private ReactiveJwtAuthenticationConverter jwtAuthenticationConverter() {
            ReactiveJwtAuthenticationConverter converter = new ReactiveJwtAuthenticationConverter();
    
            // 自定义将 "roles" 声明作为用户的权限
            JwtGrantedAuthoritiesConverter authoritiesConverter = new JwtGrantedAuthoritiesConverter();
            authoritiesConverter.setAuthorityPrefix("ROLE_");
            authoritiesConverter.setAuthoritiesClaimName("roles");
    
            converter.setJwtGrantedAuthoritiesConverter(authoritiesConverter);
            return converter;
        }
    }
    

    关键点:

    • SecurityWebFilterChain 替代 HttpSecurity,通过 ServerHttpSecurity 配置 Filter Chain。
    • 使用 ReactiveJwtAuthenticationConverter 从 JWT 中提取权限和用户信息。
    • 会话管理通过 sessionManagement() 配置,设置为 SessionCreationPolicy.IF_REQUIRED,表示按需创建会话。

    3. 将用户信息自动存储到 Redis 会话

    Spring Security 在解析 JWT 后,会将 Authentication 对象存放到 SecurityContext 中。通过与 Spring Session 集成,SecurityContext 内部的用户信息将自动被序列化到 Redis。

    Spring Boot 3.x 和 Spring Security 5.x 的会话支持已经默认完成了这部分操作,因此您无需编写任何额外代码。

    Redis 的存储结构中会出现类似如下的键:

    spring:session:sessions:<SESSION_ID>
    

    对应到存储的值中,Principal 用户信息以及 GrantedAuthority 等会被序列化存储。


    4. 在业务逻辑中读取会话中的用户信息

    在 WebFlux 响应式应用中,我们可以通过 ReactiveSecurityContextHolder 直接获取当前用户的 Authentication 信息。

    示例 Controller:
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import reactor.core.publisher.Mono;
    
    @RestController
    public class UserController {
    
        @GetMapping("/me")
        public Mono<Map<String, Object>> getUserInfo() {
            return ReactiveSecurityContextHolder.getContext()
                .map(securityContext -> securityContext.getAuthentication())
                .map(authentication -> {
                    Map<String, Object> result = new HashMap<>();
                    result.put("name", authentication.getName()); // 用户名
                    if (authentication.getCredentials() instanceof Jwt) {
                        Jwt jwt = (Jwt) authentication.getCredentials();
                        result.put("claims", jwt.getClaims()); // JWT 中的所有声明
                    }
                    return result;
                });
        }
    }
    

    5. 验证 Redis 中的存储

    启动应用后,尝试访问 API。用户请求经过以下流程:

    1. 前端携带 Authorization: Bearer <access_token>。
    2. Spring Security 校验 JWT 并将用户信息解码为 Authentication。
    3. 自动将 Authentication 和 SecurityContext 存储到 Redis 中的 Session。
    4. 在 Redis 中,您可以使用工具查看到类似以下 Session 数据:
      {
        "id": "some-session-id",
        "principal": {
          "name": "user@example.com",          # 用户身份
          "permissions": ["ROLE_USER"],        # 用户权限
          "details": { "email": "user@example.com" }
        },
        "lastUpdated": 1698593451
      }
      

    注意事项

    1. JWT Token 本身已是无状态:

      • 如果不依赖会话,可以完全跳过 Redis,会话支持就不必要。
      • 下游服务可以直接从请求头中的 JWT 自行解析,而无需依赖会话。
    2. Session 与微服务的权衡:

      • 如果各微服务需要共享用户会话信息,Redis 会是较为高效的解决方案。
      • 如果性能压力较大,可考虑将用户信息直接通过 Header 传递,不使用会话。

    总结

    依赖 ServerHttpSecurity 和 ReactiveJwtAuthenticationConverter,Spring Security WebFlux 自带的能力已经能够自动完成以下功能:

    1. 解码 JWT 并将用户信息写入 SecurityContext。
    2. 将 SecurityContext 中的用户信息自动序列化到 Redis(通过 Spring Session 集成)。

    整个过程无需额外开发代码,能够很好地满足现代微服务的需求。如果还需要进一步优化性能或增强用户信息共享,可以考虑直接使用共享上下文服务或消息队列传递用户信息。

  9. User

    只有这个方法: public SessionManagementSpec concurrentSessions(Customizer customizer) { if (this.concurrentSessions == null) { this.concurrentSessions = new ConcurrentSessionsSpec(); } customizer.customize(this.concurrentSessions); return this; }

  10. Assistant

    感谢您指出了进一步的细节,您提到了 SessionManagementSpec.concurrentSessions(Customizer<ConcurrentSessionsSpec> customizer) 方法,这实际上是传统基于 Servlet 的 Spring Security 上下文中的并发会话管理功能,而不是 WebFlux 的响应式功能,也并不是在针对 Spring Security 5.x 的 ServerHttpSecurity 响应式 API。

    为了更好地帮助您解决问题,我需要进一步澄清需求,确保提供的方案完全匹配您的实际场景。根据您的描述,我将假定以下几点:

    1. 您正在使用 Spring Security 5.x 或 Spring Boot 3.x。
    2. 您希望使用 Redis 存储会话(即基于 spring-session-data-redis 的存储)。
    3. 重点仍然是如何将解码后的 JWT 用户信息存储到 Redis 中,而不是重复手动解析数据。
    4. 您似乎是在使用 传统的 Servlet 体系结构(如 Spring MVC) 而非 WebFlux。

    基于这几点上下文,我将调整和强化方案,为您解决问题。


    完整实现方案:使用 JWT 和 Redis 会话

    1. JWT 的解析和用户信息自动写入 Spring Security 上下文

    在基于 Spring Security 的架构中,JWT 的解析和权限授予通常是由 JwtAuthenticationConverter(针对 Spring Security Oauth2 Resource Server JWT 解析器)来完成的。当用户的请求携带 Authorization: Bearer <token> 时:

    1. Spring Security 作为资源服务器验证 JWT 并解析用户信息。
    2. 解析后的用户信息会自动作为 Authentication 被装入 SecurityContext。
    3. 默认行为: Spring Security 会自动将 SecurityContext 存入 HttpSession,如果启用了 Spring Session,则会被存储到 Redis 中。

    配置文件:

    spring:
      security:
        oauth2:
          resourceserver:
            jwt:
              issuer-uri: http://<keycloak-host>/realms/<realm-name> # 替换为 Keycloak 的 realm 发行者 URL
      session:
        store-type: redis  # 启用 Spring Session 和 Redis 集成
      redis:
        host: localhost  # Redis 主机名
        port: 6379       # Redis 端口号
    

    代码部分如下:

    自定义 SecurityConfig 配置:
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.builders.HttpSecurity;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
    import org.springframework.security.web.SecurityFilterChain;
    
    @Configuration
    public class SecurityConfig {
    
        @Bean
        public SecurityFilterChain securityFilterChain(HttpSecurity http) throws Exception {
            http
                .authorizeHttpRequests(authorize -> authorize
                    .anyRequest().authenticated() // 所有请求必须认证
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthenticationConverter())) // 自定义 JWT 转换器
                )
                .sessionManagement(session -> session
                    .sessionConcurrency(concurrent -> concurrent
                        .maximumSessions(1) // 限制单个用户的最大并发会话数
                    )
                );
            return http.build();
        }
    
        private JwtAuthenticationConverter jwtAuthenticationConverter() {
            JwtAuthenticationConverter jwtAuthenticationConverter = new JwtAuthenticationConverter();
    
            // 自定义从 JWT 中提取权限的逻辑
            JwtGrantedAuthoritiesConverter grantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
            grantedAuthoritiesConverter.setAuthorityPrefix("ROLE_"); // 权限前缀,例如:ROLE_USER
            grantedAuthoritiesConverter.setAuthoritiesClaimName("roles"); // JWT 中"roles"字段存储权限信息
    
            jwtAuthenticationConverter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter);
            return jwtAuthenticationConverter;
        }
    }
    

    解释:

    • JwtAuthenticationConverter 是 Spring Security 内置的转换器,主要负责将 JWT 的声明(claims)转换为 Authentication 对象。
    • 上述代码中,我们利用了 JwtGrantedAuthoritiesConverter,将 JWT 中的 roles 解码为 Spring Security 的 GrantedAuthority,便于访问控制。

    2. 将解析后的用户信息自动存储到 Redis

    Redis 的会话存储(Spring Session Data Redis)会负责将 Spring Security 的 SecurityContext 自动序列化到 Redis 中。这包括以下内容:

    • 解码后的 Authentication 对象。
    • 用户权限(GrantedAuthority)信息。
    • ID Token 或 Access Token 中的用户声明(如用户名、用户角色等)。

    无需额外操作,Spring Session 会自动完成此任务。以下是 Redis 中会存储的典型数据:

    {
      "session-id": "some-session-uuid",
      "attributes": {
        "SPRING_SECURITY_CONTEXT": {
          "authentication": {
            "principal": "<USERNAME>",
            "authorities": ["ROLE_USER", "ROLE_ADMIN"],
            "details": {
              "tokenValue": "<JWT_TOKEN>"
            }
          }
        }
      }
    }
    

    3. 在控制器中访问存储的用户信息

    业务代码中,您可以通过 SecurityContextHolder.getContext() 获取当前会话中的用户信息。例如:

    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Map;
    
    @RestController
    public class UserController {
    
        @GetMapping("/me")
        public Map<String, Object> getUserDetails() {
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            String username = authentication.getName(); // 当前用户的用户名
            // 获取权限列表
            Object roles = authentication.getAuthorities();
    
            return Map.of("username", username, "roles", roles);
        }
    }
    

    4. Redis 中存储的优化(可选项)

    在 Redis 中存储会话时,Spring 默认会将整个 SecurityContext 对象序列化为二进制。这可能会导致 Redis 数据较多。如果希望优化存储,可以:

    1. 自定义 Redis 序列化机制,压缩存储的内容。
    2. 仅提取必要的 JWT Claims 进行存储,而非完整的 SecurityContext。
    自定义 Redis 序列化器:
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.data.redis.serializer.GenericJackson2JsonRedisSerializer;
    import org.springframework.session.data.redis.config.annotation.web.http.EnableRedisHttpSession;
    import org.springframework.session.web.http.DefaultCookieSerializer;
    
    @Configuration
    @EnableRedisHttpSession
    public class RedisSessionConfig {
    
        @Bean
        public GenericJackson2JsonRedisSerializer springSessionDefaultRedisSerializer() {
            return new GenericJackson2JsonRedisSerializer(); // 使用 JSON 格式序列化会话数据
        }
    
        @Bean
        public DefaultCookieSerializer defaultCookieSerializer() {
            DefaultCookieSerializer cookieSerializer = new DefaultCookieSerializer();
            cookieSerializer.setCookieName("SESSION"); // 自定义 Cookie 名字
            return cookieSerializer;
        }
    }
    

    5. 使用并发会话管理

    如果您提到的 SessionManagementSpec.concurrentSessions(),它主要用于管理同一用户的并发会话限制,例如:

    • 一个用户不允许在多个设备上同时登录。
    • 超出并发会话限制时,强制使旧的会话失效。

    在上面的配置中,可以这样实现:

    http
        .sessionManagement(session -> session
            .sessionConcurrency(concurrent -> concurrent
                .maximumSessions(1) // 限制同一用户的最大并发会话数
                .maxSessionsPreventsLogin(true) // 如果超出限制,禁止新的会话登录(true 则禁止新会话)
            )
        );
    

    总结

    • 配置解析 JWT 并自动存入 Redis: 使用 Spring Security 的 JwtAuthenticationConverter 配置,结合 Spring Session 自动完成 Redis 存储。
    • 无需自定义代码: Redis 会自动序列化 SecurityContext,包括用户信息和权限。
    • 扩展并发会话管理: 可以通过 SessionManagementSpec.concurrentSessions() 配置并发会话数限制。

    如果还有问题,欢迎随时进一步讨论! 😊

  11. User

    需要的类型: Converter <org.springframework.security.oauth2.jwt.Jwt, ? extends reactor.core.publisher.Mono<? extends org.springframework.security.authentication.AbstractAuthenticationToken>> 提供的类型: JwtAuthenticationConverter

  12. Assistant

    从您提供的信息来看,您使用的是 Spring WebFlux(响应式编程模型),而不是传统的 Spring MVC。这一点改变了某些 API 的使用方式。


    Spring WebFlux 使用的是响应式的 Mono 和 Flux 类型,因此必须提供一个返回类型为 Mono<? extends AbstractAuthenticationToken> 的 Converter<Jwt, Mono<? extends AbstractAuthenticationToken>> 实现,而不能直接使用传统的 JwtAuthenticationConverter(它是非响应式的)。

    为什么会出问题?

    您尝试使用的是 JwtAuthenticationConverter,该类是为传统的 Spring MVC 和同步编程模式设计的,而在 WebFlux 中,您需要使用响应式的 Converter<Jwt, Mono<? extends Authentication>>,这是 Spring Security 为了支持响应式机制的一种改进和要求。


    如何解决问题?

    我们需要自定义一个适用于 WebFlux 的响应式 Jwt 转换器,可以遵循以下步骤:


    1. 构建自定义的响应式 JwtAuthenticationConverter

    自定义一个 Converter<Jwt, Mono<AbstractAuthenticationToken>>:

    import org.springframework.core.convert.converter.Converter;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.server.resource.authentication.BearerTokenAuthentication;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    import reactor.core.publisher.Mono;
    
    public class ReactiveJwtAuthenticationConverter implements Converter<Jwt, Mono<AbstractAuthenticationToken>> {
    
        private final JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
    
        @Override
        public Mono<AbstractAuthenticationToken> convert(Jwt jwt) {
            // 提取 JWT 中的权限(默认从 "scope" 或自定义字段中提取)
            var authorities = jwtGrantedAuthoritiesConverter.convert(jwt);
    
            // 构建一个 BearerTokenAuthentication,包含用户信息和权限
            AbstractAuthenticationToken authenticationToken = new BearerTokenAuthentication(
                    jwt, jwt.getTokenValue(), authorities
            );
            return Mono.just(authenticationToken); // 返回响应式的 Mono 类型
        }
    }
    

    解释:

    • JwtGrantedAuthoritiesConverter 是一个内置的工具类,用于从 Token 中提取权限。
      • 默认会从 scope 声明中提取权限。
      • 您可以自定义提取字段(例如 roles)。
    • 构造 BearerTokenAuthentication,它是 Spring Security 用于表示 JWT 用户认证的一个实现类。

    如果 JWT 的权限声明在其他字段(比如 roles),我们可以调整自定义逻辑,比如:

    // 提取自 "roles" 字段,而非默认的 "scope"
    jwtGrantedAuthoritiesConverter.setAuthoritiesClaimName("roles");
    

    2. 配置 ServerHttpSecurity,使用自定义的转换器

    在 ServerHttpSecurity 配置中,使用前面定义的 ReactiveJwtAuthenticationConverter:

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.Customizer;
    import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
    import org.springframework.security.oauth2.server.resource.authentication.ReactiveJwtAuthenticationConverterAdapter;
    import org.springframework.security.web.server.SecurityWebFilterChain;
    import reactor.core.publisher.Mono;
    
    @Configuration
    @EnableWebFluxSecurity
    public class SecurityConfig {
    
        @Bean
        public SecurityWebFilterChain springSecurityFilterChain(ServerHttpSecurity http) {
            http
                .authorizeExchange(authorize -> authorize
                    .anyExchange().authenticated() // 所有请求需要认证
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwtSpec -> jwtSpec
                        .jwtAuthenticationConverter(jwtAuthenticationConverter()) // 使用自定义转换器
                    )
                )
                .csrf(csrf -> csrf.disable()); // 禁用 CSRF(根据需要配置)
            return http.build();
        }
    
        @Bean
        public Converter<Jwt, Mono<AbstractAuthenticationToken>> jwtAuthenticationConverter() {
            return new ReactiveJwtAuthenticationConverter();
        }
    }
    

    关键点:

    • 我们自定义了一个响应式的 JwtAuthenticationConverter,并注册到 ServerHttpSecurity.oauth2ResourceServer().jwt() 配置中。
    • WebFlux 中 必须返回响应式类型,因此所有转换器都需要返回 Mono 或 Flux。

    3. 验证 JWT 并存储到 Redis

    1. Spring Security 负责解析 Token,将 AbstractAuthenticationToken 存储到 ReactiveSecurityContextHolder。
    2. 如果启用了 Spring Session,它会自动将 ReactiveSecurityContext 的信息写入 Redis 中。在 Redis 中将会存储用户的认证及权限信息(序列化形式)。

    4. 验证是否存储成功

    访问受保护的 API 后,检查 Redis 中存储的会话信息。您可以使用 Redis CLI 或工具检查:

    > keys *
    spring:session:index:org.springframework.session.FindByIndexNameSessionRepository.PRINCIPAL_NAME_INDEX_NAME:<username>
    spring:session:sessions:<session-id>
    

    查看特定的会话数据,确认是否存储了认证信息(包含 JWT 解出的用户声明信息)。


    完整代码示例

    1. ReactiveJwtAuthenticationConverter
    import org.springframework.core.convert.converter.Converter;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.server.resource.authentication.BearerTokenAuthentication;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    import reactor.core.publisher.Mono;
    
    public class ReactiveJwtAuthenticationConverter implements Converter<Jwt, Mono<AbstractAuthenticationToken>> {
    
        private final JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
    
        @Override
        public Mono<AbstractAuthenticationToken> convert(Jwt jwt) {
            // 提取权限(默认从 "scope",或者 "roles" 等字段)
            var authorities = jwtGrantedAuthoritiesConverter.convert(jwt);
    
            // 将用户信息和权限信息封装成 AbstractAuthenticationToken
            AbstractAuthenticationToken authenticationToken = new BearerTokenAuthentication(
                    jwt, jwt.getTokenValue(), authorities
            );
    
            return Mono.just(authenticationToken);
        }
    }
    
    1. SecurityConfig
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
    import org.springframework.security.web.server.SecurityWebFilterChain;
    import reactor.core.publisher.Mono;
    
    @Configuration
    @EnableWebFluxSecurity
    public class SecurityConfig {
    
        @Bean
        public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
            http
                .authorizeExchange(authz -> authz
                    .anyExchange().authenticated()
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwt -> jwt
                        .jwtAuthenticationConverter(jwtAuthenticationConverter())
                    )
                );
            return http.build();
        }
    
        @Bean
        public Converter<Jwt, Mono<AbstractAuthenticationToken>> jwtAuthenticationConverter() {
            return new ReactiveJwtAuthenticationConverter();
        }
    }
    
    1. 从 Redis 中读取用户信息
    import org.springframework.security.core.context.ReactiveSecurityContextHolder;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import reactor.core.publisher.Mono;
    
    @RestController
    public class UserController {
    
        @GetMapping("/me")
        public Mono<Map<String, Object>> getUserDetails() {
            return ReactiveSecurityContextHolder.getContext()
                .map(securityContext -> securityContext.getAuthentication())
                .map(authentication -> {
                    String username = authentication.getName(); // 用户名
                    var authorities = authentication.getAuthorities(); // 权限信息
                    return Map.of("username", username, "authorities", authorities);
                });
        }
    }
    

    总结

    在 WebFlux 中:

    • JwtAuthenticationConverter 无法直接使用,因为它是同步的。
    • 需要自定义一个响应式的 Converter<Jwt, Mono<AbstractAuthenticationToken>>,并集成到 oauth2ResourceServer.jwt() 配置中。
    • 整个用户信息将存储到 Spring Context(以及 Redis),下游服务可以从 ReactiveSecurityContextHolder 中读取。

    再次尝试后,如果还有问题,欢迎继续讨论! 😊

  13. User

    必需类型 已提供 principal: OAuth2AuthenticatedPrincipal Jwt credentials: OAuth2AccessToken String

  14. Assistant

    您的问题表明,在 Spring WebFlux 的响应式安全配置中,存在一个类型不匹配的问题。您正在尝试使用 Spring Security 的 Jwt 支持(从一个 JWT 中创建 Authentication 对象),但由于配置的类型不匹配,可能无法构造正确的 AuthenticationToken。

    Spring Security 5.x 对 JWT 的认证步骤进行了分层设计,支持通过 ReactiveOAuth2AccessTokenAuthenticationConverter 或其他工具将 JWT 的解析及用户、访问令牌等统一封装到 Authentication 中。而从您的问题来看,特别是以下:

    必需类型:
    principal: OAuth2AuthenticatedPrincipal (实际需要的类型)
    已提供:
    principal: Jwt
    credentials: OAuth2AccessToken, String
    

    表明,Spring Security 正确解码了 JWT,但需要一个符合 OAuth2 认证流程的 AuthenticationToken,而不是直接使用 Jwt。


    解决问题的核心原因

    这是由于 JWT 转换器 (Converter) 在 WebFlux 环境下需要正确定制,而默认的 JwtReactiveAuthenticationConverterAdapter 配置不能满足复杂的需求。

    您当前如果构造的 Authentication 错误,Spring 的 SecurityContext 被存储回 Redis 或被调用时便无法正确匹配 OAuth2 的结构封装。


    解决方案

    您需要构造一个自定义的 Reactive JWT 转换器,确保 principal 和 credentials 的类型正确组合,并符合 Spring Security 要求:

    1. principal (OAuth2AuthenticatedPrincipal):

      • 这是 Authentication 对象的主用户信息。
      • OAuth2 体系要求,是一个 OAuth2AuthenticatedPrincipal(而不是 Jwt),用来表示解析后的用户对象。
    2. credentials (OAuth2AccessToken):

      • 这是用户的认证凭据,通常是 OAuth2AccessToken 的对象,而不是 Jwt 的原始 Token。

    以下是完整实现方法:


    1. 自定义一个支持 OAuth2 的 ReactiveJwtAuthenticationConverter

    创建一个自定义的 ReactiveJwtAuthenticationConverter 实现,用来将 Jwt 转换为 OAuth2AuthenticationToken 或 BearerTokenAuthentication。

    import org.springframework.core.convert.converter.Converter;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.oauth2.core.OAuth2AuthenticatedPrincipal;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.server.resource.authentication.BearerTokenAuthentication;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    import reactor.core.publisher.Mono;
    
    import java.util.Collection;
    
    /**
     * 自定义一个 Reactive JWT 转换器来适配 `OAuth2AuthenticatedPrincipal`
     */
    public class CustomReactiveJwtAuthenticationConverter
            implements Converter<Jwt, Mono<AbstractAuthenticationToken>> {
    
        // 用于从 JWT 提取权限的默认工具
        private final JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
    
        @Override
        public Mono<AbstractAuthenticationToken> convert(Jwt jwt) {
            // 1. 提取 JWT 中的权限
            Collection<GrantedAuthority> authorities = jwtGrantedAuthoritiesConverter.convert(jwt);
    
            // 2. 将 JWT 包装为 OAuth2AuthorizedPrincipal
            OAuth2AuthenticatedPrincipal principal = new CustomOAuth2AuthenticatedPrincipal(jwt.getClaims(), authorities);
    
            // 3. 构造 BearerTokenAuthentication 实例,包含 principal 和 credentials
            return Mono.just(new BearerTokenAuthentication(principal, jwt, authorities));
        }
    }
    

    说明:

    • JwtGrantedAuthoritiesConverter:

      • 为了从 JWT 的字段中提取权限(默认是 scope 声明,您也可以定制)。
    • OAuth2AuthenticatedPrincipal:

      • Spring Security 要求 JWT 解码后的用户信息主干是 OAuth2AuthenticatedPrincipal(我们用 CustomOAuth2AuthenticatedPrincipal 封装)。
    • BearerTokenAuthentication:

      • 构造 Spring Security 标准的认证类,Spring 会将该类存储回 SecurityContext。

    2. 定义 CustomOAuth2AuthenticatedPrincipal 类

    这是 Spring Security 提供的 OAuth2AuthenticatedPrincipal 的一个自定义实现,用于封装解析后的用户身份信息和权限。

    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.oauth2.core.OAuth2AuthenticatedPrincipal;
    
    import java.util.Collection;
    import java.util.Map;
    
    /**
     * 自定义 OAuth2AuthenticatedPrincipal 用来接收解析后的用户信息
     */
    public class CustomOAuth2AuthenticatedPrincipal implements OAuth2AuthenticatedPrincipal {
    
        private final Map<String, Object> attributes;
        private final Collection<GrantedAuthority> authorities;
    
        public CustomOAuth2AuthenticatedPrincipal(Map<String, Object> attributes, Collection<GrantedAuthority> authorities) {
            this.attributes = attributes;
            this.authorities = authorities;
        }
    
        @Override
        public Map<String, Object> getAttributes() {
            return attributes;
        }
    
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            return authorities;
        }
    
        @Override
        public String getName() {
            return (String) attributes.get("preferred_username"); // 从 attributes 获取用户名(比如 "preferred_username" 字段)
        }
    }
    

    这段代码的职责是封装从 JWT 中解码的用户身份信息,比如 preferred_username、email 等,并将角色(ROLE_USER 等)存入权限集合。


    3. 在 ServerHttpSecurity 配置中引用自定义 Converter

    将上述的 CustomReactiveJwtAuthenticationConverter 注册到 ServerHttpSecurity 中,完成响应式接口的安全逻辑。

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
    import org.springframework.security.web.server.SecurityWebFilterChain;
    import reactor.core.publisher.Mono;
    
    @Configuration
    @EnableWebFluxSecurity
    public class SecurityConfig {
    
        @Bean
        public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
            http
                .authorizeExchange(authz -> authz
                    .anyExchange().authenticated()  // 所有请求需经过认证
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwt -> jwt
                        .jwtAuthenticationConverter(jwtAuthenticationConverter())
                    )
                );
            return http.build();
        }
    
        @Bean
        public Converter<Jwt, Mono<AbstractAuthenticationToken>> jwtAuthenticationConverter() {
            return new CustomReactiveJwtAuthenticationConverter();
        }
    }
    

    4. 业务逻辑中访问用户身份信息

    在基于 WebFlux 的控制器中,我们可以直接通过 ReactiveSecurityContextHolder 获取用户的身份信息。

    示例如下:

    import org.springframework.security.core.context.ReactiveSecurityContextHolder;
    import org.springframework.security.oauth2.core.OAuth2AuthenticatedPrincipal;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import reactor.core.publisher.Mono;
    
    import java.util.Map;
    
    @RestController
    public class UserController {
    
        @GetMapping("/me")
        public Mono<Map<String, Object>> getUserDetails() {
            return ReactiveSecurityContextHolder.getContext()
                .map(securityContext -> {
                    OAuth2AuthenticatedPrincipal principal = (OAuth2AuthenticatedPrincipal) securityContext.getAuthentication().getPrincipal();
                    return Map.of(
                        "username", principal.getName(), // 用户名
                        "attributes", principal.getAttributes() // JWT 解码后的所有声明
                    );
                });
        }
    }
    

    总结

    我们解决了类型不匹配问题,构造了符合 OAuth2 认证结构的 BearerTokenAuthentication,并确保:

    1. 使用自定义的 ReactiveJwtAuthenticationConverter 来解析 JWT。
    2. 将 JWT 中的用户信息(principal)封装为 OAuth2AuthenticatedPrincipal。
    3. 符合 Spring Security 的要求,最终使上下文中的身份信息与 SecurityContext 保持一致。

    通过 Redis 的 Session 持久化(Spring Session),上述用户 Session 和信息会自动存储下来,供后续使用。如果还有其他问题或挑战,欢迎随时继续讨论! 😊

  15. User

    public BearerTokenAuthentication(OAuth2AuthenticatedPrincipal principal, OAuth2AccessToken credentials, Collection<? extends GrantedAuthority> authorities) {

  16. Assistant

    对于您正在实现的 BearerTokenAuthentication 构造函数的参数问题,特别是 principal 和 credentials,以下内容将帮助您解决使用 OAuth2AccessToken 作为 credentials 的问题,并正确构造 BearerTokenAuthentication 对象。


    核心问题

    在 BearerTokenAuthentication 的构造函数中需要以下参数:

    1. principal:

      • 类型:OAuth2AuthenticatedPrincipal。
      • 表示已认证的主体,可能是用户或系统身份。
      • 一般需要实现该接口(例如自定义实现)。
    2. credentials:

      • 类型:OAuth2AccessToken。
      • 表示认证令牌,通常应该是一个 OAuth2AccessToken 实例。
      • 而不是直接使用 String 类型的原始 JWT。
    3. authorities:

      • 类型:Collection<? extends GrantedAuthority>。
      • 用户的权限列表(通常从 Token 中解析生成)。

    从您当前的实现中,credentials 的类型似乎为 String(原始 JWT),而不是 OAuth2AccessToken。因此需要处理正确的 OAuth2AccessToken 创建逻辑。


    解决方案

    为了正确创建 BearerTokenAuthentication 对象,您需要以下步骤:

    1. 构造 OAuth2AccessToken 对象

    OAuth2AccessToken 是 Spring Security 中表示访问令牌的一个标准实现类。您需要用它来封装 Token 的类型、值和过期信息等。可以通过以下方式创建一个 OAuth2AccessToken 实例:

    import org.springframework.security.oauth2.core.OAuth2AccessToken;
    
    import java.time.Instant;
    
    public OAuth2AccessToken createOAuth2AccessToken(String tokenValue) {
        return new OAuth2AccessToken(
            OAuth2AccessToken.TokenType.BEARER, // Token 类型(Bearer)
            tokenValue,                        // Token 的字符串值
            Instant.now(),                     // Token 生效时间(当前时间)
            Instant.now().plusSeconds(3600)    // Token 过期时间(1小时后)
        );
    }
    
    • 此函数封装了从原始 JWT (String) 向 OAuth2AccessToken 类型转换的逻辑。
    • 如果您的 JWT 包含具体的生效时间(iat)或过期时间(exp),可以解析这些时间值并按需替换 Instant.now() 和 Instant.now().plusSeconds(3600)。

    例如:

    Instant issuedAt = Instant.ofEpochSecond(jwt.getClaim("iat")); // iat: Token 签发时间(秒)
    Instant expiresAt = Instant.ofEpochSecond(jwt.getClaim("exp")); // exp: Token 过期时间(秒)
    
    return new OAuth2AccessToken(OAuth2AccessToken.TokenType.BEARER, tokenValue, issuedAt, expiresAt);
    

    2. 构造 principal 对象

    principal 应为 OAuth2AuthenticatedPrincipal 实例(通常是 JWT Claims 的包装)。如果您需要自定义实现,可以使用以下示例:

    import org.springframework.security.oauth2.core.OAuth2AuthenticatedPrincipal;
    import org.springframework.security.core.GrantedAuthority;
    
    import java.util.Collection;
    import java.util.Map;
    
    public class CustomOAuth2Principal implements OAuth2AuthenticatedPrincipal {
    
        private final Map<String, Object> attributes;
        private final Collection<? extends GrantedAuthority> authorities;
    
        public CustomOAuth2Principal(Map<String, Object> attributes, Collection<? extends GrantedAuthority> authorities) {
            this.attributes = attributes;
            this.authorities = authorities;
        }
    
        @Override
        public Map<String, Object> getAttributes() {
            return this.attributes;
        }
    
        @Override
        public Collection<? extends GrantedAuthority> getAuthorities() {
            return this.authorities;
        }
    
        @Override
        public String getName() {
            return (String) this.attributes.get("preferred_username"); // 返回用户名
        }
    }
    

    在这个实现中,principal 属性(用户数据)是从 JWT 的 claims 中提取的。所以构造对象时,假设 JWT 已解析为 Jwt jwt:

    // 从 Jwt 中提取所有声明字段 (Claims)
    Map<String, Object> claims = jwt.getClaims();
    
    // 从 Jwt 提取用户的权限列表
    Collection<GrantedAuthority> authorities = new JwtGrantedAuthoritiesConverter().convert(jwt);
    
    // 构造 CustomOAuth2Principal 实例
    OAuth2AuthenticatedPrincipal principal = new CustomOAuth2Principal(claims, authorities);
    

    3. 构造完整的 BearerTokenAuthentication

    现在使用上面构造好的 principal(用户信息)、credentials(OAuth2AccessToken)以及 authorities(用户权限列表)来完成 BearerTokenAuthentication 的实例化:

    import org.springframework.security.oauth2.server.resource.authentication.BearerTokenAuthentication;
    
    // 假设 Jwt 已经解析
    Jwt jwt = ...;
    
    // 1. 构造 credentials (OAuth2AccessToken)
    OAuth2AccessToken credentials = createOAuth2AccessToken(jwt.getTokenValue());
    
    // 2. 构造 principal (OAuth2AuthenticatedPrincipal)
    OAuth2AuthenticatedPrincipal principal = new CustomOAuth2Principal(jwt.getClaims(), authorities);
    
    // 3. 构造 authorities (Collection<GrantedAuthority>)
    Collection<GrantedAuthority> authorities = new JwtGrantedAuthoritiesConverter().convert(jwt);
    
    // 4. 构造 BearerTokenAuthentication
    BearerTokenAuthentication authentication = new BearerTokenAuthentication(principal, credentials, authorities);
    

    上述代码将返回一个 BearerTokenAuthentication 对象,其内部封装了用户的认证(principal)、访问令牌(credentials)和权限列表。


    4. 将自定义 BearerTokenAuthentication 集成到 Spring Security

    修改 ReactiveJwtAuthenticationConverter 实现,返回构造好的 BearerTokenAuthentication:

    import org.springframework.core.convert.converter.Converter;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.oauth2.jwt.Jwt;
    import reactor.core.publisher.Mono;
    
    public class CustomReactiveJwtAuthenticationConverter
            implements Converter<Jwt, Mono<AbstractAuthenticationToken>> {
    
        @Override
        public Mono<AbstractAuthenticationToken> convert(Jwt jwt) {
            // 1. 构造 credentials
            OAuth2AccessToken credentials = createOAuth2AccessToken(jwt.getTokenValue());
    
            // 2. 构造 authorities
            Collection<GrantedAuthority> authorities = new JwtGrantedAuthoritiesConverter().convert(jwt);
    
            // 3. 构造 principal
            OAuth2AuthenticatedPrincipal principal = new CustomOAuth2Principal(jwt.getClaims(), authorities);
    
            // 4. 返回封装的 BearerTokenAuthentication
            return Mono.just(new BearerTokenAuthentication(principal, credentials, authorities));
        }
    }
    

    5. 整体集成到 SecurityConfig 中

    将自定义的 Converter<Jwt, Mono<AbstractAuthenticationToken>> 集成到 Spring Security 流程:

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.web.server.SecurityWebFilterChain;
    import reactor.core.publisher.Mono;
    
    @Configuration
    @EnableWebFluxSecurity
    public class SecurityConfig {
    
        @Bean
        public Converter<Jwt, Mono<AbstractAuthenticationToken>> jwtAuthenticationConverter() {
            return new CustomReactiveJwtAuthenticationConverter();
        }
    
        @Bean
        public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
            http
                .authorizeExchange(exchange -> exchange
                    .anyExchange().authenticated()
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthenticationConverter()))
                )
                .csrf(csrf -> csrf.disable()); // 根据需要禁用 CSRF
            return http.build();
        }
    }
    

    总结

    1. 必须构造正确的 BearerTokenAuthentication,包括:

      • principal(用户身份):需要封装为 OAuth2AuthenticatedPrincipal。
      • credentials(认证凭据):需要封装为 OAuth2AccessToken,而不是直接使用 Token 字符串。
      • 权限(authorities):从 JWT 中解析用户权限。
    2. 使用自定义的 Converter<Jwt, Mono<AbstractAuthenticationToken>> 进行响应式解析。

    3. 集成完成后,JWT 中的用户身份信息将全集成到 Spring Security 上下文中,同时可以存储到 Redis(如果启用 Redis 会话支持)。

    希望这些内容能够完全解决您的问题!如果还有进一步的问题,欢迎随时提问! 😊

  17. User

    你还记得我想让你做什么吗

  18. Assistant

    您希望实现以下目标:

    最终目标:

    在一个基于 Spring Boot 3.x 和 Spring Security 的 WebFlux 项目中:

    1. **使用 Redis 作为会话存储(启用了 spring-session-data-redis),**并且:
    2. 通过 Spring Security 集成 Keycloak(OAuth2 / OIDC),解析 JWT,验证用户身份;
    3. 将解析后的 用户信息自动存入 Redis(Spring Session),以便下游服务可以通过会话(或直接访问 Redis)来获取用户的身份信息,而无需在每个服务中重复解析 Token。
    4. 同时,减少手动编写复杂代码(例如:不需要自己操作 RedisTemplate,尽量让 Spring 自动化处理用户信息的存储)。

    主要挑战:

    1. Spring Security 支持 OIDC 和 JWT 的解析,但默认只存储认证后的 Authentication 对象到 Security 上下文,而未直接与 Spring Session 中的 Redis 存储绑定。
    2. Redis 中的会话缓存需要通过启用 spring-session-data-redis 与 Security 框架结合。
    3. WebFlux 环境中 JWT 的解析和用户上下文的处理需要适配 响应式编程模型 (比如使用 Mono 和 Flux),而不是传统的 Servlet 模式。

    您提到的额外问题,是关于 BearerTokenAuthentication 构造问题,这提示在实际开发中,您确实需要让 Spring Security 正常处理用户身份 (principal) 和凭据 (credentials),但您希望最终实现的核心目标仍然是:让用户信息自动保存在 Redis(通过 Spring Session)。


    实现方案

    以下是解决您需求的完整实现步骤,逐步说明如何实现 JWT 解析后的用户信息自动存入 Redis,从而供下游服务使用。


    1. 依赖和配置

    依赖项目需要以下库:

    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-security</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-oauth2-resource-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
    

    2. 配置 Redis 和 Spring Session

    在 application.yml 中启用 Redis 和 Spring Session:

    spring:
      session:
        store-type: redis  # 使用 Redis 保存会话
        redis:
          flush-mode: immediate  # 立即刷入 Redis
      redis:
        host: localhost # Redis 地址
        port: 6379      # Redis 端口
    
    security:
      oauth2:
        resourceserver:
          jwt:
            issuer-uri: http://<keycloak-host>/realms/<realm-name> # 替换为 Keycloak 的 Issuer 地址
    

    此配置将 Redis 作为 Spring Session 的存储设施,并且会将会话中的认证数据存入 Redis。


    3. 配置 Spring Security

    关键配置在于 JWT 的解析与转换,需要确保:

    1. Spring Security 能从 JWT 中解析用户信息(用户声明、权限等)。
    2. 自动将解析结果存入 SecurityContext,并通过 Spring Session 存储到 Redis。

    Spring Security 配置:

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    import org.springframework.security.oauth2.server.resource.authentication.ReactiveJwtAuthenticationConverterAdapter;
    import org.springframework.security.web.server.SecurityWebFilterChain;
    
    @Configuration
    @EnableWebFluxSecurity
    public class SecurityConfig {
    
        @Bean
        public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http) {
            http
                .authorizeExchange(exchange -> exchange
                    .anyExchange().authenticated()  // 所有请求需要认证
                )
                .oauth2ResourceServer(oauth2 -> oauth2
                    .jwt(jwt -> jwt.jwtAuthenticationConverter(jwtAuthenticationConverter()))  // 使用自定义 JWT 转换器
                )
                .csrf(ServerHttpSecurity.CsrfSpec::disable); // 根据需要禁用 CSRF
            return http.build();
        }
    
        @Bean
        public ReactiveJwtAuthenticationConverterAdapter jwtAuthenticationConverter() {
            // 配置权限转换(从 JWT 中提取权限)
            JwtGrantedAuthoritiesConverter grantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
            grantedAuthoritiesConverter.setAuthorityPrefix("ROLE_");
            grantedAuthoritiesConverter.setAuthoritiesClaimName("realm_access.roles");  // Keycloak 默认在此字段存储角色
    
            // 自定义的 Converter,将 JWT 转换为 Authentication 对象
            CustomReactiveJwtAuthenticationConverter converter = new CustomReactiveJwtAuthenticationConverter();
            converter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter);
    
            return new ReactiveJwtAuthenticationConverterAdapter(converter);
        }
    }
    

    在这个配置中:

    • ReactiveJwtAuthenticationConverterAdapter 是响应式版本的 JwtAuthenticationConverter。
    • JwtGrantedAuthoritiesConverter 从 JWT 中提取权限(如 roles)。

    自定义 JWT 转换器

    自定义 Converter<Jwt, ? extends AbstractAuthenticationToken>,确保从 JWT 中解析用户信息,并返回 BearerTokenAuthentication:

    import org.springframework.core.convert.converter.Converter;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.server.resource.authentication.BearerTokenAuthentication;
    import org.springframework.security.oauth2.server.resource.authentication.JwtAuthenticationConverter;
    import org.springframework.security.oauth2.server.resource.authentication.JwtGrantedAuthoritiesConverter;
    
    import java.util.Collection;
    
    /**
     * 自定义 JWT 转换器,生成 Authentication 对象
     */
    public class CustomReactiveJwtAuthenticationConverter extends JwtAuthenticationConverter {
    
        private final JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
    
        @Override
        protected AbstractAuthenticationToken convert(Jwt jwt) {
            Collection<?> authorities = jwtGrantedAuthoritiesConverter.convert(jwt);
    
            // 构造 Authentication 对象
            return new BearerTokenAuthentication(jwt, jwt.getTokenValue(), authorities);
        }
    }
    

    4. 验证用户信息是否存储到 Redis

    Spring Security 会自动将 SecurityContext 存储到 Redis 会话中(通过 spring-session-data-redis 配置)。您可以通过以下方式查看存储的用户数据:

    1. 启动服务后,访问需要认证的 API。例如使用 curl:

      curl -H "Authorization: Bearer <access_token>" http://localhost:8080/api/some-endpoint
      
    2. 在 Redis CLI 中检查会话:

      redis-cli
      keys *
      get spring:session:sessions:<SESSION_ID>
      

      这里的 <SESSION_ID> 是会话的唯一 ID,您会看到类似如下内容:

      {
          "SPRING_SECURITY_CONTEXT": {
              "authentication": {
                  "principal": {
                      "preferred_username": "user@example.com",
                      "roles": ["ROLE_USER"]
                  },
                  "authorities": ["ROLE_USER"]
              }
          }
      }
      

    5. 让下游服务获取用户信息

    在 Redis 中的用户信息会通过会话存储,供其他下游服务访问。以下是两种实现方案:

    方案 1:直接从会话中读取用户信息

    在下游服务中,使用 Spring Security 自动注入 Authentication 或 SecurityContext:

    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    import java.util.Map;
    
    @RestController
    public class UserController {
    
        @GetMapping("/me")
        public Map<String, Object> getCurrentUser() {
            Authentication authentication = SecurityContextHolder.getContext().getAuthentication();
            return Map.of(
                "username", authentication.getName(),
                "roles", authentication.getAuthorities()
            );
        }
    }
    

    方案 2:通过 Redis 手动查询会话

    如果下游服务是独立的(未共享 Security 上下文),可以直接从 Redis 查询用户信息:

    import org.springframework.beans.factory.annotation.Autowired;
    import org.springframework.data.redis.core.RedisTemplate;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    
    @RestController
    public class UserController {
    
        @Autowired
        private RedisTemplate<String, Object> redisTemplate;
    
        @GetMapping("/session")
        public Object getSessionData(String sessionId) {
            return redisTemplate.opsForValue().get("spring:session:sessions:" + sessionId);
        }
    }
    

    总结

    1. Redis 自动存储用户信息:

      • JWT 被解析为 Authentication 对象。
      • Spring Session 自动将 Authentication 和用户信息存储到 Redis。
    2. 减少手动编写代码:

      • Redis 存储通过 Spring 提供的 spring-session-data-redis 自动完成。
      • 安全上下文管理由 Spring Security 负责。
    3. 优先使用 Spring Security 上下文:

      • 后续服务可以直接使用 SecurityContextHolder 获取用户身份,而无需手动查询 Redis。

    如果还有其他需求,请继续告诉我! 😊

  19. User

    @Bean public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http, CorsConfigurationSource configurationSource) { http .cors(corsSpec -> corsSpec.configurationSource(configurationSource)) .csrf(ServerHttpSecurity.CsrfSpec::disable) .authorizeExchange(authorize -> { permits.forEach(permit -> authorize.pathMatchers(permit).permitAll()); authorize.anyExchange().authenticated(); }) .oauth2ResourceServer(oauth2 -> oauth2.jwt( jwtSpec -> jwtSpec.jwtAuthenticationConverter(jwtAuthenticationConverter()))) .sessionManagement(managementSpec -> managementSpec.concurrentSessions( concurrentSessionsSpec -> concurrentSessionsSpec.maximumSessions(SessionLimit.of(1))));

        return http.build();
    }
    
    @Bean
    public ReactiveJwtAuthenticationConverterAdapter jwtAuthenticationConverter() {
        JwtGrantedAuthoritiesConverter grantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
        grantedAuthoritiesConverter.setAuthorityPrefix("ROLE_");
        grantedAuthoritiesConverter.setAuthoritiesClaimName("realm_access.roles");
    
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter);
    
        return new ReactiveJwtAuthenticationConverterAdapter(converter);
    }
    

    这样可以吗

  20. Assistant

    从您的代码来看,基本实现了大部分功能,但有一些关键点需要调整或优化才能完全满足您的需求。以下是对代码的详细分析和需要调整的地方,以确保能够完全实现您的目标:


    代码分析与问题

    1. jwtAuthenticationConverter() 的类型问题:

      • 您的 ReactiveJwtAuthenticationConverterAdapter 是基于响应式的 ReactiveJwtAuthenticationConverter 封装的适配器,而它封装了非反应式的 JwtAuthenticationConverter。
      • 问题: Spring WebFlux 的安全模式要求 JWT 转换器返回 Mono<AbstractAuthenticationToken>,而 JwtAuthenticationConverter 是同步的,直接使用可能会导致类型不匹配并在运行时报错。
    2. sessionManagement 使用会话并发管理:

      • WebFlux 中的 ServerHttpSecurity.SessionManagementSpec 支持会话管理,但 concurrentSessions 是用在传统 Servlet 安全模型中,WebFlux 的会话模型并不支持这种配置方式。
      • 问题: managementSpec.concurrentSessions(...) 会导致 运行时异常,因为 WebFlux 和 Servlet 是不同的模型,并发会话管理不是 WebFlux 的原生机制。
    3. Redis存储用户会话:

      • Redis 会话存储的前提是启用了 spring-session-data-redis,而 Redis 存储的 OAuth2AuthenticationToken 用户会话依赖于会话的正确配置。
      • 从您的代码上看,并没有特别为 ReactiveSecurityContext 和 Redis 的集成做定制(不过 Spring 的自动化支持大部分场景)。

    针对上述问题的调整与优化

    1. 自定义一个完全支持响应式的 JWT 转换器

    由于 ReactiveJwtAuthenticationConverterAdapter 需要一个返回 Mono<AbstractAuthenticationToken> 的 Converter<Jwt, Mono<AbstractAuthenticationToken>>,我们应当实现一个纯响应式的转化器,而不是直接适配同步的 JwtAuthenticationConverter。

    实现方式如下:

    import org.springframework.core.convert.converter.Converter;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.core.GrantedAuthority;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.server.resource.authentication.BearerTokenAuthentication;
    import reactor.core.publisher.Mono;
    
    import java.util.Collection;
    
    /**
     * 自定义响应式 JWT 转换器
     */
    public class ReactiveJwtAuthenticationConverter implements Converter<Jwt, Mono<AbstractAuthenticationToken>> {
    
        private final JwtGrantedAuthoritiesConverter jwtGrantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
    
        public ReactiveJwtAuthenticationConverter() {
            // 自定义解析 roles 的字段,比如 Keycloak 的 "realm_access.roles"
            jwtGrantedAuthoritiesConverter.setAuthorityPrefix("ROLE_");
            jwtGrantedAuthoritiesConverter.setAuthoritiesClaimName("realm_access.roles");
        }
    
        @Override
        public Mono<AbstractAuthenticationToken> convert(Jwt jwt) {
            // 1. 提取 JWT 中的权限
            Collection<GrantedAuthority> grantedAuthorities = jwtGrantedAuthoritiesConverter.convert(jwt);
    
            // 2. 创建 Authentication 对象 (BearerTokenAuthentication)
            AbstractAuthenticationToken authenticationToken = new BearerTokenAuthentication(jwt, jwt.getTokenValue(), grantedAuthorities);
    
            return Mono.just(authenticationToken);
        }
    }
    
    替换 jwtAuthenticationConverter 的 Bean 配置:
    @Bean
    public Converter<Jwt, Mono<AbstractAuthenticationToken>> jwtAuthenticationConverter() {
        return new ReactiveJwtAuthenticationConverter();
    }
    

    2. WebFlux 的会话管理调整

    WebFlux 的安全模型不支持传统的基于 concurrentSessions (...) 方式的并发会话限制,这是因为 WebFlux 是响应式和无状态的设计,通常直接依赖于 JWT 的无状态认证方式。

    如果您确实需要某种形式的会话管理支持(例如存储于 Redis),可以使用以下方式来调整:
    • 在 WebFlux 中会话的代替方案(例如 Redis 的会话共享): WebFlux 本身是无状态的,建议通过 JWT 本身 实现用户的认证授权,而无需传统的会话管理。如果确实需要仅允许单个会话有效(比如只允许单一客户端登录),可以在登录时实现 Token 刷新机制(让旧 Token 作废),从根本上防止多会话问题。
    删除以下部分:
    .sessionManagement(managementSpec -> managementSpec.concurrentSessions(
            concurrentSessionsSpec -> concurrentSessionsSpec.maximumSessions(SessionLimit.of(1))));
    

    这个部分是 无效的,因为 WebFlux 的 SessionManagementSpec 不支持 concurrentSessions 的配置。


    3. 完整调整后的代码

    调整后的完整代码如下,其中:

    1. 解决了 ReactiveJwtAuthenticationConverterAdapter 与 WebFlux 下 Mono 类型的问题。
    2. 移除了不支持的 sessionManagement 部分。
    3. 使用无状态的 JWT + Redis 整合。
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.core.convert.converter.Converter;
    import org.springframework.security.authentication.AbstractAuthenticationToken;
    import org.springframework.security.config.annotation.web.reactive.EnableWebFluxSecurity;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.web.server.SecurityWebFilterChain;
    import org.springframework.web.cors.reactive.CorsConfigurationSource;
    import reactor.core.publisher.Mono;
    
    @Configuration
    @EnableWebFluxSecurity
    public class SecurityConfig {
    
        @Bean
        public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http, CorsConfigurationSource configurationSource) {
            http
                .cors(corsSpec -> corsSpec.configurationSource(configurationSource))
                .csrf(ServerHttpSecurity.CsrfSpec::disable)
                .authorizeExchange(authorize -> {
                    permits.forEach(permit -> authorize.pathMatchers(permit).permitAll());
                    authorize.anyExchange().authenticated();
                })
                .oauth2ResourceServer(oauth2 -> oauth2.jwt(
                        jwtSpec -> jwtSpec.jwtAuthenticationConverter(jwtAuthenticationConverter())));
    
            return http.build();
        }
    
        @Bean
        public Converter<Jwt, Mono<AbstractAuthenticationToken>> jwtAuthenticationConverter() {
            // 使用自定义的响应式 JWT 转换器
            return new ReactiveJwtAuthenticationConverter();
        }
    }
    
    关键调整说明:
    • JwtAuthenticationConverter 被替换为了带响应式支持的 ReactiveJwtAuthenticationConverter(返回类型为 Mono<AbstractAuthenticationToken>)。
    • 移除了无效的 sessionManagement 配置。
    • 使用 Redis + JWT 的无状态模式为基础架构,避免增加额外复杂性。

    如何验证功能是否符合预期?

    1. 自动 Redis 存储用户上下文验证

    • 启用 spring-session-data-redis 后,只要用户登录会话信息被存储,Redis 的数据中会显示 spring:session:sessions:<sessionId> 键。
    • 使用以下命令检查 Redis 是否存储了会话信息:
      redis-cli keys "spring:session:sessions:*"
      redis-cli get spring:session:sessions:<sessionId>
      
    • 检查存储的内容中是否包含:
      • principal: 用户的身份信息。
      • authorities: 解析自 JWT 的角色与权限信息。

    2. 访问受保护 API 进行验证

    • 使用 curl 或 HTTP 客户端发送带有 Bearer <token> 的认证请求:
      curl -H "Authorization: Bearer <token>" http://localhost:8080/protected-resource
      
    • 预期结果:
      • 如果 Token 有效并包含正确的角色/权限信息,服务器会返回正确的响应。
      • 如果 Token 无效,返回 401 Unauthorized。

    3. 前端整合测试

    • 如果前端与后端整合,通过 Keycloak 获取 JWT Token 后,带上 Authorization: Bearer <token> 请求,可以验证整个认证流程是否正常。

    总结

    您的目标是让用户认证信息通过 JWT 和 Spring Security 自动处理,并通过 Redis 存储用户会话(如果需要)。以下为关键点总结:

    1. JWT 解析与 WebFlux 适配:
      • 必须使用 ReactiveJwtAuthenticationConverter,而不能直接使用同步的 JwtAuthenticationConverter。
    2. WebFlux 的无状态认证机制:
      • 不支持传统 concurrentSessions 设置,推荐使用无状态的 JWT 和 Redis。
    3. Redis 数据验证:
      • 配置 spring-session-data-redis 后,自动存储用户会话信息,无需额外操作。

    希望这一更新的解决方案完全满足您的需求!如果还有进一步问题,欢迎继续提问! 😊

  21. User

    2025-01-04 21:00:44.645 [Capitals-Cloud-Gateway | | ] DEBUG 4836 --- [ctor-http-nio-7] [o.s.s.oauth2.jwt.JwtClaimValidator :68 ]: The iss claim is not valid 2025-01-04 21:00:44.646 [Capitals-Cloud-Gateway | | ] DEBUG 4836 --- [ctor-http-nio-7] [o.s.s.w.s.a.AuthenticationWebFilter :128 ]: Authentication failed: The iss claim is not valid

    org.springframework.security.oauth2.server.resource.InvalidBearerTokenException: The iss claim is not valid at org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager.onError(JwtReactiveAuthenticationManager.java:79) Suppressed: reactor.core.publisher.FluxOnAssembly$OnAssemblyException: Assembly trace from producer [reactor.core.publisher.MonoError] :

    Error has been observed at the following site(s): *_____Mono.onErrorMap ⇢ at org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager.authenticate(JwtReactiveAuthenticationManager.java:62) *______Mono.flatMap ⇢ at org.springframework.security.web.server.authentication.AuthenticationWebFilter.authenticate(AuthenticationWebFilter.java:122) | Mono.switchIfEmpty ⇢ at org.springframework.security.web.server.authentication.AuthenticationWebFilter.authenticate(AuthenticationWebFilter.java:123) | Mono.flatMap ⇢ at org.springframework.security.web.server.authentication.AuthenticationWebFilter.authenticate(AuthenticationWebFilter.java:125) Original Stack Trace: at org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager.onError(JwtReactiveAuthenticationManager.java:79) at reactor.core.publisher.Mono.lambdaonErrorMaponErrorMap28(Mono.java:3848) at reactor.core.publisher.Mono.lambdaonErrorResumeonErrorResume30(Mono.java:3938) at reactor.core.publisher.FluxOnErrorResumeResumeSubscriber.onError(FluxOnErrorResume.java:94)atreactor.core.publisher.FluxMapFuseableResumeSubscriber.onError(FluxOnErrorResume.java:94) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onError(FluxMapFuseable.java:142) at reactor.core.publisher.MonoFlatMapFlatMapMain.onError(MonoFlatMap.java:180)atreactor.core.publisher.MonoFlatMapFlatMapMain.onError(MonoFlatMap.java:180) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondError(MonoFlatMap.java:241) at reactor.core.publisher.MonoFlatMapFlatMapInner.onError(MonoFlatMap.java:315)atreactor.core.publisher.FluxOnErrorResumeFlatMapInner.onError(MonoFlatMap.java:315) at reactor.core.publisher.FluxOnErrorResumeResumeSubscriber.onError(FluxOnErrorResume.java:106) at reactor.core.publisher.Operators.error(Operators.java:198) at reactor.core.publisher.MonoError.subscribe(MonoError.java:53) at reactor.core.publisher.Mono.subscribe(Mono.java:4576) at reactor.core.publisher.FluxOnErrorResumeResumeSubscriber.onError(FluxOnErrorResume.java:103)atreactor.core.publisher.FluxMapFuseableResumeSubscriber.onError(FluxOnErrorResume.java:103) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onError(FluxMapFuseable.java:142) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:121)atreactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:121) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245)atreactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129)atreactor.core.publisher.FluxOnErrorResumeMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.FluxOnErrorResumeResumeSubscriber.onNext(FluxOnErrorResume.java:79) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74)atreactor.core.publisher.MonoFlatMapSwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305)atreactor.core.publisher.OperatorsFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.MonoFlatMapFlatMapInner.onSubscribe(MonoFlatMap.java:291)atreactor.core.publisher.MonoJust.subscribe(MonoJust.java:55)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoFlatMapFlatMapInner.onSubscribe(MonoFlatMap.java:291) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74)atreactor.core.publisher.OperatorsSwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367)atreactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.onSubscribe(Operators.java:2241) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165)atreactor.core.publisher.OperatorsFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.OperatorsMonoSubscriber.complete(Operators.java:1865) at reactor.core.publisher.MonoCacheTime.subscribeOrReturn(MonoCacheTime.java:151) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:63) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165)atreactor.core.publisher.FluxMapFuseableFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129)atreactor.core.publisher.FluxFilterMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.FluxFilterFilterSubscriber.onNext(FluxFilter.java:113) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571)atreactor.core.publisher.FluxFilterScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.FluxFilterFilterSubscriber.request(FluxFilter.java:186) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.request(FluxMapFuseable.java:171)atreactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.request(FluxMapFuseable.java:171) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.request(FluxMapFuseable.java:171) at reactor.core.publisher.MonoFlatMapFlatMapMain.request(MonoFlatMap.java:194)atreactor.core.publisher.MonoFlatMapFlatMapMain.request(MonoFlatMap.java:194) at reactor.core.publisher.MonoFlatMapFlatMapMain.request(MonoFlatMap.java:194) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.request(FluxMapFuseable.java:171)atreactor.core.publisher.OperatorsMapFuseableSubscriber.request(FluxMapFuseable.java:171) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367) at reactor.core.publisher.FluxOnErrorResumeResumeSubscriber.onSubscribe(FluxOnErrorResume.java:74)atreactor.core.publisher.FluxMapFuseableResumeSubscriber.onSubscribe(FluxOnErrorResume.java:74) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96) at reactor.core.publisher.MonoFlatMapFlatMapMain.onSubscribe(MonoFlatMap.java:117)atreactor.core.publisher.MonoFlatMapFlatMapMain.onSubscribe(MonoFlatMap.java:117) at reactor.core.publisher.MonoFlatMapFlatMapMain.onSubscribe(MonoFlatMap.java:117) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96)atreactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96) at reactor.core.publisher.FluxFilterFilterSubscriber.onSubscribe(FluxFilter.java:85)atreactor.core.publisher.MonoJust.subscribe(MonoJust.java:55)atreactor.core.publisher.Mono.subscribe(Mono.java:4576)atreactor.core.publisher.FluxFlatMap.trySubscribeScalarMap(FluxFlatMap.java:202)atreactor.core.publisher.MonoFlatMap.subscribeOrReturn(MonoFlatMap.java:53)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:63)atreactor.core.publisher.MonoFlatMapFilterSubscriber.onSubscribe(FluxFilter.java:85) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.Mono.subscribe(Mono.java:4576) at reactor.core.publisher.FluxFlatMap.trySubscribeScalarMap(FluxFlatMap.java:202) at reactor.core.publisher.MonoFlatMap.subscribeOrReturn(MonoFlatMap.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:63) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74)atreactor.core.publisher.MonoFlatMapSwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305)atreactor.core.publisher.FluxMapFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.FluxMapMapSubscriber.onNext(FluxMap.java:122) at reactor.core.publisher.MonoCallableMonoCallableSubscription.request(MonoCallable.java:156)atreactor.core.publisher.FluxMapMonoCallableSubscription.request(MonoCallable.java:156) at reactor.core.publisher.FluxMapMapSubscriber.request(FluxMap.java:164) at reactor.core.publisher.MonoFlatMapFlatMapInner.onSubscribe(MonoFlatMap.java:291)atreactor.core.publisher.FluxMapFlatMapInner.onSubscribe(MonoFlatMap.java:291) at reactor.core.publisher.FluxMapMapSubscriber.onSubscribe(FluxMap.java:92) at reactor.core.publisher.MonoCallable.subscribe(MonoCallable.java:48) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165)atreactor.core.publisher.FluxFilterFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxFilterFilterSubscriber.onNext(FluxFilter.java:113) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571)atreactor.core.publisher.FluxFilterScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.FluxFilterFilterSubscriber.request(FluxFilter.java:186) at reactor.core.publisher.MonoFlatMapFlatMapMain.request(MonoFlatMap.java:194)atreactor.core.publisher.OperatorsFlatMapMain.request(MonoFlatMap.java:194) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.onSubscribe(Operators.java:2241)atreactor.core.publisher.MonoFlatMapMultiSubscriptionSubscriber.onSubscribe(Operators.java:2241) at reactor.core.publisher.MonoFlatMapFlatMapMain.onSubscribe(MonoFlatMap.java:117) at reactor.core.publisher.FluxFilterFilterSubscriber.onSubscribe(FluxFilter.java:85)atreactor.core.publisher.MonoJust.subscribe(MonoJust.java:55)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDeferContextual.subscribe(MonoDeferContextual.java:55)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoFlatMapFilterSubscriber.onSubscribe(FluxFilter.java:85) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDeferContextual.subscribe(MonoDeferContextual.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129)atreactor.core.publisher.MonoFlatMapMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305)atreactor.core.publisher.OperatorsFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.OperatorsBaseFluxToMonoOperator.completePossiblyEmpty(Operators.java:2097) at reactor.core.publisher.MonoCollectListMonoCollectListSubscriber.onComplete(MonoCollectList.java:118)atreactor.core.publisher.FluxIterableMonoCollectListSubscriber.onComplete(MonoCollectList.java:118) at reactor.core.publisher.FluxIterableIterableSubscription.fastPath(FluxIterable.java:424) at reactor.core.publisher.FluxIterableIterableSubscription.request(FluxIterable.java:291)atreactor.core.publisher.OperatorsIterableSubscription.request(FluxIterable.java:291) at reactor.core.publisher.OperatorsBaseFluxToMonoOperator.request(Operators.java:2067) at reactor.core.publisher.MonoFlatMapFlatMapInner.onSubscribe(MonoFlatMap.java:291)atreactor.core.publisher.OperatorsFlatMapInner.onSubscribe(MonoFlatMap.java:291) at reactor.core.publisher.OperatorsBaseFluxToMonoOperator.onSubscribe(Operators.java:2051) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:201) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:83) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165)atreactor.core.publisher.FluxSwitchIfEmptyFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.MonoNextNextSubscriber.onNext(MonoNext.java:82)atreactor.core.publisher.FluxFilterWhenNextSubscriber.onNext(MonoNext.java:82) at reactor.core.publisher.FluxFilterWhenFluxFilterWhenSubscriber.drain(FluxFilterWhen.java:302) at reactor.core.publisher.FluxFilterWhenFluxFilterWhenSubscriber.onNext(FluxFilterWhen.java:140)atreactor.core.publisher.FluxIterableFluxFilterWhenSubscriber.onNext(FluxFilterWhen.java:140) at reactor.core.publisher.FluxIterableIterableSubscription.slowPath(FluxIterable.java:335) at reactor.core.publisher.FluxIterableIterableSubscription.request(FluxIterable.java:294)atreactor.core.publisher.FluxFilterWhenIterableSubscription.request(FluxIterable.java:294) at reactor.core.publisher.FluxFilterWhenFluxFilterWhenSubscriber.onSubscribe(FluxFilterWhen.java:200) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:201) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:83) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.Mono.subscribe(Mono.java:4576) at reactor.core.publisher.MonoIgnoreThenThenIgnoreMain.subscribeNext(MonoIgnoreThen.java:265)atreactor.core.publisher.MonoIgnoreThen.subscribe(MonoIgnoreThen.java:51)atreactor.core.publisher.Mono.subscribe(Mono.java:4576)atreactor.core.publisher.MonoIgnoreThenThenIgnoreMain.subscribeNext(MonoIgnoreThen.java:265) at reactor.core.publisher.MonoIgnoreThen.subscribe(MonoIgnoreThen.java:51) at reactor.core.publisher.Mono.subscribe(Mono.java:4576) at reactor.core.publisher.MonoIgnoreThenThenIgnoreMain.subscribeNext(MonoIgnoreThen.java:265) at reactor.core.publisher.MonoIgnoreThen.subscribe(MonoIgnoreThen.java:51) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDeferContextual.subscribe(MonoDeferContextual.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.netty.http.server.HttpServerHttpServerHandle.onStateChange(HttpServer.java:1176)atreactor.netty.ReactorNettyHttpServerHandle.onStateChange(HttpServer.java:1176) at reactor.netty.ReactorNettyCompositeConnectionObserver.onStateChange(ReactorNetty.java:715) at reactor.netty.transport.ServerTransportChildObserver.onStateChange(ServerTransport.java:481)atreactor.netty.http.server.HttpServerOperations.handleDefaultHttpRequest(HttpServerOperations.java:829)atreactor.netty.http.server.HttpServerOperations.onInboundNext(HttpServerOperations.java:774)atreactor.netty.channel.ChannelOperationsHandler.channelRead(ChannelOperationsHandler.java:115)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:444)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420)atio.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412)atreactor.netty.http.server.HttpTrafficHandler.channelRead(HttpTrafficHandler.java:262)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:442)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420)atio.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412)atio.netty.channel.CombinedChannelDuplexHandlerChildObserver.onStateChange(ServerTransport.java:481) at reactor.netty.http.server.HttpServerOperations.handleDefaultHttpRequest(HttpServerOperations.java:829) at reactor.netty.http.server.HttpServerOperations.onInboundNext(HttpServerOperations.java:774) at reactor.netty.channel.ChannelOperationsHandler.channelRead(ChannelOperationsHandler.java:115) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:444) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412) at reactor.netty.http.server.HttpTrafficHandler.channelRead(HttpTrafficHandler.java:262) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:442) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412) at io.netty.channel.CombinedChannelDuplexHandlerDelegatingChannelHandlerContext.fireChannelRead(CombinedChannelDuplexHandler.java:436) at io.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:346) at io.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:333) at io.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:455) at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:290) at io.netty.channel.CombinedChannelDuplexHandler.channelRead(CombinedChannelDuplexHandler.java:251) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:442) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412) at io.netty.channel.DefaultChannelPipelineHeadContext.channelRead(DefaultChannelPipeline.java:1407)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:440)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420)atio.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:918)atio.netty.channel.nio.AbstractNioByteChannelHeadContext.channelRead(DefaultChannelPipeline.java:1407) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:440) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:918) at io.netty.channel.nio.AbstractNioByteChannelNioByteUnsafe.read(AbstractNioByteChannel.java:166) at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:788) at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:724) at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:650) at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:562) at io.netty.util.concurrent.SingleThreadEventExecutor4.run(SingleThreadEventExecutor.java:994)atio.netty.util.internal.ThreadExecutorMap4.run(SingleThreadEventExecutor.java:994) at io.netty.util.internal.ThreadExecutorMap2.run(ThreadExecutorMap.java:74) at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30) at java.base/java.lang.Thread.run(Thread.java:1583) Caused by: org.springframework.security.oauth2.jwt.JwtValidationException: The iss claim is not valid at org.springframework.security.oauth2.jwt.NimbusReactiveJwtDecoder.validateJwt(NimbusReactiveJwtDecoder.java:198) Suppressed: reactor.core.publisher.FluxOnAssemblyOnAssemblyException: Assembly trace from producer [reactor.core.publisher.MonoMapFuseable] : reactor.core.publisher.Mono.map(Mono.java:3490) org.springframework.security.oauth2.jwt.NimbusReactiveJwtDecoder.decode(NimbusReactiveJwtDecoder.java:166) Error has been observed at the following site(s): *_________Mono.map ⇢ at org.springframework.security.oauth2.jwt.NimbusReactiveJwtDecoder.decode(NimbusReactiveJwtDecoder.java:166) |_ Mono.onErrorMap ⇢ at org.springframework.security.oauth2.jwt.NimbusReactiveJwtDecoder.decode(NimbusReactiveJwtDecoder.java:167) *_____Mono.flatMap ⇢ at org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager.authenticate(JwtReactiveAuthenticationManager.java:59) |_ Mono.flatMap ⇢ at org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager.authenticate(JwtReactiveAuthenticationManager.java:60) |_ Mono.cast ⇢ at org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager.authenticate(JwtReactiveAuthenticationManager.java:61) Original Stack Trace: at org.springframework.security.oauth2.jwt.NimbusReactiveJwtDecoder.validateJwt(NimbusReactiveJwtDecoder.java:198) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:113) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129)atreactor.core.publisher.MonoFlatMapMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305)atreactor.core.publisher.FluxMapFuseableFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.FluxOnErrorResumeResumeSubscriber.onNext(FluxOnErrorResume.java:79)atreactor.core.publisher.FluxSwitchIfEmptyResumeSubscriber.onNext(FluxOnErrorResume.java:79) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245)atreactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571)atreactor.core.publisher.MonoFlatMapScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.MonoFlatMapFlatMapInner.onSubscribe(MonoFlatMap.java:291) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165)atreactor.core.publisher.FluxSwitchIfEmptyFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571)atreactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.onSubscribe(Operators.java:2241)atreactor.core.publisher.MonoJust.subscribe(MonoJust.java:55)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoFlatMapMultiSubscriptionSubscriber.onSubscribe(Operators.java:2241) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.OperatorsMonoSubscriber.complete(Operators.java:1865)atreactor.core.publisher.MonoCacheTime.subscribeOrReturn(MonoCacheTime.java:151)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:63)atreactor.core.publisher.MonoFlatMapMonoSubscriber.complete(Operators.java:1865) at reactor.core.publisher.MonoCacheTime.subscribeOrReturn(MonoCacheTime.java:151) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:63) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129)atreactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.FluxFilterFilterSubscriber.onNext(FluxFilter.java:113)atreactor.core.publisher.OperatorsFilterSubscriber.onNext(FluxFilter.java:113) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.FluxFilterFilterSubscriber.request(FluxFilter.java:186)atreactor.core.publisher.FluxMapFuseableFilterSubscriber.request(FluxFilter.java:186) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.request(FluxMapFuseable.java:171) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.request(FluxMapFuseable.java:171)atreactor.core.publisher.MonoFlatMapMapFuseableSubscriber.request(FluxMapFuseable.java:171) at reactor.core.publisher.MonoFlatMapFlatMapMain.request(MonoFlatMap.java:194) at reactor.core.publisher.MonoFlatMapFlatMapMain.request(MonoFlatMap.java:194)atreactor.core.publisher.FluxMapFuseableFlatMapMain.request(MonoFlatMap.java:194) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.request(FluxMapFuseable.java:171) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367)atreactor.core.publisher.FluxOnErrorResumeMultiSubscriptionSubscriber.set(Operators.java:2367) at reactor.core.publisher.FluxOnErrorResumeResumeSubscriber.onSubscribe(FluxOnErrorResume.java:74) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96)atreactor.core.publisher.MonoFlatMapMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96) at reactor.core.publisher.MonoFlatMapFlatMapMain.onSubscribe(MonoFlatMap.java:117) at reactor.core.publisher.MonoFlatMapFlatMapMain.onSubscribe(MonoFlatMap.java:117)atreactor.core.publisher.FluxMapFuseableFlatMapMain.onSubscribe(MonoFlatMap.java:117) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96)atreactor.core.publisher.FluxFilterMapFuseableSubscriber.onSubscribe(FluxMapFuseable.java:96) at reactor.core.publisher.FluxFilterFilterSubscriber.onSubscribe(FluxFilter.java:85) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.Mono.subscribe(Mono.java:4576) at reactor.core.publisher.FluxFlatMap.trySubscribeScalarMap(FluxFlatMap.java:202) at reactor.core.publisher.MonoFlatMap.subscribeOrReturn(MonoFlatMap.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:63) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165)atreactor.core.publisher.FluxSwitchIfEmptyFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245)atreactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.FluxMapMapSubscriber.onNext(FluxMap.java:122)atreactor.core.publisher.MonoCallableMapSubscriber.onNext(FluxMap.java:122) at reactor.core.publisher.MonoCallableMonoCallableSubscription.request(MonoCallable.java:156) at reactor.core.publisher.FluxMapMapSubscriber.request(FluxMap.java:164)atreactor.core.publisher.MonoFlatMapMapSubscriber.request(FluxMap.java:164) at reactor.core.publisher.MonoFlatMapFlatMapInner.onSubscribe(MonoFlatMap.java:291) at reactor.core.publisher.FluxMapMapSubscriber.onSubscribe(FluxMap.java:92)atreactor.core.publisher.MonoCallable.subscribe(MonoCallable.java:48)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoFlatMapMapSubscriber.onSubscribe(FluxMap.java:92) at reactor.core.publisher.MonoCallable.subscribe(MonoCallable.java:48) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxFilterFilterSubscriber.onNext(FluxFilter.java:113)atreactor.core.publisher.OperatorsFilterSubscriber.onNext(FluxFilter.java:113) at reactor.core.publisher.OperatorsScalarSubscription.request(Operators.java:2571) at reactor.core.publisher.FluxFilterFilterSubscriber.request(FluxFilter.java:186)atreactor.core.publisher.MonoFlatMapFilterSubscriber.request(FluxFilter.java:186) at reactor.core.publisher.MonoFlatMapFlatMapMain.request(MonoFlatMap.java:194) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367)atreactor.core.publisher.OperatorsMultiSubscriptionSubscriber.set(Operators.java:2367) at reactor.core.publisher.OperatorsMultiSubscriptionSubscriber.onSubscribe(Operators.java:2241) at reactor.core.publisher.MonoFlatMapFlatMapMain.onSubscribe(MonoFlatMap.java:117)atreactor.core.publisher.FluxFilterFlatMapMain.onSubscribe(MonoFlatMap.java:117) at reactor.core.publisher.FluxFilterFilterSubscriber.onSubscribe(FluxFilter.java:85) at reactor.core.publisher.MonoJust.subscribe(MonoJust.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDeferContextual.subscribe(MonoDeferContextual.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165)atreactor.core.publisher.FluxMapFuseableFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxMapFuseableMapFuseableSubscriber.onNext(FluxMapFuseable.java:129) at reactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245)atreactor.core.publisher.MonoFlatMapFlatMapMain.secondComplete(MonoFlatMap.java:245) at reactor.core.publisher.MonoFlatMapFlatMapInner.onNext(MonoFlatMap.java:305) at reactor.core.publisher.OperatorsBaseFluxToMonoOperator.completePossiblyEmpty(Operators.java:2097)atreactor.core.publisher.MonoCollectListBaseFluxToMonoOperator.completePossiblyEmpty(Operators.java:2097) at reactor.core.publisher.MonoCollectListMonoCollectListSubscriber.onComplete(MonoCollectList.java:118) at reactor.core.publisher.FluxIterableIterableSubscription.fastPath(FluxIterable.java:424)atreactor.core.publisher.FluxIterableIterableSubscription.fastPath(FluxIterable.java:424) at reactor.core.publisher.FluxIterableIterableSubscription.request(FluxIterable.java:291) at reactor.core.publisher.OperatorsBaseFluxToMonoOperator.request(Operators.java:2067)atreactor.core.publisher.MonoFlatMapBaseFluxToMonoOperator.request(Operators.java:2067) at reactor.core.publisher.MonoFlatMapFlatMapInner.onSubscribe(MonoFlatMap.java:291) at reactor.core.publisher.OperatorsBaseFluxToMonoOperator.onSubscribe(Operators.java:2051)atreactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:201)atreactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:83)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoFlatMapBaseFluxToMonoOperator.onSubscribe(Operators.java:2051) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:201) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:83) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoFlatMapFlatMapMain.onNext(MonoFlatMap.java:165) at reactor.core.publisher.FluxSwitchIfEmptySwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74)atreactor.core.publisher.MonoNextSwitchIfEmptySubscriber.onNext(FluxSwitchIfEmpty.java:74) at reactor.core.publisher.MonoNextNextSubscriber.onNext(MonoNext.java:82) at reactor.core.publisher.FluxFilterWhenFluxFilterWhenSubscriber.drain(FluxFilterWhen.java:302)atreactor.core.publisher.FluxFilterWhenFluxFilterWhenSubscriber.drain(FluxFilterWhen.java:302) at reactor.core.publisher.FluxFilterWhenFluxFilterWhenSubscriber.onNext(FluxFilterWhen.java:140) at reactor.core.publisher.FluxIterableIterableSubscription.slowPath(FluxIterable.java:335)atreactor.core.publisher.FluxIterableIterableSubscription.slowPath(FluxIterable.java:335) at reactor.core.publisher.FluxIterableIterableSubscription.request(FluxIterable.java:294) at reactor.core.publisher.FluxFilterWhenFluxFilterWhenSubscriber.onSubscribe(FluxFilterWhen.java:200)atreactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:201)atreactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:83)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53)atreactor.core.publisher.Mono.subscribe(Mono.java:4576)atreactor.core.publisher.MonoIgnoreThenFluxFilterWhenSubscriber.onSubscribe(FluxFilterWhen.java:200) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:201) at reactor.core.publisher.FluxIterable.subscribe(FluxIterable.java:83) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDefer.subscribe(MonoDefer.java:53) at reactor.core.publisher.Mono.subscribe(Mono.java:4576) at reactor.core.publisher.MonoIgnoreThenThenIgnoreMain.subscribeNext(MonoIgnoreThen.java:265) at reactor.core.publisher.MonoIgnoreThen.subscribe(MonoIgnoreThen.java:51) at reactor.core.publisher.Mono.subscribe(Mono.java:4576) at reactor.core.publisher.MonoIgnoreThenThenIgnoreMain.subscribeNext(MonoIgnoreThen.java:265)atreactor.core.publisher.MonoIgnoreThen.subscribe(MonoIgnoreThen.java:51)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.core.publisher.MonoDeferContextual.subscribe(MonoDeferContextual.java:55)atreactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76)atreactor.netty.http.server.HttpServerThenIgnoreMain.subscribeNext(MonoIgnoreThen.java:265) at reactor.core.publisher.MonoIgnoreThen.subscribe(MonoIgnoreThen.java:51) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.core.publisher.MonoDeferContextual.subscribe(MonoDeferContextual.java:55) at reactor.core.publisher.InternalMonoOperator.subscribe(InternalMonoOperator.java:76) at reactor.netty.http.server.HttpServerHttpServerHandle.onStateChange(HttpServer.java:1176) at reactor.netty.ReactorNettyCompositeConnectionObserver.onStateChange(ReactorNetty.java:715)atreactor.netty.transport.ServerTransportCompositeConnectionObserver.onStateChange(ReactorNetty.java:715) at reactor.netty.transport.ServerTransportChildObserver.onStateChange(ServerTransport.java:481) at reactor.netty.http.server.HttpServerOperations.handleDefaultHttpRequest(HttpServerOperations.java:829) at reactor.netty.http.server.HttpServerOperations.onInboundNext(HttpServerOperations.java:774) at reactor.netty.channel.ChannelOperationsHandler.channelRead(ChannelOperationsHandler.java:115) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:444) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412) at reactor.netty.http.server.HttpTrafficHandler.channelRead(HttpTrafficHandler.java:262) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:442) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412) at io.netty.channel.CombinedChannelDuplexHandlerDelegatingChannelHandlerContext.fireChannelRead(CombinedChannelDuplexHandler.java:436)atio.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:346)atio.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:333)atio.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:455)atio.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:290)atio.netty.channel.CombinedChannelDuplexHandler.channelRead(CombinedChannelDuplexHandler.java:251)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:442)atio.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420)atio.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412)atio.netty.channel.DefaultChannelPipelineDelegatingChannelHandlerContext.fireChannelRead(CombinedChannelDuplexHandler.java:436) at io.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:346) at io.netty.handler.codec.ByteToMessageDecoder.fireChannelRead(ByteToMessageDecoder.java:333) at io.netty.handler.codec.ByteToMessageDecoder.callDecode(ByteToMessageDecoder.java:455) at io.netty.handler.codec.ByteToMessageDecoder.channelRead(ByteToMessageDecoder.java:290) at io.netty.channel.CombinedChannelDuplexHandler.channelRead(CombinedChannelDuplexHandler.java:251) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:442) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.AbstractChannelHandlerContext.fireChannelRead(AbstractChannelHandlerContext.java:412) at io.netty.channel.DefaultChannelPipelineHeadContext.channelRead(DefaultChannelPipeline.java:1407) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:440) at io.netty.channel.AbstractChannelHandlerContext.invokeChannelRead(AbstractChannelHandlerContext.java:420) at io.netty.channel.DefaultChannelPipeline.fireChannelRead(DefaultChannelPipeline.java:918) at io.netty.channel.nio.AbstractNioByteChannelNioByteUnsafe.read(AbstractNioByteChannel.java:166)atio.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:788)atio.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:724)atio.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:650)atio.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:562)atio.netty.util.concurrent.SingleThreadEventExecutorNioByteUnsafe.read(AbstractNioByteChannel.java:166) at io.netty.channel.nio.NioEventLoop.processSelectedKey(NioEventLoop.java:788) at io.netty.channel.nio.NioEventLoop.processSelectedKeysOptimized(NioEventLoop.java:724) at io.netty.channel.nio.NioEventLoop.processSelectedKeys(NioEventLoop.java:650) at io.netty.channel.nio.NioEventLoop.run(NioEventLoop.java:562) at io.netty.util.concurrent.SingleThreadEventExecutor4.run(SingleThreadEventExecutor.java:994) at io.netty.util.internal.ThreadExecutorMap$2.run(ThreadExecutorMap.java:74) at io.netty.util.concurrent.FastThreadLocalRunnable.run(FastThreadLocalRunnable.java:30) at java.base/java.lang.Thread.run(Thread.java:1583)

  22. Assistant

    该错误表明 JWT 的 iss (Issuer) 声明无效,这是 Spring Security 的 NimbusReactiveJwtDecoder 在验证 JWT 的 iss 字段时抛出的 JwtValidationException。在 OAuth2/JWT 的上下文中,iss 是一个非常重要的字段,用于标识签发令牌的令牌颁发者,例如 Keycloak、Auth0 或其他身份提供者 (Identity Provider, IdP)。

    如果 iss 字段的值与预期的不符合,验证将失败。

    问题来源

    1. 配置的 issuer-uri 不匹配:

      • spring.security.oauth2.resourceserver.jwt.issuer-uri 配置中的值未正确填写,导致 Spring Security 校验 iss 字段失败。
      • Spring Security 会从 JWT 的 iss 声明中验证 JWT 的颁发者是否匹配 issuer-uri。
    2. JWT 本身的 iss 字段与 Keycloak 的实际配置不符:

      • JWT 内部的 iss 字段(由 Keycloak 公钥签名)与 Spring 的 issuer-uri 配置不匹配。
      • 最常见错误包括子路径错误(例如 realm 名字拼写错误、URL 缺少尾部斜杠等)。
    3. Keycloak 的 Realm 配置问题:

      • 在 Keycloak 中,定义 Realm 时导致 Issuer URL 不兼容(例如,未正确启用 OIDC 功能)。
    4. Token 使用的环境问题:

      • 前端应用从错误环境的 Keycloak 获取了 Token(例如使用了测试环境的 Keycloak),而调用的 API 使用的是生产环境配置。

    解决方案

    针对这些常见原因,这些解决方法可以帮助您迅速解决问题:


    1. 检查 Keycloak 中 JWT 的 iss 值

    JWT 的 iss 字段由 Keycloak 在颁发 Token 时定义。以下是如何确定该字段的值:

    方法 1:解码 JWT

    您可以解码 JWT 并检查 iss 值:

    1. 获取客户端从 Keycloak 获取的 Access Token(JWT)。
    2. 使用 jwt.io 或其他解码工具解码该 Token。
    3. 找到 Token 的 payload 部分(解码后的 JSON),如:
      {
          "iss": "http://<your-keycloak-host>/realms/<realm-name>",
          "sub": "user-id",
          "exp": 1712345678,
          ...
      }
      
      重点检查 iss 值,确保它与您期望的 Keycloak 的 Realm 配置一致。
    方法 2:使用 Keycloak .well-known 配置
    1. 访问 Keycloak 的 OIDC 配置 URL:
      http://<your-keycloak-host>/realms/<realm-name>/.well-known/openid-configuration
      
      您应该看到 JSON 输出类似:
      {
          "issuer": "http://<your-keycloak-host>/realms/<realm-name>",
          "jwks_uri": "http://<your-keycloak-host>/realms/<realm-name>/protocol/openid-connect/certs",
          ...
      }
      
      检查 issuer 的值与 iss 是否一致。
    方法 3:验证配置的客户端和上下文
    1. 确定您配置的 OAuth2 客户端到底指向哪一个 Realm。
    2. Keycloak Token 的 iss 与实际的 Realm 必须匹配。

    2. 配置 Spring Security issuer-uri

    在您的 application.yml 或 application.properties 中,spring.security.oauth2.resourceserver.jwt.issuer-uri 必须与 Keycloak JWT 的 iss 声明匹配。

    spring:
      security:
        oauth2:
          resourceserver:
            jwt:
              issuer-uri: http://<your-keycloak-host>/realms/<realm-name>
    
    注意:
    • <your-keycloak-host>:Keycloak 的主机名和端口(例如 http://localhost:8080 或生产环境的域名)。
    • <realm-name>:Keycloak 配置的 Realm 名称,确保没有拼写错误。

    注意: 这个值应该与 Keycloak 的 .well-known/openid-configuration 的 issuer 字段完全匹配。


    3. 验证是否需要尾部斜杠

    Keycloak 的 issuer URL 通常不需要尾部的 /,请确保 issuer-uri 的值和 JWT 中 iss 字段完全一致。例如:

    • 正确(无尾斜杠,推荐的 Keycloak 默认配置):
      http://localhost:8080/realms/my-realm
      
    • 错误(多了尾部斜杠):
      http://localhost:8080/realms/my-realm/
      

    JWT 验证时,任何差别都会导致 The iss claim is not valid 错误。


    4. 检查客户端的配置和环境问题

    前端应用是否正确向 Keycloak 请求了 Token?以下是一些检查重点:

    1. 环境是否对齐:

      • 确保前端和后端都指向同一个 Keycloak 实例(例如生产环境或测试环境)。
      • 如果后端指向的 issuer-uri 与 JWT 的 iss 值来源环境不一致,就会发生错误。
    2. Keycloak 的客户端配置:

      • 登录到 Keycloak 管理界面,找到您使用的 Client,确保它绑定在正确的 Realm 上。

    5. 配置自定义 Issuer 校验器(可选)

    如果您希望跳过对 iss 的校验(不推荐),可以覆盖默认的认证管理器(JwtReactiveAuthenticationManager),实现自定义的 JWT 验证逻辑。

    示例:

    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.oauth2.jwt.Jwt;
    import org.springframework.security.oauth2.jwt.JwtDecoder;
    import org.springframework.security.oauth2.jwt.ReactiveJwtDecoders;
    import org.springframework.security.oauth2.server.resource.authentication.JwtReactiveAuthenticationManager;
    import reactor.core.publisher.Mono;
    
    @Configuration
    public class SecurityConfig {
    
        @Bean
        public JwtDecoder jwtDecoder() {
            // 对客户端强制禁用 iss 检验(仅示例,实际不推荐)
            return ReactiveJwtDecoders.fromIssuerLocation("http://<your-keycloak-host>/realms/<realm-name>");
        }
    
        @Bean
        public JwtReactiveAuthenticationManager jwtReactiveAuthenticationManager(JwtDecoder jwtDecoder) {
            return new JwtReactiveAuthenticationManager(jwtDecoder) {
                @Override
                public Mono<Jwt> validateJwt(Jwt jwt) {
                    // 省略 iss 校验
                    return Mono.just(jwt);
                }
            };
        }
    }
    

    6. 检查 Nginx/反向代理问题

    如果您在生产环境中使用 Nginx 或其他代理,请确保流量被正确转发到 Keycloak:

    • 如果代理中转多个上下文路径,Keycloak 配置的 iss URL 和请求地址可能不一致,从而引发问题。例如:
      • 错误:
        Token 的 iss: http://localhost:8080/realms/my-realm
        而后端配置的 issuer-uri: http://example.com/auth/realms/my-realm
        
      • 解决方式:调整 Keycloak 配置或 issuer 检验逻辑。

    总结

    1. 解码 JWT 检查 iss 声明值。
    2. 确保 spring.security.oauth2.resourceserver.jwt.issuer-uri 与 Keycloak 的 iss 完全一致。
    3. 检查前端和后端是否使用了同一 Keycloak 实例。
    4. 避免尾部斜杠导致的匹配问题。
    5. 如果问题仍然存在,可通过自定义 Issuer 校验逻辑来解决(非推荐方案)。

    通过这些步骤,您应该可以解决 The iss claim is not valid 错误并使 JWT 验证正常工作。如有任何问题,欢迎继续提问 😊。

  23. User

    @Bean public SecurityWebFilterChain securityWebFilterChain(ServerHttpSecurity http, CorsConfigurationSource configurationSource) { http .cors(corsSpec -> corsSpec.configurationSource(configurationSource)) .csrf(ServerHttpSecurity.CsrfSpec::disable) .authorizeExchange(authorize -> { permits.forEach(permit -> authorize.pathMatchers(permit).permitAll()); authorize.anyExchange().authenticated(); }) // .oauth2ResourceServer(oauth2 -> oauth2.jwt(Customizer.withDefaults())); .oauth2ResourceServer(oauth2 -> oauth2.jwt(jwtSpec -> jwtSpec.jwtAuthenticationConverter(jwtAuthenticationConverter())));

        return http.build();
    }
    
    @Bean
    public ReactiveJwtAuthenticationConverterAdapter jwtAuthenticationConverter() {
        JwtGrantedAuthoritiesConverter grantedAuthoritiesConverter = new JwtGrantedAuthoritiesConverter();
        grantedAuthoritiesConverter.setAuthorityPrefix("ROLE_");
        grantedAuthoritiesConverter.setAuthoritiesClaimName("realm_access.roles");
    
        JwtAuthenticationConverter converter = new JwtAuthenticationConverter();
        converter.setJwtGrantedAuthoritiesConverter(grantedAuthoritiesConverter);
    
        return new ReactiveJwtAuthenticationConverterAdapter(converter);
    }
    

    redis里面并没有信息

  24. Assistant

    你的代码并没有启用会话管理到 Redis 的具体逻辑(例如通过 Spring Session),因此 JWT 的用户信息不会被自动存储到 Redis 中。由于 Spring Security 和 Spring Resource Server 的默认配置是 无状态的(stateless),它不会自动将会话或用户认证信息存储到 Redis。

    以下是导致问题的具体原因及如何修复 Redis 存储的详细解决方案。


    问题分析

    1. 无状态设计默认禁用了会话存储

      • Spring Security 使用 JWT 是基于 OAuth2 的无状态设计模式(stateless)。
      • 默认情况下,Spring Security 不会在 Redis 中存储会话内容或用户信息。JWT 是完全自包含的认证令牌,所有的信息都直接从令牌中提取,不依赖服务器存储。
      • 因此,即使引入了 Redis 作为会话存储,通过默认的配置,用户信息不会自动写入 Redis。
    2. WebFlux 中的会话存储(Session Management)

      • WebFlux 默认不会使用 HTTP 会话(HttpSession)。
      • 如果希望在 WebFlux 中存储用户信息到 Redis,会话逻辑需要与 Spring Session 结合。
    3. ReactiveJwtAuthenticationConverter 的职责

      • ReactiveJwtAuthenticationConverter 的作用是将 JWT 转换为 Authentication 对象,并不与存储到 Security Context 和会话逻辑直接绑定。
      • 如果 Redis 存储没有正确启用,那 SecurityContext 的内容只会存在于请求期间的临时上下文中。

    完整解决方案:将用户信息存储到 Redis

    1. 引入 Spring Session Redis 依赖

    确保项目已经引入了 Spring 会话和 Redis 支持相关依赖:

    <dependency>
        <groupId>org.springframework.session</groupId>
        <artifactId>spring-session-data-redis</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-redis-reactive</artifactId>
    </dependency>
    
    • spring-session-data-redis 用于将会话存储到 Redis 中。
    • spring-boot-starter-data-redis-reactive 用于 WebFlux 和响应式下的 Redis 操作。

    2. 配置 Redis 和 Spring Session

    在 application.yml 中,启用 Redis 为会话存储提供支持:

    spring:
      session:
        store-type: redis  # 使用 Redis 存储会话
        redis:
          flush-mode: immediate  # 在请求提交时立即将会话刷到 Redis
          namespace: spring:session  # Redis 键的命名前缀
      redis:
        host: localhost  # Redis 服务地址
        port: 6379  # Redis 服务端口
        timeout: 5000ms  # Redis 服务超时时间配置
    

    Session 配置完成后,Spring 将会自动把 SecurityContext 和用户相关的会话数据存储到 Redis。


    3. 启用会话存储功能 (Spring Session)

    通过 EnableSpringWebSession 注解启用 Spring Session 的 Redis 支持:

    import org.springframework.session.data.redis.config.annotation.web.server.EnableRedisWebSession;
    import org.springframework.context.annotation.Configuration;
    
    @Configuration
    @EnableRedisWebSession
    public class RedisSessionConfig {
        // Spring Session 将通过 Spring 的自动化配置绑定到 Redis
    }
    

    该配置指示 Spring 使用 Redis 来存储 WebFlux 的会话数据,包括认证的用户信息和授权上下文。


    4. 配置 Spring Security 让用户信息存入 Redis

    在 WebFlux 中,用户认证信息(Authentication 对象)需要保存在 Reactive Security Context 中才能与 Redis 会话存储绑定。

    您已经正确配置了 ReactiveJwtAuthenticationConverterAdapter,将 JWT 转换为了 Authentication,接下来的任务是确保该 Authentication 被写入 SecurityContextHolder 并通过 Redis 被持久化。

    加入 WebFilter 增强 SecurityContext
    import org.springframework.context.annotation.Bean;
    import org.springframework.context.annotation.Configuration;
    import org.springframework.security.core.context.SecurityContext;
    import org.springframework.security.core.context.SecurityContextHolder;
    import org.springframework.security.web.server.context.WebSessionServerSecurityContextRepository;
    import org.springframework.web.server.ServerWebExchange;
    import reactor.core.publisher.Mono;
    
    @Configuration
    public class SecurityContextConfig {
    
        /**
         * 配置 WebSession(与 Redis 会话绑定)
         */
        @Bean
        public WebSessionServerSecurityContextRepository securityContextRepository() {
            return new WebSessionServerSecurityContextRepository();
        }
    
        /**
         * 自定义 Security Filter,确保使用者的 SecurityContext 被存入 Redis
         */
        @Bean
        public SecurityWebFilterChain securityWebFilterChain(
            ServerHttpSecurity http,
            WebSessionServerSecurityContextRepository securityContextRepository) {
    
            http.securityContextRepository(securityContextRepository) // 使用 Redis 会话存储 SecurityContext
                .authorizeExchange(exchanges -> exchanges
                    .anyExchange().authenticated()
                )
                .oauth2ResourceServer(oauth2 -> oauth2.jwt(
                    jwtSpec -> jwtSpec.jwtAuthenticationConverter(jwtAuthenticationConverter())
                ));
    
            return http.build();
        }
    }
    

    使用 WebSessionServerSecurityContextRepository 后,Spring 会将当前用户认证信息写入到 WebSession,然后通过 Spring Session 将其存储到 Redis。


    5. 验证 Redis 是否保存用户认证信息

    前置条件:确保服务正确运行,前端带上有效的 Bearer Token 访问后端的受保护资源。

    1. 使用 Redis CLI 查看存储的会话:

      redis-cli
      keys *  # 查看所有存储在 Redis 中的键
      

      您会看到类似如下的会话键:

      spring:session:sessions:<session-id>
      
    2. 检查会话内容:

      get spring:session:sessions:<session-id>
      

      会显示类似 JSON 的结构化数据,部分包含:

      {
          "SPRING_SECURITY_CONTEXT": {
              "authentication": {
                  "principal": {
                      "preferred_username": "user@example.com",
                      "roles": ["ROLE_USER", "ROLE_ADMIN"]
                  },
                  "authorities": ["ROLE_USER", "ROLE_ADMIN"]
              }
          }
      }
      

    6. 在服务端访问 Redis 中存储的会话数据

    后端可以通过接口或 Redis 客户端访问 Redis 中存储的会话和用户身份数据。

    例如,在控制器中直接使用 Spring 的 SecurityContext 获取当前用户信息:

    import org.springframework.security.core.Authentication;
    import org.springframework.security.core.context.ReactiveSecurityContextHolder;
    import org.springframework.web.bind.annotation.GetMapping;
    import org.springframework.web.bind.annotation.RestController;
    import reactor.core.publisher.Mono;
    
    import java.util.Map;
    
    @RestController
    public class UserController {
    
        @GetMapping("/me")
        public Mono<Map<String, Object>> currentUser() {
            return ReactiveSecurityContextHolder.getContext()
                .map(context -> context.getAuthentication())
                .map(auth -> Map.of(
                    "username", auth.getName(),
                    "authorities", auth.getAuthorities()
                ));
        }
    
    }
    

    调试技巧

    1. 确保 Redis 连接正常: 测试 Redis 是否成功连接:

      redis-cli ping
      

      如果返回 PONG,说明 Redis 正常。

    2. 确保 Token 有效且认证成功:

      • 使用工具(如 jwt.io)解码 Token,确认 Token 的结构和声明(如 roles 等字段)是否正确。
      • 调试日志中验证是否出现 OAuth2 的认证错误。
    3. 检查 Redis Session 是否生效: Redis 是否存储了会话数据(步骤 5)。

    4. 检查 Token 权限问题: 确保 JWT 提供了合法的权限声明,并被 JwtGrantedAuthoritiesConverter 解析。


    总结

    通过以上步骤,您将实现:

    1. JWT 认证信息存储到 Redis: 使用 spring-session-data-redis 实现 Redis 的会话存储。
    2. 基于 WebFlux 和 Security 的会话存储机制: 使用 WebSessionServerSecurityContextRepository 来将 Security Context 和会话绑定。
    3. 对存储中的会话数据操作和验证: 通过 Redis CLI 或 Spring SecurityContext API,访问存储的用户会话信息。

    如果还有问题,请继续告诉我! 😊