Spring Cloud 基础教程

微服务架构核心思想：
- 按业务能力拆分服务，每个服务独立开发、部署、扩展
- 服务间通过 HTTP/RPC 轻量通信
- 数据存储隔离，每个服务拥有独立数据库

Spring Cloud 核心组件：
- 服务注册发现：Eureka / Nacos
- 服务调用：OpenFeign（声明式 HTTP 客户端）
- 负载均衡：Spring Cloud LoadBalancer
- API 网关：Spring Cloud Gateway
- 配置中心：Spring Cloud Config / Nacos Config
- 熔断降级：Sentinel / Resilience4j
- 分布式事务：Seata
- 链路追踪：Sleuth + Zipkin

<parent>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-parent</artifactId>
  <version>3.2.5</version>
</parent>

<properties>
  <spring-cloud.version>2023.0.1</spring-cloud.version>
</properties>

<dependencyManagement>
  <dependencies>
    <dependency>
      <groupId>org.springframework.cloud</groupId>
      <artifactId>spring-cloud-dependencies</artifactId>
      <version>${spring-cloud.version}</version>
      <type>pom</type>
      <scope>import</scope>
    </dependency>
  </dependencies>
</dependencyManagement>

电商系统服务拆分示例：
- user-service：用户、地址、会员
- order-service：订单、订单项
- product-service：商品、库存
- payment-service：支付、退款

拆分原则：
1. 单一职责：一个服务只做一件事
2. 数据库隔离：服务间禁止访问对方数据库
3. 接口契约：通过 REST/RPC 明确契约
4. 独立部署：每个服务可独立上线与扩缩容
5. 避免过度拆分：小团队优先按业务域合并

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-server</artifactId>
</dependency>

# application.yml
server:
  port: 8761
eureka:
  instance:
    hostname: localhost
  client:
    register-with-eureka: false
    fetch-registry: false
  server:
    enable-self-preservation: false

package com.example.eureka;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.netflix.eureka.server.EnableEurekaServer;

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

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-netflix-eureka-client</artifactId>
</dependency>

# application.yml
spring:
  application:
    name: user-service
server:
  port: 8081
eureka:
  client:
    service-url:
      defaultZone: http://localhost:8761/eureka/
  instance:
    prefer-ip-address: true

package com.example.userservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

# 客户端心跳配置
eureka:
  instance:
    lease-renewal-interval-in-seconds: 30   # 心跳间隔
    lease-expiration-duration-in-seconds: 90  # 过期时间

# 服务端自我保护
eureka:
  server:
    enable-self-preservation: true   # 生产开启
    renewal-percent-threshold: 0.85  # 续约百分比阈值

# 自我保护触发条件：
# 15 分钟内收到的续约次数 < 期望值的 85% 时进入自我保护
# 期间不注销任何实例，等待网络恢复

<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring-cloud-starter-alibaba-nacos-discovery</artifactId>
  <version>2023.0.1.0</version>
</dependency>

# application.yml
spring:
  application:
    name: product-service
  cloud:
    nacos:
      discovery:
        server-addr: 127.0.0.1:8848
server:
  port: 8082

package com.example.productservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.client.discovery.EnableDiscoveryClient;

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

<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring-cloud-starter-alibaba-nacos-config</artifactId>
  <version>2023.0.1.0</version>
</dependency>

# bootstrap.yml（或 spring.config.import）
spring:
  application:
    name: product-service
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        file-extension: yml

# Nacos 配置中心 Data ID: product-service.yml
server:
  port: 8082
app:
  banner: hello-nacos

package com.example.productservice.config;

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

@RestController
@RefreshScope
public class ConfigController {

    @Value("${app.banner}")
    private String banner;

    @GetMapping("/banner")
    public String banner() {
        return banner;
    }
}

# Nacos 三级隔离
# 1. 命名空间 namespace：环境隔离（dev / test / prod）
# 2. 分组 group：同一命名空间下按项目/团队分组（DEFAULT_GROUP）
# 3. Data ID：具体配置文件（{spring.application.name}.yml）

spring:
  cloud:
    nacos:
      config:
        server-addr: 127.0.0.1:8848
        namespace: dev-namespace-id   # 命名空间 ID
        group: ORDER_GROUP            # 分组
        file-extension: yml
      discovery:
        server-addr: 127.0.0.1:8848
        namespace: dev-namespace-id

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

package com.example.orderservice.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service")
public interface UserClient {

    @GetMapping("/api/users/{id}")
    String getUser(@PathVariable("id") Long id);
}

package com.example.orderservice;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.openfeign.EnableFeignClients;

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

# application.yml
feign:
  client:
    config:
      default:
        connect-timeout: 5000
        read-timeout: 10000
        logger-level: full

# 日志级别（FeignClient 接口所在包）
logging:
  level:
    com.example.orderservice.feign: debug

# Feign 日志级别：
# NONE（默认）、BASIC（URL/时间）、HEADERS（含头）、FULL（全部）

# application.yml
feign:
  circuitbreaker:
    enabled: true

package com.example.orderservice.feign;

import org.springframework.cloud.openfeign.FeignClient;
import org.springframework.stereotype.Component;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.PathVariable;

@FeignClient(name = "user-service", fallback = UserClientFallback.class)
public interface UserClient {

    @GetMapping("/api/users/{id}")
    String getUser(@PathVariable("id") Long id);
}

@Component
class UserClientFallback implements UserClient {
    @Override
    public String getUser(Long id) {
        return "用户服务暂不可用（降级返回）";
    }
}

package com.example.orderservice.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.web.client.RestTemplate;

@Configuration
public class RestTemplateConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

package com.example.orderservice.controller;

import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.client.RestTemplate;

@RestController
public class OrderController {

    private final RestTemplate restTemplate;

    public OrderController(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    @GetMapping("/order/user/{id}")
    public String getUser(@PathVariable Long id) {
        // 服务名由 LoadBalancer 解析为具体实例地址
        return restTemplate.getForObject(
                "http://user-service/api/users/" + id, String.class);
    }
}

package com.example.orderservice.config;

import org.springframework.cloud.client.loadbalancer.LoadBalanced;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClient;
import org.springframework.cloud.loadbalancer.annotation.LoadBalancerClients;
import org.springframework.cloud.loadbalancer.core.RandomLoadBalancer;
import org.springframework.cloud.loadbalancer.core.ServiceInstanceListSupplier;
import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;

@Configuration
@LoadBalancerClients(defaultConfiguration = LbStrategyConfig.class)
public class RestTemplateConfig {

    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

class LbStrategyConfig {
    @Bean
    public ReactorLoadBalancer<ServiceInstance> randomLoadBalancer(
            ObjectProvider<ServiceInstanceListSupplier> supplier,
            ObjectProvider<LoadBalancerClientFactory> factory,
            String serviceId) {
        return new RandomLoadBalancer(
                supplier.getIfAvailable(),
                factory.getIfAvailable().getLazyProvider(serviceId,
                        ServiceInstanceListSupplier::getInstance),
                serviceId);
    }
}

常见负载均衡策略对比：
- 轮询（RoundRobin）：依次分配，实现简单，适合实例配置均衡
- 随机（Random）：随机选取，压力分布可能不均
- 权重：按实例性能配比权重，性能高者多分配
- 最少活跃（LeastActive）：转发给活跃请求数最少的实例
- 一致性哈希（ConsistentHash）：相同 key 请求固定实例，
  适合会话保持 / 本地缓存场景

选择建议：
- 一般业务：轮询 / 随机即可
- 性能差异大：加权轮询
- 有状态服务：一致性哈希

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-gateway</artifactId>
</dependency>

# application.yml
server:
  port: 8080
spring:
  application:
    name: gateway-service
  cloud:
    gateway:
      routes:
        - id: user-route
          uri: lb://user-service
          predicates:
            - Path=/api/user/**
          filters:
            - StripPrefix=1
        - id: order-route
          uri: lb://order-service
          predicates:
            - Path=/api/order/**

package com.example.gateway;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;

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

package com.example.gateway.filter;

import org.springframework.cloud.gateway.filter.GatewayFilterChain;
import org.springframework.cloud.gateway.filter.GlobalFilter;
import org.springframework.core.Ordered;
import org.springframework.http.HttpStatus;
import org.springframework.stereotype.Component;
import org.springframework.web.server.ServerWebExchange;
import reactor.core.publisher.Mono;

@Component
public class AuthGlobalFilter implements GlobalFilter, Ordered {

    @Override
    public Mono<Void> filter(ServerWebExchange exchange,
                             GatewayFilterChain chain) {
        String token = exchange.getRequest()
                .getHeaders().getFirst("Authorization");
        if (token == null || token.isEmpty()) {
            exchange.getResponse().setStatusCode(HttpStatus.UNAUTHORIZED);
            return exchange.getResponse().setComplete();
        }
        return chain.filter(exchange);
    }

    @Override
    public int getOrder() {
        return -100; // 数字越小优先级越高
    }
}

# application.yml
spring:
  cloud:
    gateway:
      default-filters:
        - name: RequestRateLimiter
          args:
            redis-rate-limiter.replenishRate: 10   # 每秒补充令牌数
            redis-rate-limiter.burstCapacity: 20   # 桶容量
            redis-rate-limiter.requestedTokens: 1  # 每次请求消耗
      globalcors:
        cors-configurations:
          '[/**]':
            allowedOriginPatterns: "*"
            allowedMethods: "*"
            allowedHeaders: "*"
            allowCredentials: true

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-config-server</artifactId>
</dependency>

# application.yml（config-server）
server:
  port: 8888
spring:
  application:
    name: config-server
  cloud:
    config:
      server:
        git:
          uri: https://github.com/example/config-repo
          default-label: main

package com.example.configserver;

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.cloud.config.server.EnableConfigServer;

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

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-config</artifactId>
</dependency>

# bootstrap.yml（order-service）
spring:
  application:
    name: order-service
  profiles:
    active: dev
  cloud:
    config:
      uri: http://localhost:8888
      fail-fast: true

# Git 仓库中的 order-service-dev.yml：
# spring:
#   datasource:
#     url: jdbc:mysql://localhost:3306/order_dev
#     username: root
#     password: 123456

<!-- 依赖 -->
<dependency>
  <groupId>org.springframework.boot</groupId>
  <artifactId>spring-boot-starter-actuator</artifactId>
</dependency>
<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-bus-amqp</artifactId>
</dependency>

# application.yml
management:
  endpoints:
    web:
      exposure:
        include: refresh,busrefresh

# 手动刷新单个服务
curl -X POST http://localhost:8082/actuator/refresh

# 广播刷新所有订阅服务（通过 MQ）
curl -X POST http://localhost:8082/actuator/busrefresh

<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring-cloud-starter-alibaba-sentinel</artifactId>
  <version>2023.0.1.0</version>
</dependency>

# application.yml
spring:
  cloud:
    sentinel:
      transport:
        dashboard: localhost:8080   # Sentinel 控制台
        port: 8719                  # 客户端与控制台通信端口
      eager: true

# 启动 Sentinel 控制台
java -Dserver.port=8080 -Dcsp.sentinel.dashboard.server=localhost:8080 \
     -Dproject.name=sentinel-dashboard -jar sentinel-dashboard.jar

# 流控规则
# 资源：GET:/api/order/list
# 阈值类型：QPS，单机阈值 100
# 超出 100 QPS 时，超出请求被拒绝（默认快速失败）

# 熔断规则
# 资源：GET:/api/user/{id}
# 统计时长 1000ms，最小请求数 5
# 异常比例 0.5 → 调用失败比例超 50% 时熔断 10 秒
# 熔断期间调用直接进入 fallback

// 代码中使用 @SentinelResource 定义资源与降级逻辑
@SentinelResource(value = "getOrderList",
        fallback = "listFallback")
public List<Order> list() {
    return orderRepository.findAll();
}

public List<Order> listFallback(Throwable t) {
    return Collections.emptyList();
}

# 热点参数限流（Sentinel 控制台 - 热点规则）
# 资源：getProductDetail
# 参数索引：0（productId）
# 参数例外项：productId=1001 → QPS 阈值 5
# 默认 QPS 阈值：50

// 代码
@SentinelResource("getProductDetail")
public Product getProductDetail(Long productId) {
    return productService.getById(productId);
}

# 系统自适应保护（系统规则）
# 入口 QPS 不超过 200
# 系统负载（Load）不超过 5.0
# CPU 使用率不超过 80%
# 平均 RT 不超过 500ms
# 并发线程数不超过 100

Seata 三大组件：
- TC（Transaction Coordinator）：全局事务协调者，独立部署
- TM（Transaction Manager）：事务发起方，开启/提交/回滚全局事务
- RM（Resource Manager）：参与事务的资源，管理分支事务

AT 模式两阶段：
阶段一：RM 执行业务 SQL，同时记录 undo_log 快照，
        本地事务提交（无锁等待）
阶段二：全局提交 → 异步删除 undo_log
        全局回滚 → 根据 undo_log 反向补偿 SQL

# 启动 TC（seata-server）
seata-server.sh -p 8091 -m file

<dependency>
  <groupId>com.alibaba.cloud</groupId>
  <artifactId>spring-cloud-starter-alibaba-seata</artifactId>
  <version>2023.0.1.0</version>
</dependency>

# application.yml
seata:
  registry:
    type: nacos
    nacos:
      server-addr: 127.0.0.1:8848
      namespace: ""
      group: SEATA_GROUP
      application: seata-server
  tx-service-group: my_test_tx_group

package com.example.orderservice.service;

import com.example.orderservice.feign.AccountClient;
import com.example.orderservice.feign.StockClient;
import io.seata.spring.annotation.GlobalTransactional;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final AccountClient accountClient;
    private final StockClient stockClient;

    public OrderService(AccountClient accountClient,
                        StockClient stockClient) {
        this.accountClient = accountClient;
        this.stockClient = stockClient;
    }

    @GlobalTransactional(name = "create-order-tx",
            rollbackFor = Exception.class)
    public void createOrder(Long userId, Long productId, int count) {
        // 1. 扣库存
        stockClient.deduct(productId, count);
        // 2. 扣余额
        accountClient.deduct(userId, 100 * count);
        // 3. 生成订单（本地事务）
        // 任一环节异常 → 全局回滚
    }
}

四种分布式事务模式对比：

| 模式 | 一致性 | 侵入性 | 性能 | 适用场景 |
|------|--------|--------|------|----------|
| XA   | 强一致 | 低（依赖数据库） | 低 | 银行转账等强一致 |
| AT   | 最终一致 | 低（undo_log 自动） | 中 | 通用业务，最常用 |
| TCC  | 最终一致 | 高（三接口） | 高 | 资金类高并发 |
| SAGA | 最终一致 | 中（状态机/编排） | 高 | 长事务、跨系统 |

选择建议：
- 通用微服务业务：AT 模式
- 高并发资金操作：TCC
- 复杂长流程：SAGA
- 强一致要求且低并发：XA

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-stream-rabbit</artifactId>
</dependency>

# application.yml
spring:
  cloud:
    stream:
      bindings:
        output:
          destination: order-event   # 交换机/主题名
          content-type: application/json

package com.example.orderservice.mq;

import org.springframework.cloud.stream.annotation.Output;
import org.springframework.cloud.stream.messaging.Source;
import org.springframework.messaging.MessageChannel;
import org.springframework.messaging.support.MessageBuilder;
import org.springframework.stereotype.Component;

@Component
public class OrderPublisher {

    private final MessageChannel output;

    public OrderPublisher(@Output(Source.OUTPUT) MessageChannel output) {
        this.output = output;
    }

    public void publish(String orderId) {
        output.send(MessageBuilder.withPayload(orderId).build());
        System.out.println("已发布订单事件：" + orderId);
    }
}

package com.example.inventoryservice.mq;

import org.springframework.cloud.stream.annotation.EnableBinding;
import org.springframework.cloud.stream.annotation.StreamListener;
import org.springframework.cloud.stream.messaging.Sink;
import org.springframework.stereotype.Component;

@Component
@EnableBinding(Sink.class)
public class OrderConsumer {

    @StreamListener(Sink.INPUT)
    public void onOrder(String orderId) {
        System.out.println("库存服务收到订单：" + orderId);
        // 扣减库存业务逻辑
    }
}

# application.yml
spring:
  cloud:
    stream:
      bindings:
        input:
          destination: order-event
          group: inventory-group   # 消费组：同组竞争消费
          content-type: text/plain

# application.yml
spring:
  cloud:
    stream:
      bindings:
        output:
          destination: order-event
          producer:
            partition-key-expression: payload.id
            partition-count: 3
        input:
          destination: order-event
          group: order-group
          consumer:
            max-attempts: 3               # 最大重试次数
            back-off-initial-interval: 1000
            back-off-multiplier: 2.0

# 分区后同一订单的消息固定进入同一分区实例，
# 保证顺序消费；重试失败进入 DLQ（死信队列）

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-starter-sleuth</artifactId>
</dependency>

# 开启后日志格式
# 2026-08-22 10:00:00.123 [order-service,86f4a2b1c3,86f4a2b1c3,true]
# INFO  OrderController - 创建订单
# 字段含义：[服务名, traceId, spanId, 是否采样]

# 调用链示例：
# 网关 → order-service → user-service → database
# 三者日志中 traceId 相同，spanId 不同

<dependency>
  <groupId>org.springframework.cloud</groupId>
  <artifactId>spring-cloud-sleuth-zipkin</artifactId>
</dependency>

# application.yml
spring:
  zipkin:
    base-url: http://localhost:9411
  sleuth:
    sampler:
      probability: 1.0   # 采样率，生产建议 0.1

# 启动 Zipkin Server
docker run -d -p 9411:9411 openzipkin/zipkin

# 访问 http://localhost:9411 查看：
# - 按 trace 检索调用链
# - 依赖图展示服务间调用关系
# - 每个 span 的耗时与标签

package com.example.orderservice.trace;

import brave.Tracer;
import brave.Span;
import org.springframework.stereotype.Component;

@Component
public class TraceService {

    private final Tracer tracer;

    public TraceService(Tracer tracer) {
        this.tracer = tracer;
    }

    public void doBusiness(String orderId) {
        // 手动创建 Span 埋点
        Span span = tracer.nextSpan().name("cache-warm").start();
        try (brave.ScopedSpan ignored = tracer.startScopedSpan("save-order")) {
            System.out.println("执行业务：" + orderId);
            // 业务逻辑...
        } finally {
            span.finish();
        }
    }
}

// 异步链路传递：
// - 使用 Spring 的 Async 时 Sleuth 自动注入 TraceContext
// - 自建线程池建议使用 TraceableExecutorService 包装

架构设计：
┌─────────┐    ┌──────────────┐
│  网关    │───▶│ eureka-server │
│ gateway │    └──────────────┘
└────┬────┘           ▲
     │ lb://          │ 注册/发现
┌────▼─────┐  Feign  ┌─────┴─────┐
│ order-svc│────────▶│ user-svc  │
└────┬─────┘         └───────────┘
     │ Feign
┌────▼─────┐
│ stock-svc│
└──────────┘

每个服务依赖：
- spring-cloud-starter-netflix-eureka-client
- spring-cloud-starter-openfeign
- spring-boot-starter-web
- spring-cloud-starter-sleuth + zipkin（链路）

package com.example.orderservice.service;

import com.example.orderservice.entity.Order;
import com.example.orderservice.feign.StockClient;
import com.example.orderservice.feign.UserClient;
import com.example.orderservice.repository.OrderRepository;
import org.springframework.stereotype.Service;

@Service
public class OrderService {

    private final OrderRepository orderRepository;
    private final UserClient userClient;
    private final StockClient stockClient;

    public OrderService(OrderRepository orderRepository,
                        UserClient userClient,
                        StockClient stockClient) {
        this.orderRepository = orderRepository;
        this.userClient = userClient;
        this.stockClient = stockClient;
    }

    public Order create(Long userId, Long productId, int count) {
        // 1. 校验用户是否存在
        String user = userClient.getUser(userId);
        if (user == null || user.contains("不可用")) {
            throw new RuntimeException("用户不存在");
        }
        // 2. 扣减库存
        stockClient.deduct(productId, count);
        // 3. 创建本地订单
        Order order = new Order();
        order.setUserId(userId);
        order.setProductId(productId);
        order.setCount(count);
        return orderRepository.save(order);
    }
}

# gateway 路由
spring:
  cloud:
    gateway:
      routes:
        - id: order-route
          uri: lb://order-service
          predicates:
            - Path=/api/order/**
        - id: user-route
          uri: lb://user-service
          predicates:
            - Path=/api/user/**

# 发起下单请求
curl -X POST http://localhost:8080/api/order/create \
     -H "Content-Type: application/json" \
     -d '{"userId":1,"productId":100,"count":2}'

# 验证链路：
# 1. 各服务日志中 traceId 相同
# 2. Zipkin(http://localhost:9411) 搜索该 traceId
#    可见 网关→订单服务→用户服务/库存服务 调用树