Spring Boot单体应用中调用外部API的实现方法及架构疑问

完全可以在单体Spring Boot应用里实现这个需求，根本没必要非得拆成微服务。单体应用里发起HTTP请求调用外部API是非常常规的操作，下面给你具体的实现步骤和代码示例：

一、选合适的HTTP客户端工具 #

Spring Boot里常用的有三种工具，按需选择即可：

• RestTemplate：Spring原生的同步客户端，适合简单的同步调用场景
• WebClient：Spring WebFlux提供的非阻塞异步客户端，适合高并发、不想阻塞主线程的场景
• OkHttp：第三方成熟的HTTP客户端，性能和扩展性都不错

二、具体实现示例 #

1. 用RestTemplate实现（同步场景） #

首先在配置类里注册RestTemplate的Bean：

@Configuration
public class RestTemplateConfig {
    @Bean
    public RestTemplate restTemplate() {
        return new RestTemplate();
    }
}

然后在业务服务里注入并使用：

@Service
public class DataProcessingService {
    private final RestTemplate restTemplate;

    // 构造函数注入（推荐的注入方式）
    public DataProcessingService(RestTemplate restTemplate) {
        this.restTemplate = restTemplate;
    }

    public void processDataAndSendResponse(String inputData) {
        // 第一步：处理数据
        String processedData = processRawData(inputData);

        // 第二步：调用外部API发送处理结果
        String externalApiUrl = "http://目标项目的API地址/具体接口路径";
        // 按外部API要求构造请求体
        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("processedData", processedData);
        requestBody.put("timestamp", System.currentTimeMillis());

        try {
            // 这里用POST请求举例，可根据外部API要求换成GET/PUT/DELETE
            ResponseEntity<String> response = restTemplate.postForEntity(
                    externalApiUrl,
                    requestBody,
                    String.class
            );

            // 处理外部API响应
            if (response.getStatusCode().is2xxSuccessful()) {
                System.out.println("外部API调用成功，响应内容：" + response.getBody());
            } else {
                System.err.println("外部API调用失败，状态码：" + response.getStatusCode());
            }
        } catch (RestClientException e) {
            // 处理网络异常（如连接超时、目标服务不可用）
            e.printStackTrace();
        }
    }

    // 自定义数据处理逻辑
    private String processRawData(String rawData) {
        return rawData.toUpperCase();
    }
}

最后在业务API控制器里调用该服务：

@RestController
@RequestMapping("/api/data")
public class DataController {
    private final DataProcessingService processingService;

    public DataController(DataProcessingService processingService) {
        this.processingService = processingService;
    }

    @PostMapping("/process")
    public ResponseEntity<String> handleDataProcessing(@RequestBody String inputData) {
        processingService.processDataAndSendResponse(inputData);
        return ResponseEntity.ok("数据处理中，已发起外部API调用");
    }
}

2. 用WebClient实现（异步场景） #

如果不想让外部API的响应速度阻塞主业务流程，可以用异步的WebClient：

先配置WebClient的Bean：

@Configuration
public class WebClientConfig {
    @Bean
    public WebClient webClient() {
        return WebClient.builder()
                .baseUrl("http://目标项目的API地址") // 设置基础地址，后续只需写接口路径
                .build();
    }
}

业务服务里的异步实现：

@Service
public class DataProcessingService {
    private final WebClient webClient;

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

    public Mono<Void> processDataAndSendResponseAsync(String inputData) {
        String processedData = processRawData(inputData);

        Map<String, Object> requestBody = new HashMap<>();
        requestBody.put("processedData", processedData);
        requestBody.put("timestamp", System.currentTimeMillis());

        return webClient.post()
                .uri("/具体接口路径") // 相对于baseUrl的路径
                .bodyValue(requestBody)
                .retrieve()
                // 处理非2xx响应状态码
                .onStatus(status -> !status.is2xxSuccessful(), response -> {
                    return response.bodyToMono(String.class)
                            .flatMap(errorBody -> Mono.error(new RuntimeException("外部API调用失败：" + errorBody)));
                })
                .bodyToMono(Void.class)
                .doOnSuccess(v -> System.out.println("外部API异步调用成功"))
                .doOnError(e -> System.err.println("外部API异步调用失败：" + e.getMessage()));
    }

    private String processRawData(String rawData) {
        return rawData.toUpperCase();
    }
}

控制器里的异步接口：

@RestController
@RequestMapping("/api/data")
public class DataController {
    private final DataProcessingService processingService;

    public DataController(DataProcessingService processingService) {
        this.processingService = processingService;
    }

    @PostMapping("/process/async")
    public Mono<ResponseEntity<String>> handleDataProcessingAsync(@RequestBody String inputData) {
        return processingService.processDataAndSendResponseAsync(inputData)
                .then(Mono.just(ResponseEntity.ok("数据异步处理中，已发起外部API调用")));
    }
}

三、关键注意事项 #

• 异常处理不能少：必须处理网络超时、连接失败、外部API返回错误等异常，避免外部问题拖垮主业务
• 设置超时时间：给HTTP客户端配置合理的超时时间，比如RestTemplate可通过SimpleClientHttpRequestFactory设置，WebClient通过ClientConnector配置
• 注意幂等性：如果外部API要求幂等，要确保重复调用无副作用，比如给每个请求添加唯一ID
• 日志要记全：记录外部API的调用参数、响应结果、耗时等信息，方便排查问题

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