SpringBoot中如何基于FeignClient批量串行提交REST API请求？

一、同步阻塞式顺序提交（简单直接） #

这种方案严格遵循前一个请求成功后再提交下一个的规则，适合对请求顺序要求极高、吞吐量需求较低的场景。

前置假设的FeignClient接口 #

@FeignClient(name = "external-api")
public interface ExternalApiClient {
    @PostMapping("/bulk")
    ResponseEntity<Void> submitBulkRequest(@RequestBody BulkRequest request);
}

核心实现代码 #

@Service
public class BulkRequestService {
    private final ExternalApiClient externalApiClient;
    private final Logger logger = LoggerFactory.getLogger(getClass());

    // 构造注入FeignClient
    public BulkRequestService(ExternalApiClient externalApiClient) {
        this.externalApiClient = externalApiClient;
    }

    public void submitSequentially(List<BulkRequest> bulkRequests) {
        for (BulkRequest request : bulkRequests) {
            try {
                ResponseEntity<Void> response = externalApiClient.submitBulkRequest(request);
                if (response.getStatusCode().is2xxSuccessful()) {
                    logger.info("请求[{}]提交成功", request.getTraceId());
                } else {
                    logger.error("请求[{}]提交失败，状态码：{}", request.getTraceId(), response.getStatusCode());
                    // 可根据业务选择：中断后续提交/标记失败后继续
                    throw new RuntimeException(String.format("请求%s提交失败", request.getTraceId()));
                }
            } catch (FeignException e) {
                logger.error("请求[{}]调用异常：{}", request.getTraceId(), e.getMessage());
                // 可选：触发重试/中断流程
                throw e;
            }
        }
    }
}

关键优化点 #

• 超时配置：避免单个请求卡住整个流程，在Feign配置中设置连接/读取超时

  @Configuration
  public class FeignConfig {
      @Bean
      public Request.Options options() {
          return new Request.Options(5000, 10000); // 连接超时5s，读取超时10s
      }
  }
  

• 重试机制：针对网络超时、服务端5xx等异常，用Spring Retry或Feign自带重试实现自动重试
• 失败策略：可灵活选择失败后中断流程、标记失败日志后继续，或把失败请求存入数据库后续补偿

二、响应式非阻塞顺序提交（高吞吐量友好） #

如果项目使用Spring WebFlux，可基于响应式FeignClient实现非阻塞式顺序提交，既保证请求顺序，又不占用阻塞线程，适合高吞吐量场景。

响应式FeignClient接口 #

@FeignClient(name = "external-api")
public interface ReactiveExternalApiClient {
    @PostMapping("/bulk")
    Mono<ResponseEntity<Void>> submitBulkRequest(@RequestBody BulkRequest request);
}

核心实现代码 #

@Service
public class ReactiveBulkRequestService {
    private final ReactiveExternalApiClient reactiveExternalApiClient;
    private final Logger logger = LoggerFactory.getLogger(getClass());

    public ReactiveBulkRequestService(ReactiveExternalApiClient reactiveExternalApiClient) {
        this.reactiveExternalApiClient = reactiveExternalApiClient;
    }

    public Mono<Void> submitSequentiallyReactive(List<BulkRequest> bulkRequests) {
        return Flux.fromIterable(bulkRequests)
                // concatMap保证顺序：前一个请求完成后再执行下一个
                .concatMap(request -> 
                    reactiveExternalApiClient.submitBulkRequest(request)
                            .doOnSuccess(response -> {
                                if (response.getStatusCode().is2xxSuccessful()) {
                                    logger.info("响应式请求[{}]提交成功", request.getTraceId());
                                } else {
                                    logger.error("响应式请求[{}]提交失败，状态码：{}", request.getTraceId(), response.getStatusCode());
                                    throw new RuntimeException(String.format("请求%s提交失败", request.getTraceId()));
                                }
                            })
                            .doOnError(e -> logger.error("响应式请求[{}]异常：{}", request.getTraceId(), e.getMessage()))
                            // 可选：添加超时与重试逻辑
                            .timeout(Duration.ofSeconds(10))
                            .retryWhen(Retry.backoff(3, Duration.ofSeconds(1))
                                    .filter(e -> e instanceof FeignException || e instanceof TimeoutException))
                )
                .then(); // 所有请求完成后返回Mono<Void>
    }
}

关键优化点 #

• 背压支持：Flux自带背压机制，可防止请求堆积导致的资源耗尽
• 异常灵活处理：通过onErrorResume、onErrorReturn实现失败后的跳过、降级等逻辑
• 资源高效利用：非阻塞线程模型，相比同步方案能支撑更多并发请求

三、通用优化建议 #

• 请求拆分：如果单个BulkRequest中的myRequests数量过大，可先拆分为更小的批次，避免触发外部API的限流规则
• 链路追踪：利用traceId实现全链路日志追踪，便于排查请求问题
• 熔断限流：集成Sentinel或Resilience4j实现FeignClient的熔断与限流，避免外部API故障拖垮自身服务
• 异步回调：若无需严格顺序但需知晓每个请求结果，可使用自定义线程池异步提交，同时注意线程池的参数配置（核心线程数、队列大小等）

内容的提问来源于stack exchange，提问作者user1220373