SpringBoot3 常用的第三方接口调用十种方式

环境：SpringBoot.3.3.0
在这里插入图片描述

简介
在项目中调用第三方接口是日常开发中非常常见的。调用方式的选择通常遵循公司既定的技术栈和架构规范，以确保项目的一致性和可维护性。无论是RESTful API调用、Feign声明式HTTP客户端、Apache HttpClient等调用方式，每种方式都有其适用场景和优势，选择最适合的方式将有助于提高开发效率和系统性能。接下来将全面介绍10种第三方接口调用的实现方式。
实战案例
2.1 JDK URL

URL url = URI.create("http://192.168.0.124:8000/api/data").toURL() ;
URLConnection connection = url.openConnection() ;
connection.setDoInput(true) ;
connection.setDoOutput(true) ;
InputStream inputStream = connection.getInputStream() ;
String ret = StreamUtils.copyToString(inputStream, StandardCharsets.UTF_8) ;
System.out.println(ret) ;

2.2 JDK HttpClient

URI uri = URI.create("http://192.168.0.124:8000/api/data") ;
HttpClient client = HttpClient.newBuilder()
.connectTimeout(Duration.ofSeconds(3))
.executor(Executors.newCachedThreadPool()
.build() ;
HttpRequest request = HttpRequest.newBuilder(uri).GET().build();
HttpResponse<String> response = client.send(request, BodyHandlers.ofString()) ;
System.out.println(response.body()) ;

2.3 Apache Http Client

HttpGet httpget = new HttpGet("http://192.168.0.124:8000/api/data") ;
CloseableHttpClient client = HttpClients.custom().build() ;
HttpClientResponseHandler<String> responseHandler = new BasicHttpClientResponseHandler() ; 
String ret = client.execute(httpget, responseHandler) ;
System.out.println(ret) ;

Apache HttpClient 5是一个支持HTTP/2、高度可定制、支持异步请求的开源HTTP工具包，提供了丰富的API和扩展特性。异步请求方式：

CloseableHttpAsyncClient client = HttpAsyncClients.custom().build() ;
client.start() ;
SimpleHttpRequest request = SimpleRequestBuilder.get().setHttpHost(HttpHost.create("http://192.168.0.124:8000")).setPath("/api/data").build() ;
FutureCallback<SimpleHttpResponse> callback = new FutureCallback<SimpleHttpResponse>() {@Overridepublic void failed(Exception ex) {System.err.printf("请求失败: %s%n", ex.getMessage()) ;}@Overridepublic void completed(SimpleHttpResponse result) {System.out.printf("当前线程: %s, 请求完成...%n", Thread.currentThread().getName()) ;}public void cancelled() {}
};
Future<SimpleHttpResponse> future = client.execute(request, callback) ;
System.out.println(new String(future.get().getBodyBytes(), StandardCharsets.UTF_8)) ;
client.close(CloseMode.GRACEFUL) ;

Apache Client功能还是非常强大的。
2.4 OkHttp
OkHttp是一个高效的HTTP客户端:
HTTP/2 支持允许对同一主机的所有请求共享一个套接字。
连接池可减少请求延迟（如果 HTTP/2 不可用）。
透明GZIP缩小了下载大小。
响应缓存可完全避免网络重复请求。
使用 OkHttp 非常简单。其请求/响应 API 采用流畅的构建器和不变性设计。它既支持同步阻塞调用，也支持带回调的异步调用。

URL url = URI.create("http://192.168.0.124:8000/api/data").toURL() ;
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(url).build() ;
try (Response response = client.newCall(request).execute()) {System.out.println(response.body().string()) ;
}

异步请求

URL url = URI.create("http://192.168.0.124:8000/api/data").toURL() ;
OkHttpClient client = new OkHttpClient();
Request request = new Request.Builder().url(url).build();
client.newCall(request).enqueue(new Callback() {public void onResponse(Call call, Response response) throws IOException {System.out.printf("当前线程: %s, 内容: %s%n", Thread.currentThread().getName(), response.body().string()) ;}public void onFailure(Call call, IOException e) {System.err.printf("请求失败: %s%n", e.getMessage()) ;}
}) ;

2.5 RestTemplate
RestTemplate是我们项目中最为常用的接口调用方式了，它以经典 Spring Template 类的形式为 HTTP 客户端库提供了高级 API。

RestTemplate restTemplate = new RestTemplate() ;
Map ret = restTemplate.getForObject(URI.create("http://192.168.0.124:8000/api/data"), Map.class) ;
System.out.println(ret) ;

通过RestTemplateBuilder可以对RestTemplate提供更多的配置。

RestTemplate restTemplate = new RestTemplateBuilder()// 设置超时时间.setConnectTimeout(Duration.ofSeconds(5)).setReadTimeout(Duration.ofSeconds(5))// 设置拦截器.interceptors(List.of()).build() ;
Map ret = restTemplate.getForObject(URI.create("http://192.168.0.124:8000/api/data"), Map.class) ;
System.out.println(ret) ;

注：默认情况下RestTemplate是通过JDK URL实现接口访问，我们可以自定义设置Apache Http或OKHttp实现。
2.6 WebClient
WebClient 是执行 HTTP 请求的非阻塞、反应式客户端。它在 Spring 5.0 中引入，提供了 RestTemplate 的替代方案，支持同步、异步和流场景。WebClient 支持以下功能：
非阻塞IO
反应流背压
用较少的硬件资源实现高并发
利用 Java 8 lambdas 的函数式流畅应用程序接口
支持同步和异步交互
向服务器传输数据流或从服务器向下传输数据流
WebClient 需要一个 HTTP 客户端库来执行请求。内置的支持包括：
Reactor Netty
JDK HttpClient
Jetty Reactive HttpClient
Apache HttpComponents
其他可以通过ClientHttpConnector插入。
如下示例：

WebClient client = WebClient.create("http://192.168.0.124:8000");
client.get().uri("/api/data")// 获取结果.retrieve().bodyToMono(String.class).subscribe(System.out::println) ;

更多配置，超时/错误


HttpClient httpClient = HttpClient.create().option(ChannelOption.CONNECT_TIMEOUT_MILLIS, 10000) ;
WebClient client = WebClient.builder().clientConnector(new ReactorClientHttpConnector(httpClient)).build() ;
client.get().uri("http://192.168.0.124:8000/api/data").retrieve().onStatus(HttpStatusCode::is4xxClientError, resp -> Mono.error(new RuntimeException("客户端请求错误"))).bodyToMono(String.class).subscribe(System.out::println) ;
System.in.read() ;

通过WebClient#builder可以进行更多的配置信息。
2.7 RestClient
RestClient是Spring6.1起添加的新的API。创建（或构建）后，RestClient 可由多个线程安全使用。

RestClient client = RestClient.create() ;
ParameterizedTypeReference<Map<String, Object>> bodyType = new ParameterizedTypeReference<Map<String, Object>>() {} ;
Map<String, Object> ret = client.get().uri(URI.create("http://192.168.0.124:8000/api/data")).retrieve().body(bodyType) ;

还可以通过RestClient#builder

RestClient client = RestClient.builder()// 设置请求Header.defaultHeader("Authorization", "Bearer eGvS0owCfhwkTcCHghNFMwOWODoz8WWXGhDT80R-EuBY7-EBNaMyZPsAZI0pmy3Zg7BTnoS3VTQlz_e7AKslpDL39trOYv_BY9uw5lZthsAi404iZnhWJz2p5v1Mm6Xb")// 设置拦截器.requestInterceptor((request, body, execution) -> execution.execute(request, body)).baseUrl("http://192.168.0.124:8000").build() ;

通过builder方式，你还可以进行更多的设置，具体查看API。
2.8 Http Interface
将 HTTP 服务定义为带有 @HttpExchange 方法的 Java 接口。你可以将这样的接口传递给 HttpServiceProxyFactory，创建一个代理，通过 HTTP 客户端（如 RestClient 或 WebClient）执行请求。

// 接口定义
public interface RemoteClient {@GetExchange("/api/data")Map<String, Object> queryInfo() ;
}
// 执行调用
RestClient restClient = RestClient.builder().baseUrl("http://192.168.0.124:8000").build() ;
RestClientAdapter adapter = RestClientAdapter.create(restClient) ;
HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(adapter).build() ;
RemoteClient client = factory.createClient(RemoteClient.class);
System.out.println(client.queryInfo()) ;

上面调用通过RestClient进行，你也可以换成RestTemplate。

2.9 OpenFeign
注意这里是OpenFeign可不是Spring Cloud OpenFeign，Spring Cloud openfeign对OpenFeign进行了包装，所以在使用上是有差别的。

<!--feign 依赖-->
<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-starter-openfeign</artifactId>
</dependency>

示例代码

// 接口定义
public interface RemoteClient {@RequestLine("GET /api/data")Map<String, Object> queryInfo() ;
}
// 接口调用
RemoteClient client = Feign.builder().decoder(new JacksonDecoder()).target(RemoteClient.class, "http://192.168.0.124:8000") ;
Map<String, Object> ret = client.queryInfo() ;

OpenFeign还是至其他很多的注解，如：@Param，@Headers，@Body等。
2.10 Gateway Proxy
引入依赖

<dependency><groupId>org.springframework.cloud</groupId><artifactId>spring-cloud-gateway-mvc</artifactId>
</dependency>

代码示例

private URI uri = URI.create("http://192.168.0.124:8000");@GetMapping("/api")
public ResponseEntity<?> proxy(ProxyExchange<byte[]> proxy) throws Exception {return proxy.uri(String.format("%s%s", uri.toString(), "/api/data")).get() ;
}

在上面的方法中通过ProxyExchange进行远程接口的调用。

Spring Boot 3太强：全新Controller接口定义方式

回顾定义接口方式

1.1 常规定义

@RestController
@RequestMapping("/user")
public class UsersController {@PostMapping("addUer")public Object save(@RequestBody Users users) {}
}

正确Servlet定义方法


@Component("/user/api")
public class ControllerHttpRequestHandler implements HttpRequestHandler {public void handleRequest(HttpServletRequest request, HttpServletResponse response) throws ServletException, 		      IOException {response.setContentType("text/html;charset=utf8");PrintWriter out = response.getWriter() ;out.print("<h1>你好，HttpRequestHandler</h1>") ;out.close() ;}
}

注意：接下来定义接口的方式需要在Spring6.0以上版本
2. 新的定义方式

从Spring6开始新增了一个新注解@HttpExchange。该注解将一个类或具体方法声明为HTTP 接口。接口的细节通过注解的属性以及方法参数定义。如下示例：


@HttpExchange("/persons")
interface PersonService {@GetExchange("/{id}")Person getPerson(@PathVariable Long id);@PostExchangevoid add(@RequestBody Person person) ;
}
// Person对象
@Data
@TableName("person")
@EqualsAndHashCode(callSuper = false)
public class Person {private Long id ;private String name ;
}

实现接口

@RestController
public class PersonController implements PersonService {public Person getPerson(@PathVariable Long id) {return new Person(id, "姓名 - " + id) ;}@ResponseStatus(HttpStatus.CREATED)public void add(@RequestBody Person person) {}
}

除了上面使用的@GetExchange和@PostExchange，还有下面这几个注解：
@DeleteExchange
@PatchExchange
@PutExchange
与@RequestMapping一样，这里的@HttpExchange注解也可以直接使用到方法上，如下：

@HttpExchange(value = "/list", method = "GET")
default List<Person> listPerson() {return List.of(new Person(100L, "mandala")) ;
} ;

@HttpExchange真正目的
@HttpExchange的主要目的是使用生成的代理抽象HTTP客户端代码。如下示例
还是使用上面的PersonService接口定义，通过该接口生成代理类

@Configuration
public class PersonServiceClient {@BeanPersonService personServiceProxy() {RestClient restClient = RestClient.builder().baseUrl("http://192.168.13.124:8000").build();RestClientAdapter adapter = RestClientAdapter.create(restClient);HttpServiceProxyFactory factory = HttpServiceProxyFactory.builderFor(adapter).build();PersonService personService = factory.createClient(PersonService.class);return personService ;}}

将PersonService创建代理对象，通过JDK代理。注意：这里的RestClient必须使用Spring6.1以上版本，如果你不是那你可以换成RestTemplate.


@Resource
private PersonService personServiceProxy;@GetMapping("/persons")
public List<Person> list() {return this.personServiceProxy.listPerson() ;
}