Spring Reactive中WebClient链式调用及响应处理问题咨询

1. 解决WebClient顺序调用的block()异常 #

你在Node.js里用await等待Promise的写法，对应Spring Reactive里不能用block()（会阻塞Reactor的非阻塞线程池，触发异常），要改用**flatMap**实现顺序调用——第一个调用完成后自动触发第二个调用，全程保持非阻塞。

假设你熟悉的Node.js示例是这样的：

async function fetchSequentialData() {
  const firstRes = await fetch('https://first-api.com/data');
  const firstData = await firstRes.json();
  const secondRes = await fetch(`https://second-api.com/data/${firstData.id}`);
  return secondRes.json();
}

对应的Spring Reactive正确写法：

// 注入配置好的WebClient
private final WebClient webClient;

public Mono<SecondResponse> fetchSequentialData() {
    // 第一个WebClient调用
    return webClient.get()
            .uri("https://first-api.com/data")
            .retrieve()
            .bodyToMono(FirstResponse.class)
            // 用flatMap承接第一个响应，发起第二个调用
            .flatMap(firstData -> 
                webClient.get()
                        .uri("https://second-api.com/data/{id}", firstData.getId())
                        .retrieve()
                        .bodyToMono(SecondResponse.class)
            );
}

控制器里直接返回这个Mono即可，Spring会自动处理订阅和响应输出：

@GetMapping("/sequential-data")
public Mono<SecondResponse> getSequentialData() {
    return fetchSequentialData();
}

2. 下游响应结构编排转换 #

当下游返回的结构和你的API规范不一致时，用**map**做同步转换，或flatMap做异步转换（如果转换需要调用其他服务/数据库）。

示例：同步字段映射 #

比如下游返回DownstreamUser有user_name字段，你的API要返回ApiUser的name字段：

// 下游响应DTO
@Data
public class DownstreamUser {
    private String user_name;
    private Integer user_age;
}

// 你的API规范DTO
@Data
public class ApiUser {
    private String name;
    private Integer age;
}

// 转换逻辑
public Mono<ApiUser> convertDownstreamResponse() {
    return webClient.get()
            .uri("https://downstream-api.com/user")
            .retrieve()
            .bodyToMono(DownstreamUser.class)
            // 同步转换字段映射
            .map(downstreamUser -> {
                ApiUser apiUser = new ApiUser();
                apiUser.setName(downstreamUser.getUser_name());
                apiUser.setAge(downstreamUser.getUser_age());
                return apiUser;
            });
}

示例：异步补充数据转换 #

如果转换需要异步查询数据库补全字段，用flatMap：

public Mono<ApiUser> convertWithAsyncData() {
    return webClient.get()
            .uri("https://downstream-api.com/user")
            .retrieve()
            .bodyToMono(DownstreamUser.class)
            .flatMap(downstreamUser -> {
                // 异步查询数据库获取额外信息
                return userRepository.findByUsername(downstreamUser.getUser_name())
                        .map(dbUser -> {
                            ApiUser apiUser = new ApiUser();
                            apiUser.setName(dbUser.getDisplayName());
                            apiUser.setAge(downstreamUser.getUser_age());
                            return apiUser;
                        });
            });
}

3. 确保响应体不为空 #

要避免消费者收到空白响应，需确保你的Mono/Flux不会发出null，可以用以下几种方式：

方式1：用defaultIfEmpty提供默认值 #

当下游返回空（比如404），直接返回一个预设的非空对象：

public Mono<ApiUser> getNonEmptyUser() {
    return webClient.get()
            .uri("https://downstream-api.com/user/{id}", 123)
            .retrieve()
            .bodyToMono(DownstreamUser.class)
            .map(this::convertToApiUser)
            // 上游返回空Mono时，返回默认对象
            .defaultIfEmpty(new ApiUser("默认名称", 0));
}

方式2：用switchIfEmpty触发备选逻辑 #

如果需要在空响应时调用其他服务获取默认数据：

public Mono<ApiUser> getNonEmptyUserWithFallback() {
    return webClient.get()
            .uri("https://downstream-api.com/user/{id}", 123)
            .retrieve()
            .bodyToMono(DownstreamUser.class)
            .map(this::convertToApiUser)
            // 上游空响应时，调用备选接口获取数据
            .switchIfEmpty(webClient.get()
                    .uri("https://fallback-api.com/default-user")
                    .retrieve()
                    .bodyToMono(ApiUser.class));
}

方式3：过滤空值并兜底 #

如果下游可能返回null对象，先过滤再兜底：

public Mono<ApiUser> filterNullAndFallback() {
    return webClient.get()
            .uri("https://downstream-api.com/user/{id}", 123)
            .retrieve()
            .bodyToMono(DownstreamUser.class)
            // 过滤掉null的下游对象
            .filter(Objects::nonNull)
            .map(this::convertToApiUser)
            .defaultIfEmpty(new ApiUser("默认名称", 0));
}

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