¿Cómo usar RestTemplate para llamar a la API RESTful?

Llamar a las API RESTful es una tarea común al desarrollar aplicaciones web. Para llamar a la API RESTful, necesitamos usar el protocolo HTTP para enviar una solicitud a la API y analizar la respuesta devuelta por la API. Para simplificar este proceso, puede usar la clase RestTemplate proporcionada por Spring Framework. Este artículo presentará cómo usar RestTemplate para llamar a la API RESTful y proporcionará un código de muestra.

inserte la descripción de la imagen aquí

¿Qué es RestTemplate?

RestTemplate es una herramienta proporcionada por Spring Framework para llamar a la API RESTful. RestTemplate encapsula el acceso al protocolo HTTP, puede enviar solicitudes HTTP y analizar respuestas HTTP. RestTemplate admite una variedad de métodos HTTP (como GET, POST, PUT, DELETE, etc.) y proporciona una variedad de opciones (como encabezados de solicitud, parámetros de solicitud, etc.) para satisfacer diferentes necesidades. RestTemplate simplifica el proceso de invocar API RESTful, evitando la complejidad de manejar manualmente el protocolo HTTP.

¿Cómo usar RestTemplate?

Los pasos para llamar a la API RESTful usando RestTemplate son los siguientes:

Crear una instancia de RestTemplate

Primero, se debe crear una instancia de RestTemplate. Las instancias de RestTemplate se pueden crear utilizando la configuración automática de Spring Boot o manualmente. Por ejemplo, aquí hay un código de muestra que crea manualmente una instancia de RestTemplate:

RestTemplate restTemplate = new RestTemplate();

En el código de muestra anterior, usamos el constructor predeterminado para crear la instancia de RestTemplate. También se pueden usar otros constructores para configurar la instancia de RestTemplate, como especificar HttpClient, HttpMessageConverter, etc.

enviar solicitud HTTP

Use RestTemplate para enviar solicitudes HTTP, puede llamar a los métodos de RestTemplate para enviar diferentes tipos de solicitudes HTTP, como GET, POST, PUT, DELETE, etc. Por ejemplo, aquí hay un código de muestra que usa RestTemplate para enviar una solicitud 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);

En el código de muestra anterior, usamos el getForObjectmétodo para enviar una solicitud GET y analizar la respuesta en un objeto Usuario. getForObjectEl primer parámetro del método es la URL solicitada, que puede contener marcadores de posición (por ejemplo {id}), cuyos valores se pueden especificar en el tercer parámetro. getForObjectEl segundo parámetro del método es el tipo de respuesta, que puede ser cualquier tipo de Java, como String, Integer, List, Map, etc.

Puede usar otros métodos de RestTemplate para enviar POST, PUT, DELETE y otros tipos de solicitudes HTTP, por ejemplo:

postForObject: envía una solicitud POST y devuelve un objeto de respuesta.
put: envía una solicitud PUT y devuelve el objeto de respuesta.
delete: envía una solicitud DELETE y devuelve el objeto de respuesta.
exchange: envía cualquier tipo de solicitud HTTP y devuelve un objeto de respuesta.

Por ejemplo, aquí hay un código de muestra que usa RestTemplate para enviar una solicitud 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);

En el código de ejemplo anterior, usamos postForObjectel método para enviar una solicitud POST y establecer el cuerpo de la solicitud como objeto Usuario. Para establecer el tipo de cuerpo de la solicitud, debemos crear un objeto HttpEntity y establecer el objeto Usuario y el encabezado de la solicitud como propiedades de HttpEntity.

Manejar respuestas HTTP

Después de enviar una solicitud HTTP usando RestTemplate, puede usar los métodos de RestTemplate para procesar la respuesta HTTP. Por ejemplo, puede usar getForObjectel método para analizar la respuesta en un objeto o exchangeel método para obtener la respuesta HTTP completa. Por ejemplo, aquí hay un código de muestra que usa RestTemplate para manejar una respuesta de solicitud 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();

En el código de muestra anterior, usamos getForEntityel método para enviar una solicitud GET y obtener la respuesta HTTP completa. getForEntityEl valor de retorno del método es un ResponseEntityobjeto , que contiene el código de estado, el encabezado de respuesta y el cuerpo de respuesta de la respuesta HTTP. Podemos usar getStatusCodeel método para obtener el código de estado de la respuesta HTTP, usar getBodyel método para obtener el cuerpo de la respuesta y analizarlo en un objeto Usuario.

Además getForEntitydel método , también se pueden usar métodos como postForEntity, put, delete, etc. para procesar respuestas HTTP.exchange

manejo de errores

Al usar RestTemplate para llamar a la API RESTful, pueden ocurrir algunos errores, como error de red, error HTTP, etc. Para manejar estos errores, puede usar bloques try-catch o usar el mecanismo de manejo de excepciones provisto por Spring Framework. Por ejemplo, aquí hay un código de muestra que usa un bloque try-catch para manejar errores 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) {
    
    
    // 处理其它错误
}

En el código de muestra anterior, usamos un bloque try-catch para manejar los errores HTTP. Si se produce un error HTTP, se generará HttpClientErrorExceptionuna excepción getStatusCodey se pueden usar los getResponseBodyAsStringmétodos para obtener el código de estado y el cuerpo de respuesta de la respuesta HTTP.

Código de muestra

Aquí hay un código de muestra completo que demuestra cómo usar RestTemplate para llamar a la API RESTful:

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 +
                    '}';
        }
    }
}

En el código de muestra anterior, primero creamos una instancia de RestTemplate y luego demostramos cómo usar RestTemplate para enviar solicitudes GET, solicitudes POST y manejar respuestas y errores HTTP.

## Configuración de RestTemplate

Al usar RestTemplate para llamar a la API RESTful, puede configurar la instancia de RestTemplate para cumplir con diferentes requisitos. Por ejemplo, se pueden configurar fábricas de solicitudes, interceptores, convertidores de mensajes, etc. de RestTemplate. A continuación, se presentan varios métodos de configuración de RestTemplate comúnmente utilizados.

configurar fábrica de solicitudes

RestTemplate usa la interfaz ClientHttpRequestFactory para crear solicitudes HTTP. De forma predeterminada, RestTemplate usa la implementación de SimpleClientHttpRequestFactory para crear solicitudes HTTP y puede controlar el comportamiento de las solicitudes HTTP configurando parámetros como el tiempo de espera de conexión y el tiempo de espera de lectura. Si necesita funciones más avanzadas, como agrupación de conexiones, compatibilidad con SSL, etc., puede usar otras clases de implementación para reemplazar la implementación de SimpleClientHttpRequestFactory.

Aquí hay un código de muestra que demuestra cómo reemplazar la implementación predeterminada de SimpleClientHttpRequestFactory con HttpComponentsClientHttpRequestFactory:

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

En el código de muestra anterior, primero creamos una fábrica de solicitudes usando la clase HttpComponentsClientHttpRequestFactory y luego la pasamos al constructor RestTemplate. La clase HttpComponentsClientHttpRequestFactory se implementa mediante la biblioteca Apache HttpComponents y admite funciones avanzadas, como agrupación de conexiones y compatibilidad con SSL.

Configurar interceptores

RestTemplate admite la adición de interceptores para manejar solicitudes HTTP. Los interceptores pueden procesar antes de enviar solicitudes HTTP y después de recibir respuestas HTTP, como agregar encabezados de solicitud, registrar registros de solicitudes, etc.

El siguiente es un código de muestra que muestra cómo agregar un interceptor de solicitudes mediante la interfaz ClientHttpRequestInterceptor:

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

En el código de muestra anterior, agregamos un interceptor de solicitudes, que agregará un encabezado de solicitud de autorización antes de enviar la solicitud HTTP, el valor es el token de portador.

Configurar el convertidor de mensajes

RestTemplate usa la interfaz HttpMessageConverter para manejar mensajes de solicitud y respuesta HTTP. De forma predeterminada, RestTemplate proporciona varios convertidores de mensajes integrados, como StringHttpMessageConverter, MappingJackson2HttpMessageConverter, etc. Si necesita admitir otros tipos de mensajes, como XML, Protobuf, etc., puede agregar convertidores de mensajes personalizados.

Aquí hay un código de muestra que demuestra cómo agregar un convertidor de mensajes personalizado:

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

En el código de ejemplo anterior, agregamos un convertidor de mensajes personalizado MyHttpMessageConverter, que implementa la interfaz HttpMessageConverter, que puede convertir tipos de mensajes personalizados en mensajes de solicitud y respuesta HTTP.

Resumir

El uso de RestTemplate para llamar a una API RESTful es una tarea común y la clase RestTemplate proporcionada por Spring Framework se puede usar para simplificar este proceso. RestTemplate encapsula el acceso al protocolo HTTP, puede enviar solicitudes HTTP y analizar respuestas HTTP, y admite múltiples métodos y opciones HTTP. Los pasos para usar RestTemplate incluyen la creación de una instancia de RestTemplate, el envío de solicitudes HTTP, el procesamiento de respuestas HTTP y el manejo de errores. RestTemplate también admite varias opciones de configuración, como la configuración de fábricas de solicitudes, interceptores y convertidores de mensajes, etc. El uso de RestTemplate puede simplificar el proceso de llamar a la API RESTful y mejorar la eficiencia del desarrollo.

Cómo usar RestTemplate para llamar a la API RESTful