在Spring Boot响应式应用中高效处理多外部API调用的策略

// 通用外部API服务接口
public interface ExternalApiService<T> {
    Mono<T> fetchData();
    String getServiceName();
}

// 外部API A的实现
@Service
public class ExternalApiAService implements ExternalApiService<ApiAData> {

    private final WebClient webClient; // 或其他HTTP客户端

    public ExternalApiAService(WebClient webClient) {
        this.webClient = webClient;
    }

    @Override
    public Mono<ApiAData> fetchData() {
        return webClient.get()
                .uri("/api-a/data")
                .retrieve()
                .bodyToMono(ApiAData.class)
                .timeout(Duration.ofSeconds(5)) // 设置超时
                .onErrorResume(e -> {
                    // 特定于API A的错误处理或返回默认值
                    System.err.println("Error fetching API A data: " + e.getMessage());
                    return Mono.just(new ApiAData("defaultA", "error"));
                });
    }

    @Override
    public String getServiceName() {
        return "API_A";
    }
}

// 外部API B的实现（可能需要不同的认证、SLA等）
@Service
public class ExternalApiBService implements ExternalApiService<ApiBData> {

    private final WebClient webClient; // 可能配置了不同的baseUrl或认证

    public ExternalApiBService(@Qualifier("apiBWebClient") WebClient webClient) {
        this.webClient = webClient;
    }

    @Override
    public Mono<ApiBData> fetchData() {
        // 假设API B需要不同的认证头
        return webClient.get()
                .uri("/api-b/info")
                .header("X-API-KEY", "your-api-b-key")
                .retrieve()
                .bodyToMono(ApiBData.class)
                .timeout(Duration.ofSeconds(8)) // 不同的超时设置
                .onErrorResume(e -> {
                    // 特定于API B的错误处理
                    System.err.println("Error fetching API B data: " + e.getMessage());
                    return Mono.just(new ApiBData(0, "fallback"));
                });
    }

    @Override
    public String getServiceName() {
        return "API_B";
    }
}

// 示例数据模型
import java.time.Duration;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.stereotype.Service;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

class ApiAData {
    public String field1;
    public String field2;
    // 构造函数、getter、setter
    public ApiAData(String field1, String field2) {
        this.field1 = field1;
        this.field2 = field2;
    }
}
class ApiBData {
    public int id;
    public String name;
    // 构造函数、getter、setter
    public ApiBData(int id, String name) {
        this.id = id;
        this.name = name;
    }
}

import org.springframework.stereotype.Service;
import reactor.core.publisher.Mono;

@Service
public class DataAggregationService {

    private final ExternalApiAService apiAService;
    private final ExternalApiBService apiBService;
    // ... 注入所有20个ExternalApiService实例

    public DataAggregationService(ExternalApiAService apiAService, ExternalApiBService apiBService) {
        this.apiAService = apiAService;
        this.apiBService = apiBService;
    }

    public Mono<AggregatedResponse> getAggregatedData() {
        Mono<ApiAData> apiAMono = apiAService.fetchData();
        Mono<ApiBData> apiBMono = apiBService.fetchData();
        // ... 其他18个API的Mono

        // 使用Mono.zip组合所有Mono
        return Mono.zip(apiAMono, apiBMono /*, ... 其他Mono */)
                   .map(tuple -> {
                       ApiAData aData = tuple.getT1();
                       ApiBData bData = tuple.getT2();
                       // ... 从tuple中获取所有数据

                       // 将所有数据聚合成一个AggregatedResponse对象
                       return new AggregatedResponse(aData, bData /*, ... */);
                   });
    }
}

// 聚合后的响应模型
class AggregatedResponse {
    public ApiAData apiAData;
    public ApiBData apiBData;
    // ... 其他API数据
    // 构造函数、getter、setter
    public AggregatedResponse(ApiAData apiAData, ApiBData apiBData) {
        this.apiAData = apiAData;
        this.apiBData = apiBData;
    }
}