Spring Boot 调用外部接口的四种方式

在Spring Boot项目中，调用外部接口是一种常见的需求，它允许你的应用与其他系统或服务进行交互。以下是四种常用的调用外部接口的方式，并附上相应的Java代码案例。

1. 使用RestTemplate

RestTemplate 是Spring提供的一个用于同步客户端HTTP请求的模板工具类，支持多种HTTP方法。

Java代码案例：

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.web.client.RestTemplate;  
  
@Service  
public class ExternalService {  
  
    @Autowired  
    private RestTemplate restTemplate;  
  
    public String callExternalApiGet() {  
        String url = "http://api.example.com/data";  
        return restTemplate.getForObject(url, String.class);  
    }  
  
    public void callExternalApiPost(String payload) {  
        String url = "http://api.example.com/data";  
        restTemplate.postForObject(url, payload, String.class);  
    }  
}  
  
// 配置RestTemplate  
@Configuration  
public class AppConfig {  
  
    @Bean  
    public RestTemplate restTemplate() {  
        return new RestTemplate();  
    }  
}

2. 使用WebClient

WebClient 是Spring 5中引入的响应式编程的HTTP客户端，它基于Reactor，支持异步和流式传输。

Java代码案例：

import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Service;  
import org.springframework.web.reactive.function.client.WebClient;  
  
@Service  
public class ExternalReactiveService {  
  
    @Autowired  
    private WebClient.Builder webClientBuilder;  
  
    public Mono<String> callExternalApiGet() {  
        String url = "http://api.example.com/data";  
        return webClientBuilder.build()  
                .get()  
                .uri(url)  
                .retrieve()  
                .bodyToMono(String.class);  
    }  
  
    public Mono<Void> callExternalApiPost(String payload) {  
        String url = "http://api.example.com/data";  
        return webClientBuilder.build()  
                .post()  
                .uri(url)  
                .bodyValue(payload)  
                .retrieve()  
                .bodyToMono(Void.class);  
    }  
}  
  
// 配置WebClient.Builder  
@Configuration  
public class WebClientConfig {  
  
    @Bean  
    public WebClient.Builder webClientBuilder() {  
        return WebClient.builder();  
    }  
}

3. 使用Feign

Feign 是一个声明式的Web服务客户端，它使得编写Web服务客户端变得更加简单。通过创建接口并使用注解来配置它，你可以定义服务调用的所有细节。

Java代码案例：

首先，添加Feign的依赖到你的pom.xml或build.gradle文件中。

Maven:

<dependency>  
    <groupId>org.springframework.cloud</groupId>  
    <artifactId>spring-cloud-starter-openfeign</artifactId>  
    <version>YOUR_FEIGN_VERSION</version>  
</dependency>

import org.springframework.cloud.openfeign.FeignClient;  
import org.springframework.web.bind.annotation.GetMapping;  
import org.springframework.web.bind.annotation.PostMapping;  
import org.springframework.web.bind.annotation.RequestBody;  
  
@FeignClient(name = "external-service", url = "http://api.example.com")  
public interface ExternalClient {  
  
    @GetMapping("/data")  
    String getData();  
  
    @PostMapping("/data")  
    void postData(@RequestBody String payload);  
}  
  
// 使用Feign客户端  
@Service  
public class ExternalFeignService {  
  
    @Autowired  
    private ExternalClient externalClient;  
  
    public String callGetData() {  
        return externalClient.getData();  
    }  
  
    public void callPostData(String payload) {  
        externalClient.postData(payload);  
    }  
}

 

4. HttpClient

从 Java 11 开始，HttpClient 成为了 Java 标准库的一部分，为异步 HTTP 客户端提供了一个现代的 API。

以下是一个使用 Java 11 HttpClient 发送 GET 和 POST 请求的代码案例：

GET 请求

import java.io.IOException;  
import java.net.URI;  
import java.net.http.HttpClient;  
import java.net.http.HttpRequest;  
import java.net.http.HttpResponse;  
  
public class HttpClientGetExample {  
  
    public static void main(String[] args) {  
        HttpClient client = HttpClient.newHttpClient();  
        HttpRequest request = HttpRequest.newBuilder()  
                .uri(URI.create("http://api.example.com/data"))  
                .GET()  
                .build();  
  
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())  
                .thenApply(HttpResponse::body)  
                .thenAccept(System.out::println)  
                .join(); // 等待异步操作完成  
    }  
}

POST 请求

import java.io.IOException;  
import java.net.URI;  
import java.net.http.HttpClient;  
import java.net.http.HttpRequest;  
import java.net.http.HttpResponse;  
  
public class HttpClientPostExample {  
  
    public static void main(String[] args) {  
        HttpClient client = HttpClient.newHttpClient();  
        HttpRequest request = HttpRequest.newBuilder()  
                .uri(URI.create("http://api.example.com/data"))  
                .header("Content-Type", "application/json")  
                .POST(HttpRequest.BodyPublishers.ofString("{\"key\":\"value\"}"))  
                .build();  
  
        client.sendAsync(request, HttpResponse.BodyHandlers.ofString())  
                .thenApply(HttpResponse::body)  
                .thenAccept(System.out::println)  
                .join(); // 等待异步操作完成  
    }  
}

 

       在上面的 POST 请求示例中，我们设置了 Content-Type 为 application/json 并发送了一个简单的 JSON 字符串作为请求体。

请注意，HttpClient 的 sendAsync 方法是异步的，它返回一个 CompletableFuture<HttpResponse<String>>。在这个例子中，我们使用 .join() 方法来等待异步操作完成，这会导致当前线程阻塞直到 HTTP 响应被接收和处理。在生产环境中，你可能希望使用更复杂的异步处理机制，比如 CompletableFuture 的链式调用或与其他响应式框架集成。

CompletableFuture 可以看我另一篇博客：

CompletableFuture使用详解

此外，由于 HttpClient 是 Java 标准库的一部分，因此你不需要在项目中添加任何额外的依赖来使用它（除了 Java 11 或更高版本）。如果你使用的是旧版本的 Java，你可能需要查找其他 HTTP 客户端库，如 Apache HttpClient 或 OkHttp。

小结

以上四种方式各有特点，适用于不同的场景：

• RestTemplate 适用于简单的同步HTTP调用。

• WebClient和HttpClient 适用于响应式编程和异步处理。

• Feign 适用于声明式服务调用，简化客户端开