Spring Cloud微服务安全架构设计：OAuth2.0认证授权与API网关集成实践

引言：微服务架构下的安全挑战

在现代企业级应用开发中，微服务架构已成为构建复杂、高可用系统的核心范式。它通过将单体应用拆分为多个独立部署、松耦合的服务单元，提升了系统的可维护性、可扩展性和容错能力。然而，这种架构模式也带来了新的安全挑战。

传统的单体应用通常采用统一的身份认证和权限控制机制，而微服务架构下，每个服务可能独立运行于不同的容器或云环境中，服务之间通过HTTP/REST、gRPC等协议通信。这使得身份验证、授权、令牌管理、跨服务访问控制等问题变得异常复杂。

常见的安全风险包括：

未授权访问：客户端直接调用内部服务接口，绕过认证。
令牌泄露：敏感信息（如用户凭证）在传输或存储过程中被窃取。
服务间信任缺失：服务之间无法验证彼此身份，导致中间人攻击。
权限越权：用户或服务获取超出其权限范围的资源访问能力。

为应对这些挑战，一套完整的微服务安全架构必须涵盖以下核心要素：

统一的身份认证中心（Identity Provider）
安全的令牌交换机制（如JWT）
API网关作为统一入口进行鉴权
服务间通信的安全保障（如mTLS、Token传递）
基于角色/声明的细粒度权限控制

本篇文章将围绕 Spring Cloud 微服务生态，深入探讨如何基于 OAuth2.0 协议 构建一个健壮、可扩展的安全架构，并结合 Spring Cloud Gateway 实现前后端请求的统一安全管控。我们将从理论到实践，提供完整的技术方案与代码示例，帮助开发者快速落地生产级安全体系。

一、OAuth2.0协议原理与微服务适配

1.1 OAuth2.0核心概念解析

OAuth2.0 是一种开放标准，用于授权第三方应用在不暴露用户密码的前提下访问受保护资源。其核心目标是“授权”而非“认证”，但常与身份认证结合使用（如 OpenID Connect）。

核心角色

角色	说明
资源所有者（Resource Owner）	拥有受保护资源的用户，例如登录系统的员工
客户端（Client）	请求访问资源的应用程序（前端、移动端、其他微服务）
授权服务器（Authorization Server）	验证身份并颁发访问令牌的服务器
资源服务器（Resource Server）	保护实际数据的后端服务

授权流程类型（Grant Types）

类型	适用场景	安全性
`authorization_code`	Web 应用、移动应用	高（推荐）
`implicit`	浏览器端单页应用（SPA）	低（已弃用）
`password`	可信客户端（如内部系统）	中（需谨慎）
`client_credentials`	服务间通信	高（适合微服务）

✅ 在微服务架构中，最推荐的是 authorization_code（用于用户登录）和 client_credentials（用于服务间调用）。

1.2 OAuth2.0在微服务中的典型架构

graph LR
    A[客户端: Browser / Mobile App] -->|1. Redirect to Auth Server| B(Identity Provider)
    B -->|2. Login & Consent| C[Authorization Server]
    C -->|3. Return Authorization Code| A
    A -->|4. Exchange Code for Token| D[Token Endpoint]
    D -->|5. Return Access Token| E[Resource Server 1]
    D -->|5. Return Access Token| F[Resource Server 2]
    E -->|6. Validate JWT| G[Service A]
    F -->|6. Validate JWT| H[Service B]
    G -->|7. Call via API Gateway| I[API Gateway]
    H -->|7. Call via API Gateway| I

该架构体现了以下几个关键点：

所有服务均以 JWT 形式接收访问令牌。
授权服务器集中管理用户身份与权限。
资源服务器仅负责验证令牌有效性。
API 网关作为第一道防线，拦截非法请求。

二、Spring Security + OAuth2.0 实现认证中心

为了实现上述架构，我们选择 Spring Boot + Spring Security + Spring Security OAuth2 Resource Server 来搭建授权服务器。

2.1 创建授权服务器项目（auth-server）

1. 引入依赖（`pom.xml`）

<dependencies>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-web</artifactId>
    </dependency>
    <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.security</groupId>
        <artifactId>spring-security-config</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-oauth2-config</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-data-jpa</artifactId>
    </dependency>
    <dependency>
        <groupId>org.postgresql</groupId>
        <artifactId>postgresql</artifactId>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. 配置文件（`application.yml`）

server:
  port: 9000

spring:
  datasource:
    url: jdbc:postgresql://localhost:5432/authdb
    username: authuser
    password: authpass
    driver-class-name: org.postgresql.Driver

  jpa:
    hibernate:
      ddl-auto: update
    show-sql: true

security:
  oauth2:
    authorization:
      check-authentication-at-login: true
    resource-server:
      jwt:
        issuer-uri: http://localhost:9000/realms/master
        jwk-set-uri: http://localhost:9000/realms/master/protocol/openid-connect/certs

⚠️ 注意：这里使用了 Keycloak 作为 OIDC 兼容的授权服务器。若自建，需配置 jwk-set-uri 指向公钥集。

3. 启动类与安全配置

@SpringBootApplication
@EnableAuthorizationServer
public class AuthServerApplication {
    public static void main(String[] args) {
        SpringApplication.run(AuthServerApplication.class, args);
    }
}

4. OAuth2 自定义配置（`SecurityConfig.java`）

@Configuration
@EnableWebSecurity
public class SecurityConfig {

    @Bean
    public SecurityFilterChain filterChain(HttpSecurity http) throws Exception {
        http
            .authorizeHttpRequests(authz -> authz
                .requestMatchers("/login", "/oauth2/**").permitAll()
                .anyRequest().authenticated()
            )
            .formLogin(form -> form
                .loginPage("/login")
                .permitAll()
            )
            .oauth2Login(oauth2 -> oauth2
                .loginPage("/login")
            )
            .logout(logout -> logout
                .logoutSuccessUrl("/")
                .permitAll()
            );
        return http.build();
    }

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

    @Bean
    public AuthenticationManager authenticationManager(
            AuthenticationConfiguration config) throws Exception {
        return config.getAuthenticationManager();
    }
}

5. 用户管理（简化版）

@Entity
@Table(name = "users")
public class User {
    @Id
    @GeneratedValue(strategy = GenerationType.IDENTITY)
    private Long id;

    @Column(unique = true, nullable = false)
    private String username;

    @Column(nullable = false)
    private String password;

    // Getters and Setters
}

@Repository
public interface UserRepository extends JpaRepository<User, Long> {
    Optional<User> findByUsername(String username);
}

三、生成与分发JWT令牌（基于RSA加密）

3.1 使用 RSA 非对称密钥对签名令牌

1. 生成密钥对（命令行）

# 生成私钥
openssl genrsa -out rsa-private.pem 2048

# 提取公钥
openssl rsa -pubout -in rsa-private.pem -out rsa-public.pem

2. 将公钥注入 Spring Boot 配置

# application.yml
jwt:
  signing-key: classpath:keys/rsa-private.pem
  verification-key: classpath:keys/rsa-public.pem

3. JWT 工具类（`JwtUtil.java`）

@Component
public class JwtUtil {

    private final KeyPair keyPair;
    private final String signingKeyPath;
    private final String verificationKeyPath;

    public JwtUtil(@Value("${jwt.signing-key}") String signingKeyPath,
                   @Value("${jwt.verification-key}") String verificationKeyPath) throws IOException {
        this.signingKeyPath = signingKeyPath;
        this.verificationKeyPath = verificationKeyPath;
        this.keyPair = loadKeyPair();
    }

    private KeyPair loadKeyPair() throws IOException {
        try (InputStream is = getClass().getClassLoader().getResourceAsStream(signingKeyPath)) {
            byte[] bytes = is.readAllBytes();
            PemReader reader = new PemReader(new InputStreamReader(new ByteArrayInputStream(bytes)));
            PemObject obj = reader.readPemObject();
            PKCS8EncodedKeySpec spec = new PKCS8EncodedKeySpec(obj.getContent());
            KeyFactory kf = KeyFactory.getInstance("RSA");
            PrivateKey privateKey = kf.generatePrivate(spec);

            try (InputStream pubIs = getClass().getClassLoader().getResourceAsStream(verificationKeyPath)) {
                byte[] pubBytes = pubIs.readAllBytes();
                PemReader pubReader = new PemReader(new InputStreamReader(new ByteArrayInputStream(pubBytes)));
                PemObject pubObj = pubReader.readPemObject();
                X509EncodedKeySpec specPub = new X509EncodedKeySpec(pubObj.getContent());
                PublicKey publicKey = kf.generatePublic(specPub);
                return new KeyPair(publicKey, privateKey);
            }
        }
    }

    public String generateToken(UserDetails userDetails) {
        Map<String, Object> claims = new HashMap<>();
        claims.put("roles", userDetails.getAuthorities().stream()
                .map(GrantedAuthority::getAuthority)
                .collect(Collectors.toList()));

        return Jwts.builder()
                .setClaims(claims)
                .setSubject(userDetails.getUsername())
                .setIssuedAt(new Date())
                .setExpiration(new Date(System.currentTimeMillis() + 1000 * 60 * 60 * 24)) // 24h
                .signWith(keyPair.getPrivate(), SignatureAlgorithm.RS256)
                .compact();
    }

    public boolean validateToken(String token, UserDetails userDetails) {
        try {
            Claims claims = getClaimsFromToken(token);
            String username = claims.getSubject();
            return (username.equals(userDetails.getUsername()) && !isTokenExpired(token));
        } catch (Exception e) {
            return false;
        }
    }

    private Claims getClaimsFromToken(String token) {
        return Jwts.parserBuilder()
                .setSigningKey(keyPair.getPublic())
                .build()
                .parseClaimsJws(token)
                .getBody();
    }

    private boolean isTokenExpired(String token) {
        return getClaimsFromToken(token).getExpiration().before(new Date());
    }
}

💡 提示：生产环境建议使用 Keycloak、Auth0、Azure AD 等成熟平台，避免自行管理密钥。

四、API网关集成：Spring Cloud Gateway + OAuth2 Filter

4.1 构建API网关（gateway-service）

1. 依赖引入（`pom.xml`）

<dependencies>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-gateway</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.cloud</groupId>
        <artifactId>spring-cloud-starter-oauth2-resource-server</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.boot</groupId>
        <artifactId>spring-boot-starter-webflux</artifactId>
    </dependency>
    <dependency>
        <groupId>org.springframework.security</groupId>
        <artifactId>spring-security-config</artifactId>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-api</artifactId>
        <version>0.11.5</version>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-impl</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
    <dependency>
        <groupId>io.jsonwebtoken</groupId>
        <artifactId>jjwt-jackson</artifactId>
        <version>0.11.5</version>
        <scope>runtime</scope>
    </dependency>
</dependencies>

2. 配置文件（`application.yml`）

server:
  port: 8080

spring:
  cloud:
    gateway:
      routes:
        - id: user-service
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - StripPrefix=1
            - name: AuthFilter
              args:
                skip: false
        - id: order-service
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
          filters:
            - StripPrefix=1
            - name: AuthFilter
              args:
                skip: false
      discovery:
        locator:
          enabled: true
          lowerCaseServiceId: true

security:
  oauth2:
    resourceserver:
      jwt:
        issuer-uri: http://localhost:9000/realms/master
        jwk-set-uri: http://localhost:9000/realms/master/protocol/openid-connect/certs

3. JWT 验证过滤器（`AuthFilter.java`）

@Component
@Order(1)
public class AuthFilter implements GlobalFilter {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange, GatewayFilterChain chain) {
        ServerHttpRequest request = exchange.getRequest();
        String authHeader = request.getHeaders().getFirst("Authorization");

        if (authHeader == null || !authHeader.startsWith("Bearer ")) {
            return onError(exchange, "Missing or invalid Authorization header", HttpStatus.UNAUTHORIZED);
        }

        String token = authHeader.substring(7); // Remove "Bearer "

        try {
            // 验证 JWT
            Jws<Claims> jws = Jwts.parserBuilder()
                    .setSigningKeyResolver((keyId, jwsHeader, jwsBody) -> {
                        try {
                            // 从本地加载公钥（实际应通过 JWKS 动态获取）
                            InputStream is = getClass().getClassLoader().getResourceAsStream("keys/rsa-public.pem");
                            byte[] bytes = is.readAllBytes();
                            PemReader reader = new PemReader(new InputStreamReader(new ByteArrayInputStream(bytes)));
                            PemObject obj = reader.readPemObject();
                            X509EncodedKeySpec spec = new X509EncodedKeySpec(obj.getContent());
                            KeyFactory kf = KeyFactory.getInstance("RSA");
                            return kf.generatePublic(spec);
                        } catch (Exception e) {
                            throw new RuntimeException(e);
                        }
                    })
                    .build()
                    .parseClaimsJws(token);

            // 附加用户信息到上下文
            String username = jws.getBody().getSubject();
            List<String> roles = (List<String>) jws.getBody().get("roles");

            ServerHttpRequest mutatedRequest = request.mutate()
                    .header("X-User-Name", username)
                    .header("X-User-Roles", String.join(",", roles))
                    .build();

            exchange.getAttributes().put("username", username);
            exchange.getAttributes().put("roles", roles);

            return chain.filter(exchange.mutate().request(mutatedRequest).build());

        } catch (Exception e) {
            return onError(exchange, "Invalid or expired token", HttpStatus.UNAUTHORIZED);
        }
    }

    private Mono<Void> onError(ServerWebExchange exchange, String msg, HttpStatus status) {
        ServerHttpResponse response = exchange.getResponse();
        response.setStatusCode(status);
        response.getHeaders().add("Content-Type", "application/json;charset=UTF-8");
        return response.writeWith(Mono.just(response.bufferFactory().wrap(msg.getBytes())));
    }
}

✅ 该过滤器作用于所有经过网关的请求，在进入具体服务前完成认证检查。

五、服务间通信安全：使用 Client Credentials Grant

5.1 服务间调用场景

当 order-service 需要调用 user-service 获取用户信息时，不应依赖用户令牌，而应使用 服务账户（Service Account）+ Client Credentials Grant。

1. 配置 `user-service` 为资源服务器

# user-service/application.yml
security:
  oauth2:
    resourceserver:
      jwt:
        issuer-uri: http://localhost:9000/realms/master

@RestController
@RequestMapping("/api/user")
@PreAuthorize("hasAuthority('SCOPE_user:read')")
public class UserController {

    @GetMapping("/{id}")
    public ResponseEntity<User> getUser(@PathVariable Long id) {
        // 模拟查询数据库
        User user = new User();
        user.setId(id);
        user.setUsername("alice");
        user.setEmail("alice@example.com");
        return ResponseEntity.ok(user);
    }
}

✅ @PreAuthorize("hasAuthority('SCOPE_user:read')") 表示只有携带 user:read Scope 的令牌才能访问。

2. `order-service` 请求令牌（使用 `client_credentials`）

@Service
public class UserServiceClient {

    private final WebClient webClient;

    public UserServiceClient(WebClient.Builder builder) {
        this.webClient = builder.build();
    }

    public User getUser(Long userId) {
        String token = getAccessToken();
        return webClient.get()
                .uri("http://user-service/api/user/{id}", userId)
                .header("Authorization", "Bearer " + token)
                .retrieve()
                .bodyToMono(User.class)
                .block();
    }

    private String getAccessToken() {
        return webClient.post()
                .uri("http://localhost:9000/realms/master/protocol/openid-connect/token")
                .contentType(MediaType.APPLICATION_FORM_URLENCODED)
                .body(BodyInserter.fromFormData("grant_type", "client_credentials")
                        .with("client_id", "order-service-client")
                        .with("client_secret", "order-secret"))
                .retrieve()
                .bodyToMono(Map.class)
                .map(map -> (String) map.get("access_token"))
                .block();
    }
}

🔐 客户端密钥 order-secret 必须在 Keycloak 中注册为 order-service-client 的秘密。

六、最佳实践与安全加固建议

6.1 安全策略总结

项目	最佳实践
令牌有效期	建议不超过 1 小时（短期有效）
刷新机制	使用 Refresh Token（配合持久化存储）
令牌撤销	使用 Redis 存储黑名单，或启用 JWT Blacklist
日志审计	记录每次认证/授权事件
HTTPS	所有通信必须启用 TLS 1.3+
CORS	明确白名单，禁止通配符 `*`
Header 清理	移除敏感头字段（如 `Authorization`）

6.2 使用 Redis 实现令牌黑名单

@Component
public class JwtBlacklistService {

    @Autowired
    private StringRedisTemplate redisTemplate;

    public void addToBlacklist(String token, long expireSeconds) {
        redisTemplate.opsForValue().set(token, "blacklisted", Duration.ofSeconds(expireSeconds));
    }

    public boolean isBlacklisted(String token) {
        return Boolean.TRUE.equals(redisTemplate.hasKey(token));
    }
}

在 AuthFilter 中增加判断：

if (blacklistService.isBlacklisted(token)) {
    return onError(exchange, "Token revoked", HttpStatus.UNAUTHORIZED);
}

6.3 使用 Spring Cloud Config 管理敏感配置

将 client_secret、private_key 等敏感信息放入 外部配置中心（如 Git + Spring Cloud Config Server），并通过加密方式（Vault）管理。

# config-server/config.properties
app.jwt.secret=${ENCRYPTED_SECRET}
app.oauth.client-secret=${ENCRYPTED_CLIENT_SECRET}

七、常见问题与调试技巧

问题	解决方案
`Invalid JWT signature`	检查公钥是否匹配私钥，确认 PEM 文件格式正确
`No Authority found in token`	确保 `scope` 或 `roles` 正确写入 JWT claims
`401 Unauthorized`	检查 `Authorization` 头是否以 `Bearer` 开头
服务间调用失败	查看 `client_credentials` 是否配置正确，检查 Keycloak 中的角色映射
JWT 过期时间不一致	使用 `iat`、`exp` 时间戳校验，确保时钟同步

结语：构建可持续演进的安全体系

本文全面介绍了如何基于 Spring Cloud 生态，利用 OAuth2.0 + JWT + API Gateway 构建一个健壮、可扩展的微服务安全架构。我们不仅实现了用户登录认证、资源访问控制，还覆盖了服务间通信安全、令牌生命周期管理等关键环节。

这套架构具备以下优势：

统一入口：通过 API 网关集中处理鉴权，降低各服务负担。
无状态设计：基于 JWT，支持水平扩展。
灵活授权：支持角色、权限、Scope 多维度控制。
易于集成：兼容主流 IDP（Keycloak、Auth0、Okta）。

未来可进一步演进：

引入 OpenTelemetry 实现链路追踪与安全审计。
集成 Sentinel 做流量限流与熔断。
使用 Istio 构建服务网格，实现 mTLS 加密通信。

📌 安全是持续的过程。建议定期进行渗透测试、代码审查、日志分析，建立完善的应急响应机制。

附录：完整项目结构示意

microservice-security/
├── auth-server/             # 授权服务器（Keycloak / 自研）
│   ├── src/main/java
│   │   └── com.example.auth
│   │       ├── AuthServerApplication.java
│   │       ├── SecurityConfig.java
│   │       └── JwtUtil.java
│   └── resources/
│       └── keys/
│           ├── rsa-private.pem
│           └── rsa-public.pem
│
├── gateway-service/         # API 网关
│   ├── src/main/java
│   │   └── com.example.gateway
│   │       ├── GatewayApplication.java
│   │       └── AuthFilter.java
│   └── application.yml
│
├── user-service/            # 资源服务
│   ├── src/main/java
│   │   └── com.example.user
│   │       └── UserController.java
│   └── application.yml
│
├── order-service/           # 服务消费者
│   ├── src/main/java
│   │   └── com.example.order
│   │       └── UserServiceClient.java
│   └── application.yml
│
└── shared/                  # 公共依赖
    └── security-utils.jar

✅ 提示：本文代码可在 GitHub 仓库 github.com/example/microservice-security 获取完整示例。

标签：Spring Cloud, 微服务, 安全架构, OAuth2.0, API网关

Spring Cloud微服务安全架构设计：OAuth2.0认证授权与API网关集成实践

Spring Cloud微服务安全架构设计：OAuth2.0认证授权与API网关集成实践

引言：微服务架构下的安全挑战

一、OAuth2.0协议原理与微服务适配

1.1 OAuth2.0核心概念解析

核心角色

授权流程类型（Grant Types）

1.2 OAuth2.0在微服务中的典型架构

二、Spring Security + OAuth2.0 实现认证中心

2.1 创建授权服务器项目（auth-server）

1. 引入依赖（`pom.xml`）

2. 配置文件（`application.yml`）

3. 启动类与安全配置

4. OAuth2 自定义配置（`SecurityConfig.java`）

5. 用户管理（简化版）

三、生成与分发JWT令牌（基于RSA加密）

3.1 使用 RSA 非对称密钥对签名令牌

1. 生成密钥对（命令行）

2. 将公钥注入 Spring Boot 配置

3. JWT 工具类（`JwtUtil.java`）

四、API网关集成：Spring Cloud Gateway + OAuth2 Filter

4.1 构建API网关（gateway-service）

1. 依赖引入（`pom.xml`）

2. 配置文件（`application.yml`）

3. JWT 验证过滤器（`AuthFilter.java`）

五、服务间通信安全：使用 Client Credentials Grant

5.1 服务间调用场景

1. 配置 `user-service` 为资源服务器

2. `order-service` 请求令牌（使用 `client_credentials`）

六、最佳实践与安全加固建议

6.1 安全策略总结

6.2 使用 Redis 实现令牌黑名单

6.3 使用 Spring Cloud Config 管理敏感配置

七、常见问题与调试技巧

结语：构建可持续演进的安全体系

附录：完整项目结构示意

相似文章

评论 (0)

Spring Cloud微服务安全架构设计：OAuth2.0认证授权与API网关集成实践

Spring Cloud微服务安全架构设计：OAuth2.0认证授权与API网关集成实践

引言：微服务架构下的安全挑战

一、OAuth2.0协议原理与微服务适配

1.1 OAuth2.0核心概念解析

核心角色

授权流程类型（Grant Types）

1.2 OAuth2.0在微服务中的典型架构

二、Spring Security + OAuth2.0 实现认证中心

2.1 创建授权服务器项目（auth-server）

1. 引入依赖（pom.xml）

2. 配置文件（application.yml）

3. 启动类与安全配置

4. OAuth2 自定义配置（SecurityConfig.java）

5. 用户管理（简化版）

三、生成与分发JWT令牌（基于RSA加密）

3.1 使用 RSA 非对称密钥对签名令牌

1. 生成密钥对（命令行）

2. 将公钥注入 Spring Boot 配置

3. JWT 工具类（JwtUtil.java）

四、API网关集成：Spring Cloud Gateway + OAuth2 Filter

4.1 构建API网关（gateway-service）

1. 依赖引入（pom.xml）

2. 配置文件（application.yml）

3. JWT 验证过滤器（AuthFilter.java）

五、服务间通信安全：使用 Client Credentials Grant

5.1 服务间调用场景

1. 配置 user-service 为资源服务器

2. order-service 请求令牌（使用 client_credentials）

六、最佳实践与安全加固建议

6.1 安全策略总结

6.2 使用 Redis 实现令牌黑名单

6.3 使用 Spring Cloud Config 管理敏感配置

七、常见问题与调试技巧

结语：构建可持续演进的安全体系

附录：完整项目结构示意

相似文章

评论 (0)

1. 引入依赖（`pom.xml`）

2. 配置文件（`application.yml`）

4. OAuth2 自定义配置（`SecurityConfig.java`）

3. JWT 工具类（`JwtUtil.java`）

1. 依赖引入（`pom.xml`）

2. 配置文件（`application.yml`）

3. JWT 验证过滤器（`AuthFilter.java`）

1. 配置 `user-service` 为资源服务器

2. `order-service` 请求令牌（使用 `client_credentials`）