第3章：环境信息

{
  "success": false,
  "errorCode": 429,
  "errorMsg": "请求频率过高，请稍后重试",
  "result": null
}

// 示例代码 - 令牌桶算法
import java.util.concurrent.atomic.AtomicLong;
import java.util.concurrent.locks.ReentrantLock;

public class RateLimiter {
    private final int maxRequests; // 100
    private final long timeWindow; // 1000ms (1秒)
    private AtomicLong tokens;
    private AtomicLong lastRefill;
    private final ReentrantLock lock = new ReentrantLock();
    
    public RateLimiter(int maxRequests, long timeWindow) {
        this.maxRequests = maxRequests;
        this.timeWindow = timeWindow;
        this.tokens = new AtomicLong(maxRequests);
        this.lastRefill = new AtomicLong(System.currentTimeMillis());
    }
    
    public boolean acquire() throws InterruptedException {
        refill();
        if (tokens.get() > 0) {
            tokens.decrementAndGet();
            return true;
        }
        // 等待下一个令牌
        long waitTime = timeWindow / maxRequests;
        Thread.sleep(waitTime);
        return acquire();
    }
    
    private void refill() {
        long now = System.currentTimeMillis();
        long elapsed = now - lastRefill.get();
        if (elapsed >= timeWindow) {
            lock.lock();
            try {
                // 双重检查
                if (elapsed >= timeWindow) {
                    tokens.set(maxRequests);
                    lastRefill.set(now);
                }
            } finally {
                lock.unlock();
            }
        }
    }
}

// 使用示例
RateLimiter limiter = new RateLimiter(100, 1000); // 100 QPS
limiter.acquire();
// 发送请求

// 示例代码
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;

public class RateLimitHandler {
    
    /**
     * 处理限流错误
     */
    public ResponseEntity<?> handleRateLimit(ResponseEntity<?> response) throws InterruptedException {
        if (response.getStatusCode() == HttpStatus.TOO_MANY_REQUESTS) {
            // 获取 Retry-After 响应头，默认60秒
            String retryAfterHeader = response.getHeaders().getFirst("Retry-After");
            long retryAfter = retryAfterHeader != null ? Long.parseLong(retryAfterHeader) : 60;
            
            System.out.println("限流错误，等待 " + retryAfter + " 秒后重试");
            Thread.sleep(retryAfter * 1000);
            
            // 降低请求频率
            reduceRequestRate();
            
            // 重新发送请求
            return retryRequest();
        }
        return response;
    }
    
    private void reduceRequestRate() {
        // 降低请求频率的逻辑
    }
    
    private ResponseEntity<?> retryRequest() {
        // 重新发送请求的逻辑
        return null;
    }
}

// 示例代码
import java.util.List;
import java.util.ArrayList;

public class BatchOperationService {
    
    private static final int BATCH_SIZE = 100; // 每批100条
    
    /**
     * 批量创建，分批处理避免触发限流
     */
    public void batchCreate(List<Object> items) throws InterruptedException {
        // 分批处理
        for (int i = 0; i < items.size(); i += BATCH_SIZE) {
            int end = Math.min(i + BATCH_SIZE, items.size());
            List<Object> batch = items.subList(i, end);
            
            // 创建当前批次
            createBatch(batch);
            
            // 批次之间延迟，避免触发限流
            if (end < items.size()) {
                Thread.sleep(100);
            }
        }
    }
    
    private void createBatch(List<Object> batch) {
        // 创建批次的逻辑
    }
}