SpringBoot调用外部接口的方式有哪些

发布时间：2023-04-10 16:54:42 作者：iii
来源：亿速云阅读：119

SpringBoot调用外部接口的方式有哪些

在现代的微服务架构中，Spring Boot 流行的 Java 框架，广泛用于构建独立的、生产级别的应用程序。在实际开发中，Spring Boot 应用程序经常需要与外部系统进行交互，调用外部接口是其中最常见的需求之一。本文将详细介绍 Spring Boot 调用外部接口的多种方式，包括使用 RestTemplate、WebClient、Feign、HttpURLConnection、Apache HttpClient 等，并探讨它们的优缺点及适用场景。

1. 使用 `RestTemplate`

RestTemplate 是 Spring 提供的一个用于同步 HTTP 请求的客户端工具类。它简化了与 RESTful 服务的交互，支持多种 HTTP 方法（如 GET、POST、PUT、DELETE 等），并且可以处理各种数据格式（如 JSON、XML 等）。

1.1 基本用法

首先，需要在 Spring Boot 项目中引入 spring-boot-starter-web 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-web</artifactId>
</dependency>

然后，可以通过 @Bean 注解将 RestTemplate 注入到 Spring 容器中：

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

接下来，可以在服务类中使用 RestTemplate 调用外部接口：

@Service
public class MyService {

    @Autowired
    private RestTemplate restTemplate;

    public String callExternalApi() {
        String url = "https://api.example.com/data";
        ResponseEntity<String> response = restTemplate.getForEntity(url, String.class);
        return response.getBody();
    }
}

1.2 高级用法

RestTemplate 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 RequestEntity 和 HttpHeaders 来设置请求头和请求体：

HttpHeaders headers = new HttpHeaders();
headers.set("Authorization", "Bearer token");
HttpEntity<String> entity = new HttpEntity<>(headers);

ResponseEntity<String> response = restTemplate.exchange(url, HttpMethod.GET, entity, String.class);

1.3 优缺点

优点： - 简单易用，适合快速开发。 - 支持同步请求，适合简单的 HTTP 调用场景。

缺点： - 同步阻塞模型，不适合高并发场景。 - 配置复杂，需要手动处理异常和超时。

2. 使用 `WebClient`

WebClient 是 Spring 5 引入的一个非阻塞的、响应式的 HTTP 客户端。它基于 Reactor 项目，支持异步请求和响应式编程模型。

2.1 基本用法

首先，需要在 Spring Boot 项目中引入 spring-boot-starter-webflux 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

然后，可以通过 @Bean 注解将 WebClient 注入到 Spring 容器中：

@Bean
public WebClient webClient() {
    return WebClient.create();
}

接下来，可以在服务类中使用 WebClient 调用外部接口：

@Service
public class MyService {

    @Autowired
    private WebClient webClient;

    public Mono<String> callExternalApi() {
        String url = "https://api.example.com/data";
        return webClient.get()
                        .uri(url)
                        .retrieve()
                        .bodyToMono(String.class);
    }
}

2.2 高级用法

WebClient 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 WebClient.Builder 来配置 WebClient：

@Bean
public WebClient webClient(WebClient.Builder builder) {
    return builder.baseUrl("https://api.example.com")
                  .defaultHeader("Authorization", "Bearer token")
                  .build();
}

2.3 优缺点

优点： - 非阻塞、响应式模型，适合高并发场景。 - 支持异步请求，适合复杂的 HTTP 调用场景。

缺点： - 学习曲线较陡，需要熟悉响应式编程。 - 配置复杂，需要手动处理异常和超时。

3. 使用 `Feign`

Feign 是一个声明式的 HTTP 客户端，它简化了与 RESTful 服务的交互。Feign 通过注解的方式定义接口，自动生成 HTTP 请求代码。

3.1 基本用法

首先，需要在 Spring Boot 项目中引入 spring-cloud-starter-openfeign 依赖：

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

然后，需要在启动类上添加 @EnableFeignClients 注解：

@SpringBootApplication
@EnableFeignClients
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

接下来，可以定义一个 Feign 客户端接口：

@FeignClient(name = "exampleClient", url = "https://api.example.com")
public interface ExampleClient {

    @GetMapping("/data")
    String getData();
}

最后，可以在服务类中使用 Feign 客户端接口调用外部接口：

@Service
public class MyService {

    @Autowired
    private ExampleClient exampleClient;

    public String callExternalApi() {
        return exampleClient.getData();
    }
}

3.2 高级用法

Feign 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 @RequestLine 和 @Headers 注解来设置请求方法和请求头：

@FeignClient(name = "exampleClient", url = "https://api.example.com")
public interface ExampleClient {

    @RequestLine("GET /data")
    @Headers("Authorization: Bearer token")
    String getData();
}

3.3 优缺点

优点： - 声明式编程模型，代码简洁易读。 - 支持多种高级功能，如负载均衡、熔断器等。

缺点： - 依赖 Spring Cloud 生态，不适合非微服务场景。 - 配置复杂，需要手动处理异常和超时。

4. 使用 `HttpURLConnection`

HttpURLConnection 是 Java 标准库中的一个类，用于发送 HTTP 请求。它是最基础的 HTTP 客户端，适合简单的 HTTP 调用场景。

4.1 基本用法

可以直接使用 HttpURLConnection 调用外部接口：

public String callExternalApi() throws IOException {
    String url = "https://api.example.com/data";
    URL obj = new URL(url);
    HttpURLConnection con = (HttpURLConnection) obj.openConnection();
    con.setRequestMethod("GET");

    int responseCode = con.getResponseCode();
    if (responseCode == HttpURLConnection.HTTP_OK) {
        BufferedReader in = new BufferedReader(new InputStreamReader(con.getInputStream()));
        String inputLine;
        StringBuilder response = new StringBuilder();

        while ((inputLine = in.readLine()) != null) {
            response.append(inputLine);
        }
        in.close();
        return response.toString();
    } else {
        throw new IOException("HTTP request failed with code: " + responseCode);
    }
}

4.2 高级用法

HttpURLConnection 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 setRequestProperty 方法设置请求头：

con.setRequestProperty("Authorization", "Bearer token");

4.3 优缺点

优点： - 无需额外依赖，适合简单的 HTTP 调用场景。 - 支持同步请求，适合简单的 HTTP 调用场景。

缺点： - 代码冗长，不易维护。 - 不支持异步请求，不适合高并发场景。

5. 使用 `Apache HttpClient`

Apache HttpClient 是 Apache 基金会提供的一个功能强大的 HTTP 客户端库。它支持同步和异步请求，适合复杂的 HTTP 调用场景。

5.1 基本用法

首先，需要在 Spring Boot 项目中引入 httpclient 依赖：

<dependency>
    <groupId>org.apache.httpcomponents</groupId>
    <artifactId>httpclient</artifactId>
</dependency>

然后，可以使用 HttpClient 调用外部接口：

public String callExternalApi() throws IOException {
    String url = "https://api.example.com/data";
    HttpClient client = HttpClients.createDefault();
    HttpGet request = new HttpGet(url);

    HttpResponse response = client.execute(request);
    HttpEntity entity = response.getEntity();

    if (entity != null) {
        return EntityUtils.toString(entity);
    } else {
        throw new IOException("No response entity");
    }
}

5.2 高级用法

Apache HttpClient 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 RequestConfig 配置超时：

RequestConfig config = RequestConfig.custom()
                                    .setConnectTimeout(5000)
                                    .setSocketTimeout(5000)
                                    .build();
HttpGet request = new HttpGet(url);
request.setConfig(config);

5.3 优缺点

优点： - 功能强大，支持同步和异步请求。 - 支持多种高级功能，如连接池、重试机制等。

缺点： - 配置复杂，需要手动处理异常和超时。 - 代码冗长，不易维护。

6. 使用 `OkHttp`

OkHttp 是 Square 公司开发的一个高效的 HTTP 客户端库。它支持同步和异步请求，适合复杂的 HTTP 调用场景。

6.1 基本用法

首先，需要在 Spring Boot 项目中引入 okhttp 依赖：

<dependency>
    <groupId>com.squareup.okhttp3</groupId>
    <artifactId>okhttp</artifactId>
</dependency>

然后，可以使用 OkHttpClient 调用外部接口：

public String callExternalApi() throws IOException {
    String url = "https://api.example.com/data";
    OkHttpClient client = new OkHttpClient();
    Request request = new Request.Builder()
                                .url(url)
                                .build();

    Response response = client.newCall(request).execute();
    return response.body().string();
}

6.2 高级用法

OkHttp 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 Interceptor 添加请求头：

OkHttpClient client = new OkHttpClient.Builder()
                                      .addInterceptor(chain -> {
                                          Request original = chain.request();
                                          Request request = original.newBuilder()
                                                                   .header("Authorization", "Bearer token")
                                                                   .build();
                                          return chain.proceed(request);
                                      })
                                      .build();

6.3 优缺点

优点： - 高效、轻量，适合复杂的 HTTP 调用场景。 - 支持同步和异步请求，适合高并发场景。

缺点： - 配置复杂，需要手动处理异常和超时。 - 代码冗长，不易维护。

7. 使用 `Retrofit`

Retrofit 是 Square 公司开发的一个类型安全的 HTTP 客户端库。它基于 OkHttp，支持同步和异步请求，适合复杂的 HTTP 调用场景。

7.1 基本用法

首先，需要在 Spring Boot 项目中引入 retrofit 依赖：

<dependency>
    <groupId>com.squareup.retrofit2</groupId>
    <artifactId>retrofit</artifactId>
</dependency>

然后，可以定义一个 Retrofit 接口：

public interface ExampleService {

    @GET("/data")
    Call<String> getData();
}

接下来，可以使用 Retrofit 调用外部接口：

public String callExternalApi() throws IOException {
    String url = "https://api.example.com";
    Retrofit retrofit = new Retrofit.Builder()
                                    .baseUrl(url)
                                    .addConverterFactory(ScalarsConverterFactory.create())
                                    .build();

    ExampleService service = retrofit.create(ExampleService.class);
    Call<String> call = service.getData();
    Response<String> response = call.execute();
    return response.body();
}

7.2 高级用法

Retrofit 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 OkHttpClient 配置超时：

OkHttpClient client = new OkHttpClient.Builder()
                                      .connectTimeout(5, TimeUnit.SECONDS)
                                      .readTimeout(5, TimeUnit.SECONDS)
                                      .build();

Retrofit retrofit = new Retrofit.Builder()
                                .baseUrl(url)
                                .client(client)
                                .addConverterFactory(ScalarsConverterFactory.create())
                                .build();

7.3 优缺点

优点： - 类型安全，代码简洁易读。 - 支持同步和异步请求，适合复杂的 HTTP 调用场景。

缺点： - 依赖 OkHttp，配置复杂。 - 学习曲线较陡，需要熟悉 Retrofit 的注解和配置。

8. 使用 `Spring Cloud OpenFeign`

Spring Cloud OpenFeign 是 Spring Cloud 提供的一个声明式的 HTTP 客户端库。它基于 Feign，支持负载均衡、熔断器等高级功能，适合微服务场景。

8.1 基本用法

首先，需要在 Spring Boot 项目中引入 spring-cloud-starter-openfeign 依赖：

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

然后，需要在启动类上添加 @EnableFeignClients 注解：

@SpringBootApplication
@EnableFeignClients
public class MyApplication {
    public static void main(String[] args) {
        SpringApplication.run(MyApplication.class, args);
    }
}

接下来，可以定义一个 Feign 客户端接口：

@FeignClient(name = "exampleClient", url = "https://api.example.com")
public interface ExampleClient {

    @GetMapping("/data")
    String getData();
}

最后，可以在服务类中使用 Feign 客户端接口调用外部接口：

@Service
public class MyService {

    @Autowired
    private ExampleClient exampleClient;

    public String callExternalApi() {
        return exampleClient.getData();
    }
}

8.2 高级用法

Spring Cloud OpenFeign 支持多种高级功能，如负载均衡、熔断器等。例如，可以通过 @FeignClient 注解配置负载均衡：

@FeignClient(name = "exampleClient", url = "https://api.example.com", configuration = FeignConfig.class)
public interface ExampleClient {

    @GetMapping("/data")
    String getData();
}

8.3 优缺点

优点： - 声明式编程模型，代码简洁易读。 - 支持负载均衡、熔断器等高级功能，适合微服务场景。

缺点： - 依赖 Spring Cloud 生态，不适合非微服务场景。 - 配置复杂，需要手动处理异常和超时。

9. 使用 `Spring WebFlux`

Spring WebFlux 是 Spring 5 引入的一个响应式的 Web 框架。它基于 Reactor 项目，支持非阻塞、响应式的编程模型，适合高并发场景。

9.1 基本用法

首先，需要在 Spring Boot 项目中引入 spring-boot-starter-webflux 依赖：

<dependency>
    <groupId>org.springframework.boot</groupId>
    <artifactId>spring-boot-starter-webflux</artifactId>
</dependency>

然后，可以使用 WebClient 调用外部接口：

@Service
public class MyService {

    @Autowired
    private WebClient webClient;

    public Mono<String> callExternalApi() {
        String url = "https://api.example.com/data";
        return webClient.get()
                        .uri(url)
                        .retrieve()
                        .bodyToMono(String.class);
    }
}

9.2 高级用法

Spring WebFlux 支持多种高级功能，如设置请求头、处理异常、配置超时等。例如，可以通过 WebClient.Builder 配置 WebClient：

@Bean
public WebClient webClient(WebClient.Builder builder) {
    return builder.baseUrl("https://api.example.com")
                  .defaultHeader("Authorization", "Bearer token")
                  .build();
}

9.3 优缺点

优点： - 非阻塞、响应式模型，适合高并发场景。 - 支持异步请求，适合复杂的 HTTP 调用场景。

缺点： - 学习曲线较陡，需要熟悉响应式编程。 - 配置复杂，需要手动处理异常和超时。

10. 使用 `Spring Cloud Gateway`

Spring Cloud Gateway 是 Spring Cloud 提供的一个 API 网关。它基于 Spring WebFlux，支持非阻塞、响应式的编程模型，适合微服务场景。

10.1 基本用法

首先，需要在 Spring Boot 项目中引入 spring-cloud-starter-gateway 依赖：

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

然后，可以配置路由规则：

spring:
  cloud:
    gateway:
      routes:
        - id: example_route
          uri: https://api.example.com
          predicates:
            - Path=/data

接下来，可以通过网关调用外部接口：

@Service
public class MyService {

    @Autowired
    private WebClient webClient;

    public Mono<String> callExternalApi() {
        String url = "http://localhost:8080/data";
        return webClient.get()
                        .uri(url)
                        .retrieve()
                        .bodyToMono(String.class);
    }
}

10.2 高级用法

Spring Cloud Gateway 支持多种高级功能，如负载均衡、熔断器等。例如，可以通过 RouteLocator 配置负载均衡：

@Bean
public RouteLocator customRouteLocator(RouteLocatorBuilder builder) {
    return builder.routes()
                  .route("example_route", r -> r.path("/data")
                                                .uri("lb://example-service"))
                  .build();
}

10.3 优缺点

优点： - 非阻塞、响应式模型，适合高并发场景。 - 支持负载均衡、熔断器等高级功能，适合微

SpringBoot调用外部接口的方式有哪些

SpringBoot调用外部接口的方式有哪些

1. 使用 RestTemplate

1.1 基本用法

1.2 高级用法

1.3 优缺点

2. 使用 WebClient

2.1 基本用法

2.2 高级用法

2.3 优缺点

3. 使用 Feign

3.1 基本用法

3.2 高级用法

3.3 优缺点

4. 使用 HttpURLConnection

4.1 基本用法

4.2 高级用法

4.3 优缺点

5. 使用 Apache HttpClient

5.1 基本用法

5.2 高级用法

5.3 优缺点

6. 使用 OkHttp

6.1 基本用法

6.2 高级用法

6.3 优缺点

7. 使用 Retrofit

7.1 基本用法

7.2 高级用法

7.3 优缺点

8. 使用 Spring Cloud OpenFeign

8.1 基本用法

8.2 高级用法

8.3 优缺点

9. 使用 Spring WebFlux

9.1 基本用法

9.2 高级用法

9.3 优缺点

10. 使用 Spring Cloud Gateway

10.1 基本用法

10.2 高级用法

10.3 优缺点

相关阅读

1. 使用 `RestTemplate`

2. 使用 `WebClient`

3. 使用 `Feign`

4. 使用 `HttpURLConnection`

5. 使用 `Apache HttpClient`

6. 使用 `OkHttp`

7. 使用 `Retrofit`

8. 使用 `Spring Cloud OpenFeign`

9. 使用 `Spring WebFlux`

10. 使用 `Spring Cloud Gateway`