Una guía esencial para los clientes HTTP y los microservicios Spring Boot

¡Hola! Mi nombre es Viacheslav Aksenov y soy un desarrollador backend especializado en desarrollar sistemas backend complejos en Java y Kotlin. Además, tengo muchos pequeños proyectos favoritos que puedes encontrar en mi GitHub: https://github.com/v-aksenov

¿Qué es un microservicio?

Un microservicio es un servicio pequeño e independiente que está diseñado para realizar una tarea específica o un conjunto de tareas dentro de una aplicación más grande. Cada microservicio se desarrolla e implementa independientemente de los otros microservicios en el sistema y se comunica con otros microservicios a través de API.

Los microservicios también ofrecen varios otros beneficios, incluida una escalabilidad mejorada, una mejor tolerancia a fallas y una mayor agilidad. Al desglosar una aplicación en servicios más pequeños e independientes, los desarrolladores pueden ampliar o reducir fácilmente los componentes individuales según sea necesario y pueden responder rápidamente a los cambios en las necesidades de los usuarios o las condiciones del mercado.

Sin embargo, los microservicios también presentan algunos desafíos, como la necesidad de una sólida gestión de API, detección de servicios y seguimiento distribuido. Diseñar e implementar correctamente los microservicios requiere una planificación y coordinación cuidadosas en todo el equipo de desarrollo, así como una comprensión profunda de los requisitos y limitaciones únicos del sistema que se está desarrollando.

¿Cuándo se requieren clientes HTTP para los microservicios?

Para responder a esta pregunta, debemos responder a la pregunta "¿De qué es responsable este servicio actual?"

Muy a menudo, en la lógica comercial del servicio, hay una situación en la que necesitamos obtener una respuesta de una API de terceros. O además, tenemos varios microservicios en cadena para manejar nuestro proceso comercial. En estas situaciones tenemos que implementar el cliente HTTP en nuestro microservicio.

En una arquitectura de microservicios, un cliente HTTP es un componente de software que se comunica con otros microservicios a través del protocolo HTTP. El cliente HTTP es responsable de realizar solicitudes a otros microservicios y recibir respuestas.

Cuando un microservicio necesita comunicarse con otro microservicio, normalmente envía una solicitud HTTP al punto final apropiado del otro microservicio. La solicitud HTTP puede incluir una carga útil de datos, como un objeto JSON o un documento XML, que el microservicio receptor puede usar para realizar su tarea.

¿Cómo implementar el cliente HTTP en un microservicio Spring Boot?

Hay varias formas de implementar el cliente HTTP en el servicio Spring Boot. En primer lugar, debe elegir: ¿será un cliente síncrono o asíncrono?

Por ejemplo, si tiene una arquitectura síncrona, puede elegir una de las soluciones que proporciona Spring Boot.

En Spring Boot, un cliente HTTP síncrono es un componente que se utiliza para realizar solicitudes HTTP a otros servicios o puntos finales y bloquea el hilo actual hasta que se recibe la respuesta. Spring Boot ofrece varias opciones para implementar clientes HTTP sincrónicos, incluidas las clases RestTemplate y WebClient .

RestTemplate es una opción popular para implementar clientes HTTP síncronos en Spring Boot. Proporciona una API simple e intuitiva para realizar solicitudes HTTP y manejar respuestas, y admite una amplia gama de métodos HTTP, tipos de solicitudes y respuestas y convertidores de mensajes. Para usar RestTemplate , debe configurarlo como un bean en el contexto de su aplicación y luego usarlo para realizar solicitudes HTTP llamando a sus diversos métodos.

Hay un ejemplo de uso de RestTemplate para solicitud POST HTTP:

 public RegisterResponse registerUser(UserDto userDto) { HttpEntity<UserDto> requestEntity = new HttpEntity<>(user, headers); ResponseEntity<String> responseEntity = restTemplate.postForEntity(url, requestEntity, RegisterResponse.class); if (responseEntity.getStatusCode() == HttpStatus.OK) { RegisterResponse response = responseEntity.getBody(); // handle the response } else { // handle the error } }

Otra opción para implementar clientes HTTP síncronos en Spring Boot es usar la clase WebClient . WebClient es un cliente HTTP reactivo que proporciona una API sin bloqueo para realizar solicitudes HTTP y manejar respuestas, y es ideal para aplicaciones que requieren altos niveles de concurrencia o escalabilidad. Para usar WebClient , debe configurarlo como un bean en el contexto de su aplicación y luego usarlo para realizar solicitudes HTTP llamando a sus diversos métodos.

 public RegisterResponse registerUser(UserDto userDto) { Mono<String> responseMono = webClient.post() .uri(endpointPath) .contentType(MediaType.APPLICATION_JSON) .body(Mono.just(user), UserDto.class) .retrieve() .bodyToMono(RegisterResponse.class); responseMono.subscribe(response -> { // handle the response }, error -> { // handle the error }); }

Es importante tener en cuenta que el uso de clientes HTTP sincrónicos puede bloquear el subproceso actual, lo que puede tener un impacto negativo en el rendimiento general y la escalabilidad de su aplicación. Como tal, se recomienda usar clientes HTTP asincrónicos, como WebClient con programación reactiva, cuando sea posible para mejorar la capacidad de respuesta de la aplicación y la utilización de recursos.

Hay varias desventajas al usar RestTemplate y WebClient:

• necesita escribir mucha lógica repetitiva para manejar escenarios positivos y negativos
• necesitas configurar cada cliente manualmente
• los métodos para la solicitud regular GET/POST HTTP tienen una semántica compleja y debe recordarla

¿Cómo hacerlo más simple?

Respuesta corta: puede usar la biblioteca Fingir. ¿Qué es?

Feign es una biblioteca de Java que permite a los desarrolladores crear fácilmente clientes HTTP, diseñada específicamente para crear microservicios RESTful. Proporciona una forma declarativa de definir las API HTTP a las que se puede llamar desde su código como si fueran llamadas a métodos locales, lo que facilita el trabajo con las API y el consumo de recursos en diferentes microservicios.

Con Feign, puede crear fácilmente interfaces que definan los métodos HTTP, los parámetros de solicitud y los tipos de respuesta para sus puntos finales RESTful. Luego, Feign se encarga del resto, incluida la serialización y deserialización de solicitudes y respuestas, codificación de URL, manejo de errores y administración de conexiones.

Aquí hay un ejemplo de una solicitud POST para el registro de usuarios usando Fingir:

 // Client describes as interface with configuration: @FeignClient(name = "exampleRegisterClient") public interface RegisterClient { @PostMapping("/register") RegisterResponse registerUser(@RequestBody UserDto user); } // Bean creation in Spring configuration: @Bean public RegisterClient registerUserApi() { return Feign.builder().target(RegisterClient.class, "https://localhost:9090/api); }

Fingir proporciona una forma simple y declarativa de interactuar con las API HTTP, lo que permite a los desarrolladores centrarse en la lógica comercial de sus microservicios en lugar de los detalles de realizar solicitudes HTTP.

Conclusión.

En conclusión, Spring Boot brinda múltiples opciones para implementar clientes HTTP en microservicios, incluidos RestTemplate, WebClient y Feign. RestTemplate es un cliente simple y ampliamente utilizado que proporciona comunicación HTTP síncrona. WebClient es una alternativa más moderna y reactiva que proporciona comunicación HTTP sin bloqueo con una API de estilo funcional. Feign es un cliente declarativo y con seguridad de tipos que genera código basado en definiciones de API, lo que proporciona una interfaz fácil de usar para microservicios RESTful.

Al elegir qué cliente HTTP usar, es importante tener en cuenta los requisitos de su microservicio, como el rendimiento, la escalabilidad y la facilidad de uso. RestTemplate es una buena opción para casos de uso simples que requieren comunicación síncrona. WebClient es una buena opción para casos de uso reactivos y sin bloqueo que requieren alto rendimiento y escalabilidad. Fingir es una buena opción para casos de uso declarativos y con seguridad de tipos que requieren una API simplificada y una experiencia de desarrollador mejorada.

Independientemente del cliente HTTP que elija, es importante escribir pruebas de integración para garantizar que su microservicio se comporte correctamente al interactuar con servicios externos. Al probar sus clientes HTTP, puede asegurarse de que su microservicio se comporte como se espera en diferentes escenarios, como fallas en la red o respuestas inesperadas de servicios externos.

Puede encontrar mis ejemplos de implementación de diferentes formas de escribir clientes HTTP en mi GitHub: https://github.com/v-aksenov

Foto de ThisisEngineering RAEng en Unsplash