1
┌─────────────────────────────────────────────┐
2
│              API Gateway                    │
3
├─────────────────────────────────────────────┤
4
│  ┌─────────┐  ┌─────────┐  ┌─────────┐     │
5
│  │路由转发 │  │认证授权 │  │限流熔断 │     │
6
│  └─────────┘  └─────────┘  └─────────┘     │
7
│  ┌─────────┐  ┌─────────┐  ┌─────────┐     │
8
│  │日志监控 │  │协议转换 │  │负载均衡 │     │
9
│  └─────────┘  └─────────┘  └─────────┘     │
10
└─────────────────────────────────────────────┘

1
@Component
2
public class AuthFilter implements GlobalFilter {
3

4
    @Override
5
    public Mono<Void> filter(ServerWebExchange exchange,
6
                           GatewayFilterChain chain) {
7
        String token = exchange.getRequest()
8
            .getHeaders().getFirst("Authorization");
9

10
        // 验证 JWT
11
        if (!jwtUtil.verify(token)) {
12
            return unauthorized(exchange);
13
        }
14

15
        // 解析用户信息，传递给下游
16
        UserInfo user = jwtUtil.parse(token);
17
        exchange.getAttributes().put("user", user);
18

19
        return chain.filter(exchange);
20
    }
21
}

1
// 使用 Sentinel 实现限流
2
@SentinelResource(value = "orderApi",
3
                  blockHandler = "blockHandler")
4
public Mono<Order> getOrder(String id) {
5
    return webClient.get()
6
        .uri("/orders/" + id)
7
        .retrieve()
8
        .bodyToMono(Order.class);
9
}
10

11
// 配置限流规则
12
@Configuration
13
public class SentinelConfig {
14
    @PostConstruct
15
    public void init() {
16
        FlowRuleManager.loadRules(
17
            Arrays.asList(
18
                new FlowRule("orderApi")
19
                    .setCount(100)
20
                    .setGrade(RuleConstant.FLOW_GRADE_QPS)
21
            )
22
        );
23
    }
24
}

1
// 请求日志
2
@Component
3
public class LoggingFilter implements GlobalFilter {
4

5
    @Override
6
    public Mono<Void> filter(ServerWebExchange exchange,
7
                           GatewayFilterChain chain) {
8
        long start = System.currentTimeMillis();
9

10
        return chain.filter(exchange)
11
            .then(Mono.fromRunnable(() -> {
12
                long duration = System.currentTimeMillis() - start;
13
                log.info("{} {} - {}ms - {}",
14
                    exchange.getRequest().getMethod(),
15
                    exchange.getRequest().getURI(),
16
                    duration,
17
                    exchange.getResponse().getStatusCode());
18

19
                // 发送指标到 Prometheus
20
                metrics.record(
21
                    "api_request_duration",
22
                    duration,
23
                    "path", exchange.getRequest().getPath(),
24
                    "status", exchange.getResponse().getStatusCode()
25
                );
26
            }));
27
    }
28
}

1
                    ┌─────────────┐
2
                    │   DNS/LB    │
3
                    └──────┬──────┘
4
                           │
5
                    ┌──────▼──────┐
6
                    │   Nginx     │
7
                    └──────┬──────┘
8
                           │
9
              ┌────────────┼────────────┐
10
              │            │            │
11
        ┌─────▼─────┐ ┌────▼────┐ ┌─────▼─────┐
12
        │ Gateway 1 │ │Gateway 2│ │Gateway 3 │
13
        └─────┬─────┘ └────┬────┘ └─────┬─────┘
14
              │            │            │
15
              └────────────┼────────────┘
16
                           │
17
        ┌──────────────────┼──────────────────┐
18
        │                  │                  │
19
   ┌────▼────┐       ┌─────▼─────┐      ┌─────▼────┐
20
   │  User   │       │  Order    │      │ Payment │
21
   │ Service │       │  Service  │      │ Service │
22
   └─────────┘       └───────────┘      └─────────┘