如何在 Spring Boot 中使用并行 REST 调用优化多子请求性能

在 Spring Boot 开发中，一个业务接口往往要聚合多个微服务的数据，比如用户信息、订单列表和推荐内容。如果按顺序发起 REST 调用，总耗时就是各个请求耗时之和。通过并行 REST 调用，可以让多个子请求同时发出，从而将接口响应时间压缩到最慢的那个请求附近。

为什么需要并行 REST 调用

假设接口需要调用三个下游服务，每个平均耗时 200 毫秒。串行情况下总耗时约 600 毫秒；并行情况下仅约 200 毫秒。对于内部管理系统或前端聚合接口，这种优化能明显降低延迟。

使用 CompletableFuture 实现并行调用

Spring Boot 中可结合 RestTemplate 与 AsyncRestTemplate，或直接使用响应式 WebClient。下面以 CompletableFuture 配合自定义线程池为例，展示如何并行调用并返回聚合结果。

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.scheduling.annotation.Async;
import org.springframework.stereotype.Service;
import org.springframework.web.client.RestTemplate;
import java.util.concurrent.CompletableFuture;

@Service
public class AggregateService {

    @Autowired
    private RestTemplate restTemplate;

    // 异步方法，使用自定义线程池执行
    @Async("restExecutor")
    public CompletableFuture<String> fetchUser() {
        String result = restTemplate.getForObject("http://127.0.0.1:8081/user", String.class);
        return CompletableFuture.completedFuture(result);
    }

    @Async("restExecutor")
    public CompletableFuture<String> fetchOrder() {
        String result = restTemplate.getForObject("http://127.0.0.1:8082/order", String.class);
        return CompletableFuture.completedFuture(result);
    }

    // 聚合两个并行任务
    public CompletableFuture<String> aggregate() {
        CompletableFuture<String> userFuture = fetchUser();
        CompletableFuture<String> orderFuture = fetchOrder();
        return userFuture.thenCombine(orderFuture, (u, o) -> "user:" + u + ",order:" + o);
    }
}

线程池配置建议

默认的异步执行器可能复用主线程池，导致资源争用。应声明独立线程池：

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.scheduling.annotation.EnableAsync;
import java.util.concurrent.Executor;
import java.util.concurrent.ThreadPoolTaskExecutor;

@Configuration
@EnableAsync
public class AsyncConfig {

    @Bean("restExecutor")
    public Executor restExecutor() {
        ThreadPoolTaskExecutor executor = new ThreadPoolTaskExecutor();
        executor.setCorePoolSize(10);
        executor.setMaxPoolSize(20);
        executor.setQueueCapacity(100);
        executor.setThreadNamePrefix("rest-async-");
        executor.initialize();
        return executor;
    }
}

异常处理与超时控制

并行任务中某个子请求失败不应阻塞整体。可使用 exceptionally 或 orTimeout 设置兜底与超时：

CompletableFuture<String> safeUser = fetchUser()
    .orTimeout(500, java.util.concurrent.TimeUnit.MILLISECONDS)
    .exceptionally(ex -> "default");

使用 WebClient 的响应式并行方案

若项目已引入 WebFlux，WebClient 天然支持非阻塞并行，代码更简洁：

import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

WebClient client = WebClient.create();
Mono<String> userMono = client.get().uri("http://127.0.0.1:8081/user").retrieve().bodyToMono(String.class);
Mono<String> orderMono = client.get().uri("http://127.0.0.1:8082/order").retrieve().bodyToMono(String.class);

Mono.zip(userMono, orderMono).map(t -> t.getT1() + t.getT2()).block();

小结

在 Spring Boot 中优化多子请求性能，核心是把串行等待变为并行执行。根据技术栈选择 CompletableFuture 或 WebClient，并合理配置线程池与超时，就能以较低成本获得明显延迟收益。

Spring_Boot并行REST调用性能优化修改时间：2026-07-27 06:30:21