如何使用 RestTemplate 调用 RESTful API

落日映苍穹つ 2024-03-16 20:57 63阅读 0赞

## 如何使用 RestTemplate 调用 RESTful API？ ##

在开发 Web 应用程序时，调用 RESTful API 是一个常见的任务。为了调用 RESTful API，我们需要使用 HTTP 协议向 API 发送请求，并解析 API 返回的响应。为了简化这个过程，可以使用 Spring Framework 提供的 RestTemplate 类。本文将介绍如何使用 RestTemplate 调用 RESTful API，并提供示例代码。

![在这里插入图片描述][6ecab6823a1342c7a9baec52aa711ed8.png]

### 什么是 RestTemplate？ ###

RestTemplate 是 Spring Framework 提供的一个用于调用 RESTful API 的工具。RestTemplate 封装了对 HTTP 协议的访问，可以发送 HTTP 请求并解析 HTTP 响应。RestTemplate 支持多种 HTTP 方法（例如 GET、POST、PUT、DELETE 等），并提供了多种选项（例如请求头、请求参数等）来满足不同的需求。RestTemplate 简化了调用 RESTful API 的过程，避免了手动处理 HTTP 协议的复杂性。

### 如何使用 RestTemplate？ ###

使用 RestTemplate 调用 RESTful API 的步骤如下：

1.  创建 RestTemplate 实例

首先，需要创建一个 RestTemplate 实例。可以使用 Spring Boot 的自动配置来创建 RestTemplate 实例，或者手动创建 RestTemplate 实例。例如，下面是一个手动创建 RestTemplate 实例的示例代码：

RestTemplate restTemplate = new RestTemplate();

在上述示例代码中，我们使用了默认的构造函数来创建 RestTemplate 实例。也可以使用其他构造函数来配置 RestTemplate 实例，例如指定 HttpClient、HttpMessageConverter 等。

1.  发送 HTTP 请求

使用 RestTemplate 发送 HTTP 请求，可以调用 RestTemplate 的方法来发送不同类型的 HTTP 请求，例如 GET、POST、PUT、DELETE 等。例如，下面是一个使用 RestTemplate 发送 GET 请求的示例代码：

String url = "https://api.example.com/users/{id}";
    Map<String, String> params = new HashMap<>();
    params.put("id", "123");
    User user = restTemplate.getForObject(url, User.class, params);

在上述示例代码中，我们使用了 RestTemplate 的 `getForObject` 方法来发送 GET 请求，并将响应解析为 User 对象。`getForObject` 方法的第一个参数是请求的 URL，可以包含占位符（例如 `{id}`），占位符的值可以在第三个参数中指定。`getForObject` 方法的第二个参数是响应的类型，可以是任何 Java 类型，例如 String、Integer、List、Map 等。

可以使用 RestTemplate 的其他方法来发送 POST、PUT、DELETE 等类型的 HTTP 请求，例如：

*  `postForObject`：发送 POST 请求，并返回响应的对象。
 *  `put`：发送 PUT 请求，并返回响应的对象。
 *  `delete`：发送 DELETE 请求，并返回响应的对象。
 *  `exchange`：发送任意类型的 HTTP 请求，并返回响应的对象。

例如，下面是一个使用 RestTemplate 发送 POST 请求的示例代码：

String url = "https://api.example.com/users";
    User user = new User("张三", 18);
    HttpHeaders headers = new HttpHeaders();
    headers.setContentType(MediaType.APPLICATION_JSON);
    HttpEntity<User> requestEntity = new HttpEntity<>(user, headers);
    User createdUser = restTemplate.postForObject(url, requestEntity, User.class);

在上述示例代码中，我们使用了 RestTemplate 的 `postForObject` 方法来发送 POST 请求，并将请求体设置为 User 对象。为了设置请求体的类型，我们需要创建一个 HttpEntity 对象，并将 User 对象和请求头设置为 HttpEntity 的属性。

1.  处理 HTTP 响应

使用 RestTemplate 发送 HTTP 请求后，可以使用 RestTemplate 的方法来处理 HTTP 响应。例如，可以使用 `getForObject` 方法来将响应解析为对象，或者使用 `exchange` 方法来获取完整的 HTTP 响应。例如，下面是一个使用 RestTemplate 处理 GET 请求响应的示例代码：

String url = "https://api.example.com/users/{id}";
    Map<String, String> params = new HashMap<>();
    params.put("id", "123");
    ResponseEntity<User> responseEntity = restTemplate.getForEntity(url, User.class, params);
    HttpStatus statusCode = responseEntity.getStatusCode();
    User user =responseEntity.getBody();

在上述示例代码中，我们使用了 RestTemplate 的 `getForEntity` 方法来发送 GET 请求，并获取完整的 HTTP 响应。`getForEntity` 方法的返回值是一个 `ResponseEntity` 对象，包含了 HTTP 响应的状态码、响应头和响应体。我们可以使用 `getStatusCode` 方法获取 HTTP 响应的状态码，使用 `getBody` 方法获取响应体，并将其解析为 User 对象。

除了 `getForEntity` 方法外，还可以使用 `postForEntity`、`put`、`delete`、`exchange` 等方法来处理 HTTP 响应。

1.  错误处理

在使用 RestTemplate 调用 RESTful API 时，可能会发生一些错误，例如网络错误、HTTP 错误等。为了处理这些错误，可以使用 try-catch 块或使用 Spring Framework 提供的异常处理机制。例如，下面是一个使用 try-catch 块处理 HTTP 错误的示例代码：

String url = "https://api.example.com/users/{id}";
    Map<String, String> params = new HashMap<>();
    params.put("id", "123");
    try {
        
        User user = restTemplate.getForObject(url, User.class, params);
    } catch (HttpClientErrorException e) {
        
        HttpStatus statusCode = e.getStatusCode();
        String responseBody = e.getResponseBodyAsString();
        // 处理 HTTP 错误
    } catch (RestClientException e) {
        
        // 处理其它错误
    }

在上述示例代码中，我们使用了 try-catch 块来处理 HTTP 错误。如果发生 HTTP 错误，会抛出 `HttpClientErrorException` 异常，可以使用 `getStatusCode` 和 `getResponseBodyAsString` 方法来获取 HTTP 响应的状态码和响应体。

### 示例代码 ###

下面是一个完整的示例代码，演示如何使用 RestTemplate 调用 RESTful API：

import org.springframework.http.*;
    import org.springframework.web.client.RestTemplate;
    
    import java.util.HashMap;
    import java.util.Map;
    
    public class RestTemplateDemo {
        
        public static void main(String[] args) {
        
            RestTemplate restTemplate = new RestTemplate();
    
            // 发送 GET 请求
            String url = "https://api.example.com/users/{id}";
            Map<String, String> params = new HashMap<>();
            params.put("id", "123");
            User user = restTemplate.getForObject(url, User.class, params);
            System.out.println(user);
    
            // 发送 POST 请求
            url = "https://api.example.com/users";
            User newUser = new User("张三", 18);
            HttpHeaders headers = new HttpHeaders();
            headers.setContentType(MediaType.APPLICATION_JSON);
            HttpEntity<User> requestEntity = new HttpEntity<>(newUser, headers);
            User createdUser = restTemplate.postForObject(url, requestEntity, User.class);
            System.out.println(createdUser);
    
            // 处理 HTTP 响应
            url = "https://api.example.com/users/{id}";
            params = new HashMap<>();
            params.put("id", "123");
            ResponseEntity<User> responseEntity = restTemplate.getForEntity(url, User.class, params);
            HttpStatus statusCode = responseEntity.getStatusCode();
            User retrievedUser = responseEntity.getBody();
            System.out.println(statusCode);
            System.out.println(retrievedUser);
    
            // 错误处理
            url = "https://api.example.com/nonexistent";
            try {
        
                String result = restTemplate.getForObject(url, String.class);
                System.out.println(result);
            } catch (HttpClientErrorException e) {
        
                HttpStatus errorStatus = e.getStatusCode();
                String errorBody = e.getResponseBodyAsString();
                System.out.println(errorStatus);
                System.out.println(errorBody);
            } catch (RestClientException e) {
        
                e.printStackTrace();
            }
        }
    
        static class User {
        
            private String name;
            private int age;
    
            public User(String name, int age) {
        
                this.name = name;
                this.age = age;
            }
    
            public String getName() {
        
                return name;
            }
    
            public void setName(String name) {
        
                this.name = name;
            }
    
            public int getAge() {
        
                return age;
            }
    
            public void setAge(int age) {
        
                this.age = age;
            }
    
            @Override
            public String toString() {
        
                return "User{" +
                        "name='" + name + '\'' +
                        ", age=" + age +
                        '}';
            }
        }
    }

在上述示例代码中，我们首先创建了一个 RestTemplate 实例，然后演示了如何使用 RestTemplate 发送 GET 请求、POST 请求，并处理 HTTP 响应和错误。

### \#\# RestTemplate 的配置 ###

使用 RestTemplate 调用 RESTful API 时，可以通过配置 RestTemplate 实例来满足不同的需求。例如，可以配置 RestTemplate 的请求工厂、拦截器、消息转换器等。下面介绍几种常用的 RestTemplate 配置方法。

#### 配置请求工厂 ####

RestTemplate 使用 ClientHttpRequestFactory 接口来创建 HTTP 请求。默认情况下，RestTemplate 使用 SimpleClientHttpRequestFactory 实现来创建 HTTP 请求，可以通过设置连接超时和读取超时等参数来控制 HTTP 请求的行为。如果需要更高级的功能，例如连接池、SSL 支持等，可以使用其他实现类来替换 SimpleClientHttpRequestFactory 实现。

以下是一个示例代码，演示如何使用 HttpComponentsClientHttpRequestFactory 替换默认的 SimpleClientHttpRequestFactory 实现：

CloseableHttpClient httpClient = HttpClients.custom()
            .setDefaultRequestConfig(RequestConfig.custom()
                    .setConnectTimeout(5000)
                    .setSocketTimeout(5000)
                    .build())
            .build();
    HttpComponentsClientHttpRequestFactory requestFactory = new HttpComponentsClientHttpRequestFactory(httpClient);
    RestTemplate restTemplate = new RestTemplate(requestFactory);

在上述示例代码中，我们首先使用 HttpComponentsClientHttpRequestFactory 类创建一个请求工厂，然后将其传递给 RestTemplate 构造函数。HttpComponentsClientHttpRequestFactory 类使用 Apache HttpComponents 库实现，支持连接池、SSL 支持等高级功能。

#### 配置拦截器 ####

RestTemplate 支持添加拦截器来对 HTTP 请求进行处理。拦截器可以在发送 HTTP 请求前和收到 HTTP 响应后进行处理，例如添加请求头、记录请求日志等。

以下是一个示例代码，演示如何使用 ClientHttpRequestInterceptor 接口添加一个请求拦截器：

RestTemplate restTemplate = new RestTemplate();
    restTemplate.setInterceptors(Collections.singletonList((request, body, execution) -> {
        
        request.getHeaders().add("Authorization", "Bearer token");
        return execution.execute(request, body);
    }));

在上述示例代码中，我们添加了一个请求拦截器，它会在发送 HTTP 请求前添加一个 Authorization 请求头，值为 Bearer token。

#### 配置消息转换器 ####

RestTemplate 使用 HttpMessageConverter 接口来处理 HTTP 请求和响应的消息。默认情况下，RestTemplate 提供了多个内置的消息转换器，例如 StringHttpMessageConverter、MappingJackson2HttpMessageConverter 等。如果需要支持其他类型的消息，例如 XML、Protobuf 等，可以添加自定义的消息转换器。

以下是一个示例代码，演示如何添加一个自定义的消息转换器：

RestTemplate restTemplate = new RestTemplate();
    restTemplate.setMessageConverters(Collections.singletonList(new MyHttpMessageConverter()));

在上述示例代码中，我们添加了一个自定义的消息转换器 MyHttpMessageConverter，它实现了 HttpMessageConverter 接口，可以将自定义的消息类型转换为 HTTP 请求和响应的消息。

### 总结 ###

使用 RestTemplate 调用 RESTful API 是一种常见的任务，可以使用 Spring Framework 提供的 RestTemplate 类来简化这个过程。RestTemplate 封装了对 HTTP 协议的访问，可以发送 HTTP 请求并解析 HTTP 响应，支持多种 HTTP 方法和选项。RestTemplate 的使用步骤包括创建 RestTemplate 实例、发送 HTTP 请求、处理 HTTP 响应和错误处理。RestTemplate 还支持多种配置选项，例如配置请求工厂、拦截器和消息转换器等。使用 RestTemplate 可以简化调用 RESTful API 的过程，提高开发效率。

[6ecab6823a1342c7a9baec52aa711ed8.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/15/1c48809676e6467180d20c2edc0e77a3.png