C (一致性)
   / \
  /   \
 /     \
A       P
(可用性) (分区容错性)

只能选择 CA、CP 或 AP
但在分布式系统中 P 必须选择
所以实际选择只有 CP 或 AP

假设存在分布式系统：
    Node A ←──网络──→ Node B
    数据: X=1         数据: X=1

场景：网络分区（Node A 和 Node B 无法通信）

如果选择 CP（一致性 + 分区容错性）：
    Node A 收到更新请求 X=2
    → Node A 必须等待与 Node B 同步
    → 但网络分区无法同步
    → Node A 拒绝请求（牺牲可用性）
    ✓ 一致性保持 ✓ 分区容错

如果选择 AP（可用性 + 分区容错性）：
    Node A 收到更新请求 X=2
    → Node A 直接处理请求，返回成功
    → Node B 仍保留 X=1
    → 两个节点数据不一致
    ✓ 可用性保持 ✓ 分区容错 ✗ 一致性

不可能同时保持三者：
    如果要同时保持一致性和可用性 → 必须能同步
    → 但网络分区时无法同步
    → 矛盾！

场景一：电商订单系统
    → 订单数据必须一致
    → 选择 CP（或在 AP 基础上通过补偿保证最终一致）

场景二：电商商品详情
    → 商品详情可接受短暂不一致
    → 选择 AP（缓存 + 异步同步）

场景三：服务注册中心
    → Eureka（AP）：即使部分节点不可用，服务仍可发现
    → Consul（CP）：强一致性，适合对一致性要求高的场景

电商系统故障场景：
    ✓ 商品浏览（核心功能）→ 可用
    ✓ 下单支付（核心功能）→ 可用
    ✗ 推荐算法（非核心）→ 可降级
    ✗ 数据统计（非核心）→ 可延迟
    ✗ 实时搜索（非核心）→ 可降级

电商系统中的软状态：
    用户下单 → 订单状态 = "待支付"
    支付完成 → 订单状态 = "已支付"
              ↓
         库存扣减（异步）→ 可能延迟几秒
              ↓
         积分更新（异步）→ 可能延迟几分钟

在这个过程中：
- 订单显示"已支付"但积分未到账 → 软状态
- 经过一段时间后积分到账 → 最终一致

下单流程（遵循 BASE 理论）：

1. 用户提交订单
    → 订单服务创建订单（本地事务）
    → 发送"订单创建"事件（MQ）

2. 库存服务消费事件
    → 异步扣减库存
    → 如果库存扣减失败 → 发送补偿事件

3. 支付服务消费事件
    → 等待用户支付
    → 支付成功后更新订单状态

4. 对账服务（定时任务）
    → 每 5 分钟检查订单状态
    → 修复不一致的数据
    → 补偿遗漏的操作

@Service
public class OrderService {

    @Autowired
    private LocalMessageMapper messageMapper;
    @Autowired
    private JdbcTemplate jdbcTemplate;

    @Transactional
    public void createOrder(CreateOrderRequest request) {
        // 1. 创建订单（本地事务）
        Order order = new Order(request);
        orderMapper.insert(order);

        // 2. 写入本地消息表（与订单在同一事务中）
        LocalMessage message = new LocalMessage(
            "order_created",
            order.getId(),
            "PENDING"
        );
        messageMapper.insert(message);

        // 事务提交后，由定时任务扫描 PENDING 消息并发送到 MQ
    }

    @Scheduled(fixedDelay = 5000)  // 每 5 秒扫描一次
    public void sendPendingMessages() {
        List<LocalMessage> messages = messageMapper.selectByStatus("PENDING");
        for (LocalMessage msg : messages) {
            try {
                // 发送到 MQ
                mqProducer.send(msg.getTopic(), msg.getPayload());
                // 更新消息状态
                messageMapper.updateStatus(msg.getId(), "SENT");
            } catch (Exception e) {
                // 发送失败，保持 PENDING 状态，下次继续
                log.error("消息发送失败", e);
            }
        }
    }
}

单体架构                          微服务架构
┌─────────────────────────┐      ┌──────────┐
│                         │      │ 用户服务  │ ← 独立部署
│    一个大的应用           │      └──────────┘
│    所有功能耦合在一起      │      ┌──────────┐
│                         │      │ 订单服务  │ ← 独立部署
│    一个数据库             │      └──────────┘
│                         │      ┌──────────┐
└─────────────────────────┘      │ 支付服务  │ ← 独立部署
                                 └──────────┘
                                 ┌──────────┐
                                 │ 库存服务  │ ← 独立部署
                                 └──────────┘

                    ┌─────────────────┐
                    │   API 网关       │ ← 统一入口
                    └────────┬────────┘
                             │
              ┌──────────────┼──────────────┐
              │              │              │
              ▼              ▼              ▼
     ┌────────────┐  ┌────────────┐  ┌────────────┐
     │  用户服务   │  │  订单服务   │  │  支付服务   │
     └─────┬──────┘  └─────┬──────┘  └─────┬──────┘
           │               │               │
           ▼               ▼               ▼
     ┌────────────┐  ┌────────────┐  ┌────────────┐
     │ 用户数据库  │  │ 订单数据库  │  │ 支付数据库  │
     └────────────┘  └────────────┘  └────────────┘
              ↑              ↑              ↑
              │              │              │
        ┌─────┴──────────────┴──────────────┴─────┐
        │         基础设施层（微服务组件）           │
        │  服务发现 | 配置中心 | 熔断降级 | 链路追踪   │
        └───────────────────────────────────────────┘

// Nacos 服务提供方
@SpringBootApplication
@EnableDiscoveryClient
public class OrderServiceApplication { ... }

// Nacos 服务消费方（负载均衡调用）
@Bean
@LoadBalanced
public RestTemplate restTemplate() {
    return new RestTemplate();
}

// 使用服务名调用
restTemplate.getForObject("http://user-service/users/" + userId, User.class);

// Seata AT 模式（自动补偿）
@GlobalTransactional
public void createOrder(CreateOrderRequest request) {
    // 1. 调用库存服务扣减库存
    stockService.deduct(request.getProductId(), request.getQuantity());
    // 2. 调用订单服务创建订单
    orderService.create(request);
    // Seata 自动管理事务边界和补偿
}

// Sentinel 熔断降级配置
@Configuration
public class SentinelConfig {

    @Bean
    public SentinelResourceFactoryBean sentinelFactory() {
        return new SentinelResourceFactoryBean()
            .setUrl("http://localhost:8080")
            .setRules(loadRules());
    }

    private List<FlowRule> loadRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("getUser");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(100);  // QPS 限制为 100
        rules.add(rule);
        return rules;
    }
}

// SkyWalking 接入（无需代码侵入）
// 1. 下载 SkyWalking Agent
// 2. 在启动时通过 -javaagent 参数加载
// -javaagent:/path/to/skywalking-agent.jar
// 3. 自动追踪所有服务调用

# Nacos 配置中心
spring:
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: prod
        group: DEFAULT_GROUP
        file-extension: yaml

// Spring Cloud Gateway 配置
@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            // 路由到订单服务
            .route("order_service", r -> r
                .path("/api/orders/**")
                .uri("lb://order-service")
                .filters(f -> f
                    .stripPrefix(2)
                    .filter(new AuthFilter())
                )
            )
            // 路由到用户服务
            .route("user_service", r -> r
                .path("/api/users/**")
                .uri("lb://user-service")
                .filters(f -> f.stripPrefix(2))
            )
            .build();
    }
}

// Feign 声明式 HTTP 客户端
@FeignClient(name = "user-service")
public interface UserClient {

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

    @PostMapping("/users")
    User createUser(@RequestBody CreateUserRequest request);
}

// 使用 Feign 客户端
@Service
public class OrderService {

    @Autowired
    private UserClient userClient;

    public Order createOrder(CreateOrderRequest request) {
        // 同步调用用户服务
        User user = userClient.getUser(request.getUserId());
        // ...
    }
}

┌──────────────┐
│  注册中心     │ ← 存储所有服务的地址信息
│ (Nacos/Eureka)│
└──────┬───────┘
       │
  注册/发现/心跳
       │
  ┌────┴────┐
  │         │
  ▼         ▼
┌────┐   ┌────┐
│服务A│   │服务B│ ← 服务提供者（注册）
└────┘   └────┘

┌────┐   ┌────┐
│服务C│   │服务D│ ← 服务消费者（发现）
└────┘   └────┘

1. 服务启动
    │
    ▼
2. 读取自身配置（服务名、端口、IP）
    │
    ▼
3. 向注册中心发送注册请求
    │
    ▼
4. 注册中心保存服务实例信息
    │
    ▼
5. 服务开始提供服务
    │
    ▼
6. 定时发送心跳（默认 10 秒）
    │
    ▼
7. 注册中心更新实例的最后活跃时间

1. 消费者启动
    │
    ▼
2. 向注册中心请求目标服务的实例列表
    │
    ▼
3. 注册中心返回可用实例列表
    │
    ▼
4. 消费者将列表缓存到本地
    │
    ▼
5. 定时刷新（默认 30 秒）或事件推送更新
    │
    ▼
6. 负载均衡选择实例
    │
    ▼
7. 发起 RPC/HTTP 调用

正常情况：
    服务提供者 → 心跳 → 注册中心（更新最后活跃时间）
    注册中心 → 心跳 → 服务提供者（可选，双向检测）

异常情况：
    服务提供者停止心跳（宕机或网络故障）
    → 注册中心在 3 个心跳周期后标记实例为不可用
    → 通知消费者更新服务列表
    → 消费者不再调用该实例

# 服务提供者配置
spring:
  application:
    name: order-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: prod
        group: DEFAULT_GROUP

# 服务消费者配置
spring:
  application:
    name: user-service
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848

// 服务提供者
@SpringBootApplication
@EnableDiscoveryClient  // 开启服务注册与发现
public class OrderServiceApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderServiceApplication.class, args);
    }
}

// 服务消费者
@RestController
public class UserController {

    @Autowired
    private DiscoveryClient discoveryClient;  // 获取服务实例

    @GetMapping("/services")
    public List<String> getServices() {
        List<ServiceInstance> instances = discoveryClient.getInstances("order-service");
        return instances.stream()
            .map(i -> i.getHost() + ":" + i.getPort())
            .collect(Collectors.toList());
    }

    // 使用负载均衡的 RestTemplate 调用
    @Bean
    @LoadBalanced
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }

    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable Long id) {
        // 通过服务名调用（Ribbon 自动负载均衡）
        return restTemplate.getForObject(
            "http://order-service/orders/" + id, Order.class);
    }
}

Eureka Server (Peer-to-Peer)
    │  ← 对等集群，无主从
    ├── Eureka Server 1
    ├── Eureka Server 2
    └── Eureka Server 3
    │
    ▼
Eureka Client（服务提供者/消费者）
    → 注册 → 任意 Server
    → 心跳 → 注册的 Server
    → 拉取 → 任意 Server 获取服务列表

Nacos Server (主从 + 只读)
    │  ← 主从模式，支持读写分离
    ├── Nacos Server (Leader) → 处理写入
    ├── Nacos Server (Follower) → 同步 + 处理读
    └── Nacos Server (ReadOnly) → 仅处理读
    │
    ▼
Nacos Client（服务提供者/消费者）
    → 注册 → Leader Server
    → 心跳 → 注册的 Server
    → 拉取/推送 → 任意 Server

// Nacos 切换 CP/AP 模式
// 在 application.properties 中配置集群模式
spring.cloud.nacos.discovery.cluster.type=ap  // AP 模式（默认）
spring.cloud.nacos.discovery.cluster.type=cp  // CP 模式

# 注册中心配置
eureka:
  client:
    service-url:
      defaultZone: http://eureka-server1:8761/eureka,http://eureka-server2:8761/eureka
    register-with-eureka: true
    fetch-registry: true

# 服务提供者
@EnableDiscoveryClient
@SpringBootApplication
public class OrderServiceApplication { ... }

# 注册中心配置
spring:
  cloud:
    nacos:
      discovery:
        server-addr: localhost:8848
        namespace: prod
        group: ORDER_GROUP
        cluster-name: order-cluster

# 同时作为配置中心
spring:
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: prod
        group: DEFAULT_GROUP
        file-extension: yaml

@EnableDiscoveryClient
@SpringBootApplication
public class OrderServiceApplication { ... }

1. 服务启动
    │
    ▼
2. 从配置中心拉取初始配置
    │
    ▼
3. 监听配置变更（长轮询/WebSocket）
    │
    ▼
4. 配置中心检测到变更
    │
    ▼
5. 推送变更到订阅的服务
    │
    ▼
6. 服务收到变更 → 刷新配置 → 生效

服务 A ──长轮询请求──▶ 配置中心
    │                      │
    │◀── 有变更？── 等待中 ──│
    │                      │
    │              配置变更！
    │                      │
    │◀── 返回变更通知 ──────│
    │                      │
    │ 处理变更              │
    │                      │
    │── 重新长轮询 ──────▶ │

# bootstrap.yml（注意用 bootstrap 而非 application.yml）
spring:
  application:
    name: order-service
  cloud:
    nacos:
      config:
        server-addr: localhost:8848
        namespace: prod
        group: DEFAULT_GROUP
        file-extension: yaml

// 配置类
@Configuration
@RefreshScope  // 支持动态刷新
public class OrderConfig {

    @Value("${order.timeout:30}")
    private int timeout;

    @Value("${order.max-retry:3}")
    private int maxRetry;

    // getter...
}

// 使用配置
@Service
public class OrderService {

    @Autowired
    private OrderConfig orderConfig;

    public void process() {
        int timeout = orderConfig.getTimeout();
        // ...
    }
}

@Configuration
public class ApolloConfig {

    @Value("${timeout:30}")
    private int timeout;
}

客户端（浏览器/移动端）
        │
        ▼
   ┌──────────┐
   │ API 网关  │ ← 统一入口
   └────┬─────┘
        │
   ┌────┼────┬────────┬────────┐
   │    │    │        │        │
   ▼    ▼    ▼        ▼        ▼
 用户  订单  支付  库存  通知
 服务  服务  服务  服务  服务

@Configuration
public class GatewayConfig {

    @Bean
    public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
        return builder.routes()
            // 路由到订单服务
            .route("order_service", r -> r
                .path("/api/orders/**")
                .uri("lb://order-service")
                .filters(f -> f
                    .stripPrefix(2)
                    .filter(authFilter())
                    .filter(rateLimitFilter())
                )
            )
            // 路由到用户服务
            .route("user_service", r -> r
                .path("/api/users/**")
                .uri("lb://user-service")
                .filters(f -> f.stripPrefix(2))
            )
            .build();
    }

    // 鉴权过滤器
    public AuthFilter authFilter() {
        return new AuthFilter();
    }

    // 限流过滤器
    public RateLimitFilter rateLimitFilter() {
        return new RateLimitFilter(100, 1000); // 100 QPS
    }
}

# YAML 配置方式
spring:
  cloud:
    gateway:
      routes:
        - id: order_service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - StripPrefix=2
            - name: Auth
            - name: RequestRateLimiter
              args:
                redis-rate-limiter.replenishRate: 100
                redis-rate-limiter.burstCapacity: 200

场景：2 个实例，A 性能是 B 的 2 倍

轮询分配：
    A ← 请求 1（空闲）
    B ← 请求 2（忙）
    A ← 请求 3（空闲）
    B ← 请求 4（忙）
    A ← 请求 5（空闲）
    B ← 请求 6（忙）

结果：A 利用率低，B 过载

# 配置使用的负载均衡算法
# 轮询（默认）
order-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.RoundRobinRule

# 加权轮询
order-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.WeightedResponseTimeRule

# 最少连接
order-service:
  ribbon:
    NFLoadBalancerRuleClassName: com.netflix.loadbalancer.BestAvailableRule

// 自定义负载均衡规则
@Configuration
public class LoadBalancerConfig {

    @Bean
    public IRule weightedRoundRobinRule() {
        return new WeightedRoundRobinRule();
    }
}

┌─────────────────────────────────────────────┐
│                  服务消费者                   │
│  ┌─────────┐  ┌─────────┐  ┌─────────────┐  │
│  │ 动态代理 │→│ Filter链│→│ LoadBalance │  │
│  └─────────┘  └─────────┘  └─────────────┘  │
│        │                                        │
│        ▼                                        │
│  ┌─────────┐  ┌─────────┐  ┌─────────────┐  │
│  │ 序列化  │→│ 协议栈  │→│   Netty     │  │
│  └─────────┘  └─────────┘  └─────────────┘  │
└──────────────────┬──────────────────────────┘
                   │ 网络传输
                   ▼
┌─────────────────────────────────────────────┐
│                  服务提供者                   │
│  ┌─────────┐  ┌─────────┐  ┌─────────────┐  │
│  │  Netty  │→│ 协议栈  │→│   反序列化   │  │
│  └─────────┘  └─────────┘  └─────────────┘  │
│        │                                        │
│        ▼                                        │
│  ┌─────────┐  ┌─────────┐  ┌─────────────┐  │
│  │ 反射调用 │←│ Filter链│←│   负载均衡   │  │
│  └─────────┘  └─────────┘  └─────────────┘  │
└─────────────────────────────────────────────┘

1. 消费者创建代理对象（Proxy）
    → 基于 Java 动态代理生成接口的实现类

2. 代理对象发起方法调用
    → 拦截方法调用，构建 RPC 请求

3. Cluster 选择策略
    → Failover（重试）/ Failfast（快速失败）/ Failsafe（安全失败）

4. 负载均衡选择实例
    → Random / RoundRobin / ConsistentHash

5. Filter 链处理
    → 序列化、鉴权、限流、日志等

6. Netty 发送请求
    → 使用 Dubbo 协议（二进制）

7. Provider 接收请求
    → 反序列化 → 反射调用 → 序列化结果

8. Consumer 接收响应
    → 反序列化 → 返回结果

META-INF/services/com.example.Router
    → RandomRouter
    → RoundRobinRouter
    → ConsistentHashRouter

// 加载所有实现
ServiceLoader<Router> loader = ServiceLoader.load(Router.class);
for (Router router : loader) {
    // 遍历所有实现
}
// 问题：一次性加载所有实现，不支持按需选择

META-INF/dubbo/com.example.Router
    random=com.example.RandomRouter
    roundrobin=com.example.RoundRobinRouter
    hash=com.example.ConsistentHashRouter

// 按需加载指定实现
Router router = ExtensionLoader.getExtensionLoader(Router.class)
    .getExtension("random");  // 仅加载 RandomRouter

// 自适应扩展
@SPI("random")
public interface Router { ... }

// 自动选择默认实现
Router router = ExtensionLoader.getExtensionLoader(Router.class)
    .getDefaultExtension();

// 启动类
@SpringBootApplication
@EnableDubbo(scanBasePackages = "com.example.order")
public class OrderProviderApplication {
    public static void main(String[] args) {
        SpringApplication.run(OrderProviderApplication.class, args);
    }
}

// 服务实现
@DubboService(version = "1.0.0", group = "order")
public class OrderServiceImpl implements OrderService {

    @Override
    public Order getOrder(Long id) {
        return orderMapper.selectById(id);
    }
}

// 服务引用
@RestController
public class OrderController {

    @DubboReference(version = "1.0.0", group = "order")
    private OrderService orderService;

    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable Long id) {
        return orderService.getOrder(id);
    }
}

场景判断：
    ├── 内部服务间通信 → RPC（Dubbo/gRPC）
    │   ├── 性能要求高 → RPC
    │   ├── 调用频繁 → RPC
    │   └── 服务数量多 → RPC（注册中心治理）
    │
    ├── 对外开放 API → HTTP（RESTful）
    │   ├── 第三方调用 → HTTP
    │   ├── 跨平台 → HTTP
    │   └── 调试方便 → HTTP
    │
    └── 混合场景 → HTTP + RPC
        ├── API 网关（HTTP） → 内部服务（RPC）
        └── BFF（HTTP） → 微服务（RPC）

┌─────────────────────────────────────────┐
│            Client Stub                  │
│  (由 .proto 文件生成)                     │
│                                         │
│  ┌─────────────────────────────────┐    │
│  │  Protobuf 序列化                 │    │
│  └─────────────────────────────────┘    │
│  ┌─────────────────────────────────┐    │
│  │  HTTP/2 多路复用客户端           │    │
│  └─────────────────────────────────┘    │
└──────────────────┬──────────────────────┘
                   │ HTTP/2
                   ▼
┌──────────────────┬──────────────────────┐
│            Server Stub                  │
│  (由 .proto 文件生成)                     │
│                                         │
│  ┌─────────────────────────────────┐    │
│  │  Protobuf 反序列化               │    │
│  └─────────────────────────────────┘    │
│  ┌─────────────────────────────────┐    │
│  │  业务逻辑实现                    │    │
│  └─────────────────────────────────┘    │
└─────────────────────────────────────────┘

syntax = "proto3";

package order;

service OrderService {
    // 一元 RPC
    rpc GetOrder(GetOrderRequest) returns (OrderResponse);
    // 服务器流式
    rpc ListOrders(ListOrdersRequest) returns (stream OrderResponse);
    // 双向流式
    rpc ProcessOrders(stream OrderRequest) returns (stream OrderResponse);
}

message GetOrderRequest {
    int64 id = 1;
}

message OrderResponse {
    int64 id = 1;
    string status = 2;
    double amount = 3;
}

# 使用 protoc 生成 Java 代码
protoc --proto_path=. --java_out=. order.proto
protoc --proto_path=. --grpc-java_out=. order.proto

public class OrderServiceImpl extends OrderServiceGrpc.OrderServiceImplBase {
    @Override
    public void getOrder(GetOrderRequest request,
                         StreamObserver<OrderResponse> responseObserver) {
        OrderResponse response = OrderResponse.newBuilder()
            .setId(request.getId())
            .setStatus("PAID")
            .setAmount(99.9)
            .build();
        responseObserver.onNext(response);
        responseObserver.onCompleted();
    }
}

public class OrderClient {
    public static void main(String[] args) {
        ManagedChannel channel = ManagedChannelBuilder
            .forAddress("localhost", 50051)
            .usePlaintext()
            .build();

        OrderServiceGrpc.OrderServiceBlockingStub stub =
            OrderServiceGrpc.newBlockingStub(channel);

        GetOrderRequest request = GetOrderRequest.newBuilder()
            .setId(1L)
            .build();

        OrderResponse response = stub.getOrder(request);
        System.out.println("Order: " + response);

        channel.shutdown();
    }
}

┌──────────────────────────────────────────────┐
│              Spring Cloud 微服务架构            │
│                                              │
│  ┌────────┐  ┌────────┐  ┌────────┐  ┌────┐ │
│  │ 网关    │  │ 服务    │  │ 配置    │  │安全│ │
│  │Gateway │  │发现     │  │中心     │  │    │ │
│  └────────┘  └────────┘  └────────┘  └────┘ │
│                                              │
│  ┌────────┐  ┌────────┐  ┌────────┐  ┌────┐ │
│  │ RPC    │  │ 负载    │  │ 熔断    │  │链路│ │
│  │ Feign  │  │均衡     │  │降级     │  │追踪│ │
│  └────────┘  └────────┘  └────────┘  └────┘ │
│                                              │
│  ┌────────┐  ┌────────┐  ┌────────┐         │
│  │分布式  │  │ 消息    │  │ 任务    │         │
│  │事务    │  │驱动     │  │调度     │         │
│  └────────┘  └────────┘  └────────┘         │
│                                              │
└──────────────────────────────────────────────┘

// Ribbon + RestTemplate
@Bean
@LoadBalanced  // 开启 Ribbon 负载均衡
public RestTemplate restTemplate() {
    return new RestTemplate();
}

// 使用服务名调用
User user = restTemplate.getForObject(
    "http://user-service/users/" + userId, User.class);

// Feign 声明式调用
@FeignClient(name = "user-service")
public interface UserClient {

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

    @PostMapping("/users")
    User createUser(@RequestBody CreateUserRequest request);
}

// 直接调用接口方法
@Service
public class OrderService {

    @Autowired
    private UserClient userClient;

    public Order createOrder(CreateOrderRequest request) {
        User user = userClient.getUser(request.getUserId());
        // ...
    }
}

@HystrixCommand(
    commandKey = "getUser",
    fallbackMethod = "getUserFallback",
    commandProperties = {
        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20"),
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50")
    }
)
public User getUser(Long id) {
    return userClient.getUser(id);
}

public User getUserFallback(Long id) {
    return new User(-1L, "Default User");
}

// 1. QPS 限流
FlowRule flowRule = new FlowRule();
flowRule.setResource("getUser");
flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
flowRule.setCount(100);  // QPS 上限 100

// 2. 熔断降级
DegradeRule degradeRule = new DegradeRule();
degradeRule.setResource("getUser");
degradeRule.setGrade(RuleConstant.DEGRADE_GRADE_RT);  // 慢调用比例
degradeRule.setCount(1000);  // RT 超过 1 秒
degradeRule.setTimeWindow(10);  // 熔断时长 10 秒

// 3. 热点参数防护
ParamFlowRule paramRule = new ParamFlowRule();
paramRule.setResource("getUser");
paramRule.setParamIndex(0);  // 第一个参数
paramRule.setCount(10);  // 单值限流 10 QPS

协调者 ──Prepare──▶ 参与者 A (CanCommit?)
       ──Prepare──▶ 参与者 B (CanCommit?)

       A: Yes ✓    B: Yes ✓

       ──Commit──▶ A (DoCommit)
       ──Commit──▶ B (DoCommit)

       ✓ 完成

协调者 ──CanCommit──▶ 参与者 (检查)
       ──PreCommit──▶ 参与者 (准备)
       ──DoCommit──▶ 参与者 (提交)

Try 阶段：预留资源
    ├── 账户服务：冻结 100 元
    └── 库存服务：冻结 2 件商品

Confirm 阶段：确认提交
    ├── 账户服务：扣减 100 元（解冻 → 扣减）
    └── 库存服务：扣减 2 件商品（解冻 → 扣减）

Cancel 阶段：取消回滚
    ├── 账户服务：解冻 100 元
    └── 库存服务：解冻 2 件商品

步骤 1：创建订单（正向） → 补偿：取消订单
步骤 2：扣减库存（正向） → 补偿：恢复库存
步骤 3：扣减积分（正向） → 补偿：恢复积分
步骤 4：发送通知（正向） → 补偿：撤回通知

如果步骤 3 失败 → 执行补偿 2 → 补偿 1

1. 本地事务：创建订单 + 写消息表（同一数据库）
2. 定时任务：扫描消息表，发送到 MQ
3. 消费者：消费消息，执行业务
4. 补偿：定期对账，修复不一致

1. 发送半消息（对消费者不可见）
2. 执行本地事务
3. 根据结果提交/回滚消息
4. 回查机制：超时后 Broker 回查本地事务

@GlobalTransactional
public void createOrder(CreateOrderRequest request) {
    // 1. 调用库存服务（自动代理）
    stockService.deduct(request.getProductId(), request.getQuantity());
    // 2. 调用订单服务（自动代理）
    orderService.create(request);
    // Seata 自动管理事务边界和 undo log
}

// Try：预留资源
@Try
public void tryDeductStock(Long productId, int quantity) {
    // 冻结库存
    stockMapper.freeze(productId, quantity);
}

// Confirm：确认提交
@Confirm
public void confirmDeductStock(Long productId, int quantity) {
    // 扣减冻结库存
    stockMapper.deductFrozen(productId, quantity);
}

// Cancel：取消回滚
@Cancel
public void cancelDeductStock(Long productId, int quantity) {
    // 解冻库存
    stockMapper.unfreeze(productId, quantity);
}

优点：强一致性，实现相对简单
缺点：参与者阻塞等待，协调者单点故障
场景：数据库分布式事务（如跨库更新）、XA 事务

优点：减少阻塞时间，有超时机制
缺点：实现复杂，仍无法完全解决脑裂
场景：对一致性要求高且需要减少阻塞的场景

优点：不依赖事务协调器，灵活性高
缺点：业务侵入性强，每个服务需要实现 3 个方法
场景：核心交易（支付、订单、库存）、资金相关业务

优点：无锁机制，适合长流程
缺点：补偿逻辑复杂，可能部分成功
场景：订单→支付→物流→通知等长流程

优点：实现简单，性能好，成熟可靠
缺点：定时扫描有延迟，增加数据库表
场景：绝大多数互联网异步场景

优点：原生支持，无业务侵入，自动回查
缺点：依赖 RocketMQ，回查有延迟
场景：RocketMQ 用户的首选方案

需要分布式事务？
    │
    ├── 是 → 对一致性要求极高？（如银行转账）
    │   └── 是 → 2PC 或 TCC
    │
    ├── 需要长流程？（如订单-支付-物流）
    │   └── 是 → Saga
    │
    ├── 使用 RocketMQ？
    │   └── 是 → RocketMQ 事务消息
    │
    ├── 大多数场景
    │   └── 本地消息表
    │
    └── 简单场景
        └── 本地消息表或最终一致性即可

协调者 ──Prepare──▶ 参与者 A (CanCommit?)
       ──Prepare──▶ 参与者 B (CanCommit?)

       A: Yes ✓    B: Yes ✓

       ──Commit──▶ A (DoCommit)
       ──Commit──▶ B (DoCommit)

       ✓ 完成

协调者 ──CanCommit──▶ 参与者 (检查)
       ──PreCommit──▶ 参与者 (准备)
       ──DoCommit──▶ 参与者 (提交)

Try 阶段：预留资源
    ├── 账户服务：冻结 100 元
    └── 库存服务：冻结 2 件商品

Confirm 阶段：确认提交
    ├── 账户服务：扣减 100 元（解冻 → 扣减）
    └── 库存服务：扣减 2 件商品（解冻 → 扣减）

Cancel 阶段：取消回滚
    ├── 账户服务：解冻 100 元
    └── 库存服务：解冻 2 件商品

步骤 1：创建订单（正向） → 补偿：取消订单
步骤 2：扣减库存（正向） → 补偿：恢复库存
步骤 3：扣减积分（正向） → 补偿：恢复积分
步骤 4：发送通知（正向） → 补偿：撤回通知

如果步骤 3 失败 → 执行补偿 2 → 补偿 1

1. 本地事务：创建订单 + 写消息表（同一数据库）
2. 定时任务：扫描消息表，发送到 MQ
3. 消费者：消费消息，执行业务
4. 补偿：定期对账，修复不一致

1. 发送半消息（对消费者不可见）
2. 执行本地事务
3. 根据结果提交/回滚消息
4. 回查机制：超时后 Broker 回查本地事务

@GlobalTransactional
public void createOrder(CreateOrderRequest request) {
    // 1. 调用库存服务（自动代理）
    stockService.deduct(request.getProductId(), request.getQuantity());
    // 2. 调用订单服务（自动代理）
    orderService.create(request);
    // Seata 自动管理事务边界和 undo log
}

// Try：预留资源
@Try
public void tryDeductStock(Long productId, int quantity) {
    // 冻结库存
    stockMapper.freeze(productId, quantity);
}

// Confirm：确认提交
@Confirm
public void confirmDeductStock(Long productId, int quantity) {
    // 扣减冻结库存
    stockMapper.deductFrozen(productId, quantity);
}

// Cancel：取消回滚
@Cancel
public void cancelDeductStock(Long productId, int quantity) {
    // 解冻库存
    stockMapper.unfreeze(productId, quantity);
}

优点：强一致性，实现相对简单
缺点：参与者阻塞等待，协调者单点故障
场景：数据库分布式事务（如跨库更新）、XA 事务

优点：减少阻塞时间，有超时机制
缺点：实现复杂，仍无法完全解决脑裂
场景：对一致性要求高且需要减少阻塞的场景

优点：不依赖事务协调器，灵活性高
缺点：业务侵入性强，每个服务需要实现 3 个方法
场景：核心交易（支付、订单、库存）、资金相关业务

优点：无锁机制，适合长流程
缺点：补偿逻辑复杂，可能部分成功
场景：订单→支付→物流→通知等长流程

优点：实现简单，性能好，成熟可靠
缺点：定时扫描有延迟，增加数据库表
场景：绝大多数互联网异步场景

优点：原生支持，无业务侵入，自动回查
缺点：依赖 RocketMQ，回查有延迟
场景：RocketMQ 用户的首选方案

需要分布式事务？
    │
    ├── 是 → 对一致性要求极高？（如银行转账）
    │   └── 是 → 2PC 或 TCC
    │
    ├── 需要长流程？（如订单-支付-物流）
    │   └── 是 → Saga
    │
    ├── 使用 RocketMQ？
    │   └── 是 → RocketMQ 事务消息
    │
    ├── 大多数场景
    │   └── 本地消息表
    │
    └── 简单场景
        └── 本地消息表或最终一致性即可

String uuid = UUID.randomUUID().toString();
// 示例：550e8400-e29b-41d4-a716-446655440000

CREATE TABLE id_generator (
    id BIGINT AUTO_INCREMENT PRIMARY KEY,
    biz_type VARCHAR(50)
);

// 从数据库获取 ID 段
// 数据库表：id_segment
// biz_type | max_id | step
// order    | 1000    | 100

// 内存中缓存 ID 段
// 当前段：[1001, 1100]
// 用完后从数据库获取下一段：[1101, 1200]

public class SnowflakeIdGenerator {
    private long sequence = 0L;
    private long lastTimestamp = -1L;

    // 生成 ID
    public synchronized long nextId() {
        long timestamp = System.currentTimeMillis() - EPOCH;

        if (timestamp < lastTimestamp) {
            throw new RuntimeException("时钟回拨");
        }

        if (timestamp == lastTimestamp) {
            sequence = (sequence + 1) & SEQUENCE_MASK;
            if (sequence == 0) {
                timestamp = waitNextMillis(timestamp);
            }
        } else {
            sequence = 0L;
        }

        lastTimestamp = timestamp;

        return ((timestamp & TIMESTAMP_MASK) << TIMESTAMP_SHIFT)
            | (workerId << WORKER_ID_SHIFT)
            | (datacenterId << DATACENTER_ID_SHIFT)
            | sequence;
    }
}

-- Redis Lua 脚本
local counter = redis.call('INCR', KEYS[1])
return counter

64 位 Long 型 ID（雪花算法结构）：

┌───┬───────────────────────────────────────────────────────────────────────┬─────┬─────┬────────────┐
│   │                          41 位时间戳                                  │     │     │            │
│ 0 │ ┌──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┬──┐ │ 5位 │ 5位 │   12位     │
│   │ │ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ts│ │数据 │机器 │  序列号    │
│   │ └──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┴──┘ │中心 │标识 │            │
│   │                          毫秒级时间戳                                │     │     │            │
└───┴───────────────────────────────────────────────────────────────────────┴─────┴─────┴────────────┘
 ↑                                                                                                                                        ↑
 符号位（0，正数）                                                                                                              低位序列号

时间戳：41 位 → 支持约 69 年（相对于自定义起始时间戳）
数据中心：5 位 → 0-31
机器标识：5 位 → 0-31
序列号：12 位 → 0-4095（同一毫秒内 4096 个 ID）

// 常量定义
private static final long WORKER_ID_BITS = 5L;
private static final long DATACENTER_ID_BITS = 5L;
private static final long SEQUENCE_BITS = 12L;

private static final long MAX_WORKER_ID = ~(-1L << WORKER_ID_BITS);        // 31
private static final long MAX_DATACENTER_ID = ~(-1L << DATACENTER_ID_BITS);  // 31
private static final long WORKER_ID_SHIFT = SEQUENCE_BITS;                 // 12
private static final long DATACENTER_ID_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS;  // 17
private static final long TIMESTAMP_SHIFT = SEQUENCE_BITS + WORKER_ID_BITS + DATACENTER_ID_BITS;  // 22

private static final long SEQUENCE_MASK = ~(-1L << SEQUENCE_BITS);  // 4095

// 起始时间戳（自定义，2014-01-01）
private static final long EPOCH = 1489111610226L;

public synchronized long nextId() {
    long timestamp = timeGen();  // 获取当前时间戳（毫秒）

    if (timestamp < lastTimestamp) {
        // 时钟回拨处理
        long offset = lastTimestamp - timestamp;
        if (offset <= 5) {
            // 等待时钟追齐
            try { Thread.sleep(offset); } catch (InterruptedException e) { }
            timestamp = timeGen();
            if (timestamp < lastTimestamp) {
                throw new RuntimeException("时钟回拨超过 5ms");
            }
        } else {
            throw new RuntimeException("时钟回拨超过 5ms");
        }
    }

    if (timestamp == lastTimestamp) {
        // 同一毫秒内，序列号递增
        sequence = (sequence + 1) & SEQUENCE_MASK;
        if (sequence == 0) {
            // 序列号用完，等待下一毫秒
            timestamp = tilNextMillis(lastTimestamp);
        }
    } else {
        // 不同毫秒，序列号重置
        sequence = 0L;
    }

    lastTimestamp = timestamp;

    // 拼接 64 位 ID
    return ((timestamp - EPOCH) << TIMESTAMP_SHIFT)      // 时间戳部分
         | (datacenterId << DATACENTER_ID_SHIFT)        // 数据中心部分
         | (workerId << WORKER_ID_SHIFT)                // 机器标识部分
         | sequence;                                     // 序列号部分
}

┌──────────────────────────────────────────────────────────┐
│                     高可用架构                             │
│                                                          │
│  ┌────────────────────────────────────────────────────┐  │
│  │  客户端层                                          │  │
│  │  CDN → 负载均衡（Nginx/F5）→ 多活数据中心            │  │
│  └────────────────────────────────────────────────────┘  │
│                          │                               │
│  ┌────────────────────────────────────────────────────┐  │
│  │  应用层                                            │  │
│  │  API 网关（Gateway Cluster）→ 微服务集群            │  │
│  │  ┌────────┐ ┌────────┐ ┌────────┐                 │  │
│  │  │订单服务│ │用户服务│ │支付服务│  每个服务多实例    │  │
│  │  └────────┘ └────────┘ └────────┘                 │  │
│  │  熔断降级 | 限流 | 超时 | 重试                     │  │
│  └────────────────────────────────────────────────────┘  │
│                          │                               │
│  ┌────────────────────────────────────────────────────┐  │
│  │  数据层                                            │  │
│  │  MySQL（主从）| Redis（Cluster）| MQ（多副本）       │  │
│  │  数据多副本 | 读写分离 | 备份恢复                   │  │
│  └────────────────────────────────────────────────────┘  │
│                          │                               │
│  ┌────────────────────────────────────────────────────┐  │
│  │  监控层                                            │  │
│  │  全链路追踪 | 日志中心 | 指标监控 | 告警系统          │  │
│  └────────────────────────────────────────────────────┘  │
└──────────────────────────────────────────────────────────┘

// Sentinel 熔断降级配置
@Configuration
public class SentinelConfig {

    @Bean
    public SentinelResourceFactoryBean sentinelFactory() {
        return new SentinelResourceFactoryBean()
            .setUrl("http://localhost:8080")
            .setRules(loadFlowRules())
            .setDegradeRules(loadDegradeRules());
    }

    private List<FlowRule> loadFlowRules() {
        List<FlowRule> rules = new ArrayList<>();
        FlowRule rule = new FlowRule();
        rule.setResource("getUser");
        rule.setGrade(RuleConstant.FLOW_GRADE_QPS);
        rule.setCount(100);
        rules.add(rule);
        return rules;
    }

    private List<DegradeRule> loadDegradeRules() {
        List<DegradeRule> rules = new ArrayList<>();
        DegradeRule rule = new DegradeRule();
        rule.setResource("getUser");
        rule.setGrade(RuleConstant.DEGRADE_GRADE_SLOW_RATIO);
        rule.setCount(1000);
        rule.setTimeWindow(10);
        rules.add(rule);
        return rules;
    }
}

                    用户请求
                        │
                        ▼
                ┌─────────────┐
                │ 客户端优化   │ ← 前端缓存/本地缓存
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │   CDN 层     │ ← 静态资源缓存 + 就近访问
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │  接入层优化  │ ← Nginx 负载均衡 + 限流
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │  网关层优化  │ ← API 网关 + 缓存 + 降级
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │  应用层优化  │ ← 异步/并行/缓存/熔断
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │  数据层优化  │ ← Redis 缓存 + 分库分表 + 读写分离
                └─────────────┘

                    用户抢购请求
                        │
                        ▼
                ┌─────────────┐
                │ 1. CDN 静态化 │ ← 商品详情静态化到 CDN
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │ 2. 秒杀页面  │ ← 秒杀前页面，点击按钮
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │ 3. 接口层    │ ← 秒杀接口（前置校验）
                │    - 限流    │
                │    - 防刷    │
                │    - 原子扣减 │
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │ 4. Redis     │ ← Lua 脚本原子扣减库存
                │    库存扣减  │    DECR + 库存检查
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │ 5. MQ 削峰   │ ← 扣减成功发送到 MQ
                └──────┬──────┘
                       │
                ┌──────┴──────┐
                │ 6. 异步下单  │ ← 消费者异步创建订单
                └─────────────┘

正常状态：
    服务 A → 服务 B → 服务 C
    (正常响应)  (正常响应)  (正常响应)

雪崩触发：
    服务 A ← 流量突增/Bug/依赖故障
    │
    ▼
    服务 A 响应变慢/不可用
    │
    ▼
    服务 B 的请求线程阻塞
    │
    ▼
    服务 B 线程池占满
    │
    ▼
    服务 B 不可用
    │
    ▼
    服务 C 的请求线程阻塞
    │
    ▼
    服务 C 不可用
    │
    ▼
    全部服务不可用 → 系统雪崩

// Sentinel 熔断配置
@Bean
public SentinelResourceFactoryBean sentinelFactory() {
    return new SentinelResourceFactoryBean()
        .setDegradeRules(loadDegradeRules());
}

private List<DegradeRule> loadDegradeRules() {
    List<DegradeRule> rules = new ArrayList<>();

    // 慢调用比例熔断
    DegradeRule slowCallRule = new DegradeRule();
    slowCallRule.setResource("orderService");
    slowCallRule.setGrade(RuleConstant.DEGRADE_GRADE_SLOW_RATIO);
    slowCallRule.setCount(1000);      // RT > 1s
    slowCallRule.setTimeWindow(30);   // 熔断 30 秒
    slowCallRule.setMinRequestAmount(5);
    slowCallRule.setStatIntervalMs(1000);
    rules.add(slowCallRule);

    // 异常比例熔断
    DegradeRule errorRule = new DegradeRule();
    errorRule.setResource("orderService");
    errorRule.setGrade(RuleConstant.DEGRADE_GRADE_EXCEPTION_RATIO);
    errorRule.setCount(0.5);          // 异常比例 > 50%
    errorRule.setTimeWindow(30);
    rules.add(errorRule);

    return rules;
}

// Fallback 方法
@BlockHandler  // Sentinel 降级
public User getUserFallback(Long id, BlockException ex) {
    log.warn("getUser 被降级: {}", ex.getRule());
    return new User(-1L, "System busy, please retry later");
}

// Hystrix Fallback
@HystrixCommand(
    fallbackMethod = "getUserFallback",
    commandProperties = {
        @HystrixProperty(name = "circuitBreaker.requestVolumeThreshold", value = "20"),
        @HystrixProperty(name = "circuitBreaker.errorThresholdPercentage", value = "50")
    }
)
public User getUser(Long id) {
    return userClient.getUser(id);
}

// Sentinel QPS 限流
FlowRule flowRule = new FlowRule();
flowRule.setResource("orderService");
flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
flowRule.setCount(100);  // QPS 限制 100

// 或使用 Guava RateLimiter
RateLimiter rateLimiter = RateLimiter.create(100.0);  // 100 QPS
if (rateLimiter.tryAcquire()) {
    // 正常处理
} else {
    // 限流处理
}

// Feign 超时配置
feign:
  client:
    config:
      default:
        connect-timeout: 1000   // 连接超时 1 秒
        read-timeout: 3000      // 读取超时 3 秒

// RestTemplate 超时配置
@Bean
public RestTemplate restTemplate() {
    RestTemplate template = new RestTemplate();
    template.setConnectTimeout(1000);
    template.setReadTimeout(3000);
    return template;
}

// 线程池隔离（Hystrix）
@HystrixCommand(
    commandProperties = {
        @HystrixProperty(name = "execution.isolation.strategy", value = "THREAD"),
        @HystrixProperty(name = "execution.isolation.thread.timeoutInMilliseconds", value = "3000"),
        @HystrixProperty(name = "coreSize", value = "10"),
        @HystrixProperty(name = "maxQueueSize", value = "50")
    }
)
public User getUser(Long id) {
    return userClient.getUser(id);
}

// 信号量隔离（Sentinel 默认）
// 基于并发数限制，不创建线程

┌──────────┐ 错误率超阈值  ┌──────────┐
│   Closed  │─────────────▶│   Open    │
│  (正常)   │              │  (熔断)   │
└─────┬────┘              └─────┬────┘
      │                         │ 熔断时间窗到期
      │                         ▼
      │                  ┌──────────┐
      │                  │Half-Open │
      │                  │ (探测)   │
      │                  └─────┬────┘
      │                         │
      │              ┌──────────┴──────────┐
      │              │                      │
      │        探测成功               探测失败
      │              │                      │
      ▼              ▼                      ▼
  恢复正常      ┌──────────┐          ┌──────────┐
               │  Closed  │          │   Open   │
               └──────────┘          └──────────┘

// 降级注解示例
@Service
public class OrderService {

    // 核心方法：不降级
    @GetMapping("/orders/{id}")
    public Order getOrder(@PathVariable Long id) {
        return orderRepository.findById(id);
    }

    // 非核心方法：降级返回
    @GetMapping("/orders/{id}/recommendations")
    @DegradeRule(fallback = "getRecommendationsFallback")
    public List<Product> getRecommendations(@PathVariable Long id) {
        return recommendationClient.getByOrderId(id);
    }

    public List<Product> getRecommendationsFallback(Long id) {
        return Collections.emptyList();  // 降级返回空列表
    }
}

令牌桶（Token Bucket）：
    ┌─────────────────┐
    │   令牌桶         │  ← 令牌以固定速率 r 添加
    │  [ ][ ][ ][ ]   │      桶容量为 b
    └────────┬────────┘
             │
    令牌充足 → 立即处理（可突发）
    令牌不足 → 等待令牌或拒绝

漏桶（Leaky Bucket）：
    ┌─────────────────┐
    │   漏桶           │  ← 请求进入桶
    │  [ ][ ][ ][ ]   │      桶容量为 b
    └────────┬────────┘
             │
        固定速率输出（严格平滑）
        桶空则等待，桶满则丢弃

// 创建令牌桶限流器，每秒 100 个令牌
RateLimiter rateLimiter = RateLimiter.create(100.0);

// 尝试获取令牌
if (rateLimiter.tryAcquire()) {
    // 获取成功，处理请求
    processRequest();
} else {
    // 获取失败，限流处理
    rejectRequest();
}

// 或阻塞获取
rateLimiter.acquire();  // 阻塞直到获取令牌
processRequest();

// QPS 限流（令牌桶）
FlowRule flowRule = new FlowRule();
flowRule.setResource("getUser");
flowRule.setGrade(RuleConstant.FLOW_GRADE_QPS);
flowRule.setCount(100);  // QPS 限制

// 计数器限流
AtomicInteger counter = new AtomicInteger(0);
AtomicLong lastResetTime = new AtomicLong(System.currentTimeMillis());

public boolean tryAcquire() {
    long now = System.currentTimeMillis();
    if (now - lastResetTime.get() > 1000) {
        counter.set(0);
        lastResetTime.set(now);
    }
    return counter.incrementAndGet() <= 100;
}

用户请求
    │
    ▼
┌──────────────────────────────────────┐
│  第一层：接入层限流（Nginx）           │
│  - IP 级限流                         │
│  - 防护恶意流量                       │
└──────────────────────────────────────┘
    │
    ▼
┌──────────────────────────────────────┐
│  第二层：网关层限流（API Gateway）     │
│  - 接口级限流                        │
│  - 用户级限流                        │
│  - 关联限流                          │
└──────────────────────────────────────┘
    │
    ▼
┌──────────────────────────────────────┐
│  第三层：应用层限流（AOP/Sentinel）    │
│  - 方法级限流                        │
│  - 热点参数限流                       │
│  - 精细化控制                        │
└──────────────────────────────────────┘
    │
    ▼
  业务处理

http {
    # 定义限流区域
    limit_req_zone $binary_remote_addr zone=api_limit:10m rate=100r/s;
    limit_conn_zone $binary_remote_addr zone=conn_limit:10m;

    server {
        location /api/ {
            # 应用限流
            limit_req zone=api_limit burst=200 nodelay;
            limit_conn zone=conn_limit 50;

            proxy_pass http://backend;
        }
    }
}

spring:
  cloud:
    gateway:
      routes:
        - id: order_service
          uri: lb://order-service
          predicates:
            - Path=/api/orders/**
          filters:
            - name: Sentinel
              args:
                flowRules:
                  - resource: order_api
                    grade: QPS
                    count: 100
                  - resource: order_api
                    grade: CONCURRENT
                    count: 50

// 自定义限流注解
@Target(ElementType.METHOD)
@Retention(RetentionPolicy.RUNTIME)
public @interface RateLimit {
    int qps() default 100;          // QPS 限制
    int concurrent() default 50;    // 并发数限制
    String keyExpression() default "";  // 限流键表达式
    RateLimitStrategy strategy() default RateLimitStrategy.TOKEN_BUCKET;
}

// 限流切面
@Aspect
@Component
public class RateLimitAspect {

    private final ConcurrentHashMap<String, RateLimiter> limiters = new ConcurrentHashMap<>();

    @Around("@annotation(rateLimit)")
    public Object around(ProceedingJoinPoint joinPoint, RateLimit rateLimit) throws Throwable {
        String key = parseKey(joinPoint, rateLimit);
        RateLimiter limiter = limiters.computeIfAbsent(key,
            k -> RateLimiter.create(rateLimit.qps()));

        if (limiter.tryAcquire()) {
            return joinPoint.proceed();
        } else {
            // 限流降级
            return handleBlock(joinPoint, rateLimit);
        }
    }
}

// 使用示例
@RestController
public class OrderController {

    @GetMapping("/orders/{id}")
    @RateLimit(qps = 100, concurrent = 50, keyExpression = "#id")
    public Order getOrder(@PathVariable Long id) {
        return orderService.getOrder(id);
    }
}

-- 订单表：订单号唯一
CREATE TABLE orders (
    id BIGINT PRIMARY KEY AUTO_INCREMENT,
    order_no VARCHAR(64) NOT NULL UNIQUE,  -- 唯一索引
    user_id BIGINT NOT NULL,
    -- ...
);

@Service
public class OrderService {

    public Order createOrder(CreateOrderRequest request) {
        try {
            Order order = new Order();
            order.setOrderNo(generateOrderNo());
            order.setUserId(request.getUserId());
            return orderMapper.insert(order);
        } catch (DuplicateKeyException e) {
            // 唯一键冲突 → 订单已创建，直接返回
            return orderMapper.selectByOrderNo(request.getOrderNo());
        }
    }
}

// 1. 前端获取 Token
@GetMapping("/token")
public String getToken() {
    String token = UUID.randomUUID().toString();
    redisTemplate.opsForValue().set("idempotent:token:" + token, "1", 10, TimeUnit.MINUTES);
    return token;
}

// 2. 提交时携带 Token
@PostMapping("/orders")
public Order createOrder(@RequestBody CreateOrderRequest request,
                         @RequestHeader("Idempotent-Token") String token) {
    // 检查 Token 是否存在
    Boolean isFirst = redisTemplate.opsForValue()
        .setIfAbsent("idempotent:token:" + token, "1", 10, TimeUnit.MINUTES);
    if (Boolean.FALSE.equals(isFirst)) {
        // Token 已使用 → 幂等返回
        return orderMapper.selectByOrderNo(request.getOrderNo());
    }

    // 创建订单
    return orderService.createOrder(request);
}

@Service
public class AccountService {

    public void deductBalance(Long accountId, BigDecimal amount) {
        Account account = accountMapper.selectById(accountId);

        // 状态机：只有"正常"状态才能扣款
        if (!"ACTIVE".equals(account.getStatus())) {
            return;  // 非正常状态，直接返回
        }

        // CAS 更新：确保状态不被并发修改
        int updated = accountMapper.updateStatus(
            accountId, "ACTIVE", "DEDUCTING");
        if (updated == 0) {
            return;  // 状态已被其他操作修改
        }

        // 执行扣款
        account.setBalance(account.getBalance().subtract(amount));
        account.setStatus("ACTIVE");
        accountMapper.updateById(account);
    }
}

public void deductWithLock(Long accountId, BigDecimal amount) {
    String lockKey = "lock:account:" + accountId;
    RLock lock = redissonClient.getLock(lockKey);

    if (lock.tryLock(3, 10, TimeUnit.SECONDS)) {
        try {
            // 检查幂等标记
            String dedupKey = "dedup:deduct:" + accountId + ":" + amount;
            Boolean isFirst = redisTemplate.opsForValue()
                .setIfAbsent(dedupKey, "1", 24, TimeUnit.HOURS);
            if (Boolean.FALSE.equals(isFirst)) {
                return;  // 已处理
            }

            // 执行扣款
            accountService.deductBalance(accountId, amount);
        } finally {
            lock.unlock();
        }
    }
}

-- 更新时带版本号
UPDATE accounts
SET balance = balance - #{amount}, version = version + 1
WHERE id = #{id} AND version = #{version}

public void deductWithVersion(Long id, BigDecimal amount, Integer version) {
    int updated = accountMapper.deductBalanceWithVersion(id, amount, version);
    if (updated == 0) {
        // 版本号不匹配 → 重试或返回
        throw new ConcurrentModificationException("数据已被修改，请重试");
    }
}

分布式定时任务场景：

时间到达 → 触发任务
    │
    ├── 节点 A 触发 → 执行任务 → 成功
    │
    ├── 节点 B 同时触发 → 执行任务 → 重复执行！
    │
    └── 网络重试 → 再次触发 → 重复执行！

// XXL-JOB + Redisson 分布式锁
@Component
public class IdempotentJob {

    @XxlJob("idempotentJob")
    public void execute(String param) {
        // 生成唯一任务 ID
        String taskId = "task:" + param + ":" + System.currentTimeMillis();
        String lockKey = "lock:task:" + param;

        RLock lock = redissonClient.getLock(lockKey);
        boolean acquired = false;

        try {
            acquired = lock.tryLock(0, 60, TimeUnit.SECONDS);
            if (!acquired) {
                log.info("任务已被其他节点执行，跳过");
                return;
            }

            // 检查幂等标记
            Boolean isFirst = redisTemplate.opsForValue()
                .setIfAbsent("done:task:" + taskId, "1", 1, TimeUnit.HOURS);
            if (Boolean.FALSE.equals(isFirst)) {
                log.info("任务已执行，跳过");
                return;
            }

            // 执行任务
            doTask(param);

        } catch (Exception e) {
            log.error("任务执行失败", e);
            // 清理幂等标记，允许重试
            redisTemplate.delete("done:task:" + taskId);
        } finally {
            if (acquired) {
                lock.unlock();
            }
        }
    }
}

// 数据库任务记录表
@Entity
@Table(name = "task_record")
public class TaskRecord {
    @Id
    private String taskId;       // 任务唯一 ID
    private String taskType;     // 任务类型
    private String bizKey;       // 业务唯一键
    private Integer status;      // 0:待执行 1:执行中 2:已完成 3:失败
    private LocalDateTime createTime;
    private LocalDateTime updateTime;
}

// 任务执行逻辑
@Service
public class TaskService {

    @Autowired
    private TaskRecordMapper taskRecordMapper;

    public void executeTask(String taskType, String bizKey) {
        String taskId = taskType + ":" + bizKey;

        // 1. 尝试插入任务记录（唯一键保证不重复）
        TaskRecord record = new TaskRecord();
        record.setTaskId(taskId);
        record.setTaskType(taskType);
        record.setBizKey(bizKey);
        record.setStatus(0);  // 待执行

        try {
            taskRecordMapper.insert(record);
        } catch (DuplicateKeyException e) {
            // 任务已存在，检查状态
            TaskRecord existing = taskRecordMapper.selectById(taskId);
            if (existing.getStatus() == 2) {
                // 已完成，直接返回
                return;
            }
            // 其他状态，等待前一次执行结果
            return;
        }

        // 2. 更新为执行中
        record.setStatus(1);
        taskRecordMapper.updateById(record);

        try {
            // 3. 执行任务
            doExecute(taskType, bizKey);

            // 4. 标记为完成
            record.setStatus(2);
        } catch (Exception e) {
            // 5. 标记为失败
            record.setStatus(3);
            throw e;
        }
        taskRecordMapper.updateById(record);
    }
}

// 基于业务状态机的幂等
@Service
public class SettlementService {

    @Scheduled(cron = "0 0 2 * * ?")  // 每天凌晨 2 点
    public void dailySettlement() {
        // 1. 查询待结算的记录
        List<Settlement> pendingList = settlementMapper
            .selectByStatus("PENDING");

        for (Settlement settlement : pendingList) {
            // 2. CAS 更新状态（防止并发）
            int updated = settlementMapper.updateStatus(
                settlement.getId(), "PENDING", "PROCESSING");
            if (updated == 0) {
                continue;  // 已被其他节点处理
            }

            try {
                // 3. 执行结算
                doSettlement(settlement);

                // 4. 标记完成
                settlementMapper.updateStatus(
                    settlement.getId(), "PROCESSING", "COMPLETED");
            } catch (Exception e) {
                // 5. 标记失败，等待重试
                settlementMapper.updateStatus(
                    settlement.getId(), "PROCESSING", "FAILED");
            }
        }
    }
}