Ticker

6/recent/ticker-posts

Creando una API RESTful con Spring WebFlux en base a conceptos de la Programación Reactiva

Hadsonpar febrero 03, 2023


En este tutorial práctico desarrollaremos una API RESTful con Spring WebFlux en base a conceptos de la Programación Reactiva. Recordenos que Spring introdujo el componente en base a un modelo de Multi-Event Loop (bucle de eventos múltiples) para habilitar una solución en base eventos reactivas conocida como WebFlux. Es un framework  web totalmente libre de bloqueo y basado en anotaciones creado en Project Reactor que permite crear aplicaciones web reactivas en la capa HTTP, incorporados servidores populares como contenedores Netty , Undertow y Servlet 3.1.


Requisitos:

  1. Spring Initializr.
  2. Java 17.
  3. Maven 3.8.6.
  4. IntelliJ IDEA Ultimate.
  5. Dependencia Spring Reactive Web


Lo que veremos en este tutorial:

  1. ¿Qué es API RESTful?.
  2. Crear el proyecto desde Spring Initializr.
  3. Crear el paquete restfullwebflux.
  4. Crear el controller entidad Webflux.
  5. Crear el controller Reactive Webflux
  6. Crear la clase Router.
  7. Crear el método MONO en base a WebClient.
  8. Crear el método MAIN de nuestro proyecto.
  9. Ejecutar nuestra API RESTful.
  10. Conclusiones y Referencias.


1. ¿Qué es API RESTful?.

La API RESTful es una interfaz donde dos aplicaciones o sistemas intercambian información de manera segura a través de Internet. La mayoría de las aplicaciones empresariales deben comunicarse con otras aplicaciones internas o de terceros para llevar a cabo varias tareas como parte del proceso que amerita el negocio. 

Por ejemplo, para generar nóminas mensuales, su sistema interno de cuentas debe compartir datos con el sistema bancario de su cliente para automatizar la facturación y comunicarse con una aplicación interna de planillas de horarios (fuente: Pagina oficial de AWS). 

Las API RESTful admiten intercambio de información siguen estándares de comunicación de software seguros, confiables y eficientes.


2. Crear el proyecto desde Spring Initializr.

El nombre del poryecto llevara el nombre de restful-spring-webflux y se tiene que agregar la dependencia Spring Reactive Web. Puedes revisar el tutorial acerca de Creando proyectos con Spring Initializr.

Agregar la dependencia Spring Reactive Web


3. Crear el paquete restfullwebflux.

Después de haber descargado y descomprimido el proyecto que fue generado desde Spring Initializr, agregar el paquete restfullwebflux.

Clic derecho en el directorio Java seguidamente seleccionar New/Package 


4. Crear el controller entidad Webflux.

4.1. Crear Controller Entidad WebFlux (nombre: ReactiveWebflux) para retornar el mensaje a procesar. POJO que retorna el servicio RESTful en serialización JSON.

4.2. Codigo a elaborar en nuestro controller ReactiveWebflux:

package restfullwebflux;

/**
 * Controller Entidad WebFlux para retornar el mensaje a procesar.
 * POJO que retorna el servicio RESTful en serialización JSON.
 */
public class ReactiveWebflux {
    private String message;

    public ReactiveWebflux() {
    }

    public ReactiveWebflux(String message) {
        this.message = message;
    }

    public String getMessage() {
        return this.message;
    }

    public void setMessage(String message) {
        this.message = message;
    }

    @Override
    public String toString() {
        return "ReactiveWebflux{" +
                "message='" + message + '\'' +
                '}';
    }
}

5. Crear el controller Reactive Webflux.

5.1. Crear Controller Reactive (WebFlux de nombre ReactiveWebfluxHandler) para controlar todas las solicitudes (peticiones), es el encargado de retornar una respuesta según las peticiones..


5.2. Codigo a elaborar en nuestro controller ReactiveWebfluxHandler:

package restfullwebflux;

import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.BodyInserters;
import org.springframework.web.reactive.function.server.ServerRequest;
import org.springframework.web.reactive.function.server.ServerResponse;
import reactor.core.publisher.Mono;

/**
 * Controller Reactive (WebFlux) para controlar todas las
 * solicitudes (peticiones), es el encargado de retornar una
 * respuesta según las peticiones.
 *
 * CONSIDERACIÓN REACTIVE:
 * Importar la librería MONO: Un objeto MONO es el encargado de de
 * reportar el cuerpo de un servicio REACTIVE, es decir retorar el
 * ServerResponse
 */
@Component
public class ReactiveWebfluxHandler {
    public Mono<ServerResponse> mensaje(ServerRequest request){
        return ServerResponse.ok().contentType(MediaType.APPLICATION_JSON)
                .body(BodyInserters.fromValue(new ReactiveWebflux("Hola Spring Webflux - Programación Reactiva!")));
    }
}

6. Crear la clase Router.

6.1. Crear el Router (nombre ReactiveWebfluxRouter) para escuchar el tráfico generado en la ruta /mensaje, valor proporcionado por nuestra clase de Controller Reactive (WebFlux).

6.2. Codigo a elaborar en nuestro clase Router ReactiveWebfluxRouter:

package restfullwebflux;
/**
 * Router para escuchar el tráfico generado en la ruta /mensaje, valor
 * proporcionado por nuestra clase de Controller Reactive (WebFlux).
 *
 * CONSIDERACIÓN:
 * Import static manualmente los Requests Predicates GET y accept
 */

import org.springframework.context.annotation.Bean;
import org.springframework.context.annotation.Configuration;
import org.springframework.http.MediaType;
import org.springframework.web.reactive.function.server.RouterFunction;
import org.springframework.web.reactive.function.server.RouterFunctions;
import org.springframework.web.reactive.function.server.ServerResponse;

import static org.springframework.web.reactive.function.server.RequestPredicates.GET;
import static org.springframework.web.reactive.function.server.RequestPredicates.accept;

@Configuration(proxyBeanMethods = false)
public class ReactiveWebfluxRouter {
    @Bean
    public RouterFunction<ServerResponse> routerFunction(ReactiveWebfluxHandler reactiveWebfluxHandler){
        return RouterFunctions.route(GET("/mensaje").and(accept(MediaType.APPLICATION_JSON)), reactiveWebfluxHandler::mensaje);
    }
}

7. Crear el método MONO en base a WebClient.

7.1. Para la parte cliente haremos uso de WebClient.Builder, Spring Boot configura automáticamente la instancia WebClient.Builder con valores predeterminados y personalizaciones. Crear un “WebClient” (nombre: ReactiveWebfluxClient) dedicado para nuestro proyecto.

7.2. Codigo a elaborar en base a WebClient ReactiveWebfluxClient:

package restfullwebflux;
/**
 * Implementamos una clase basada en WebClient para consumir nuestro
 * servicio RESTful
 *
 * CONSIDERACIÓN:
 * Importar WebClient, que es la clase para realizar funciones reactivas  en
 * forma de MONO, con la finalidad de procesar el contenido del mensaje, en
 * nuestro caso será devuelto por el metodo getMessage en base a funciones MONO
 */

import org.springframework.http.MediaType;
import org.springframework.stereotype.Component;
import org.springframework.web.reactive.function.client.WebClient;
import reactor.core.publisher.Mono;

@Component
public class ReactiveWebfluxClient {
    //declarar WebCleint
    private final WebClient webClient;
    /**
     * Spring Boot configura automáticamente la instancia WebClient.Builder
     * con valores predeterminados y personalizaciones.
     * Podemos usarlo para crear un `WebClient` dedicado para nuestro proyecto.
     */
    public ReactiveWebfluxClient(WebClient.Builder builder){
        this.webClient = builder.baseUrl("http://localhost:8080").build();
    }

    //Crear nuestro método MONO para capturar las petición en formato JSON
    public Mono<String> getMessage(){
     return this.webClient.get().uri("/mensaje").accept(MediaType.APPLICATION_JSON).retrieve().bodyToMono(ReactiveWebflux.class).map(ReactiveWebflux::getMessage);
    }
}

8. Crear el método MAIN de nuestro proyecto.

8.1. Crear una clase de nombre Application para crear nuestro método main para invocar a nuestro método MONO getMessage con el fin de poder ejecutar nuestra API RESTful.

8.2. Codigo a elaborar en nuestra clase Application para implementar el método MAIN:

package restfullwebflux;
/**
 * Crearemos nuestro propio método main para invocar a nuestro
 * método MONO getMessage
 */

import org.springframework.boot.SpringApplication;
import org.springframework.boot.autoconfigure.SpringBootApplication;
import org.springframework.context.ConfigurableApplicationContext;
@SpringBootApplication
public class Application {
    public static void main(String[] args) {
        ConfigurableApplicationContext context = SpringApplication.run(Application.class, args);
        ReactiveWebfluxClient reactiveWebfluxClient = context.getBean(ReactiveWebfluxClient.class);
        // Capturamos el mensaje procesado
        System.out.println(">> mensaje = " + reactiveWebfluxClient.getMessage().block());
    }
}

9. Ejecutar nuestra API RESTful.
9.1. Ejecutar la aplicación desde el Rub Application de nuestro proyecto.

Clic en Run Application


9.2. Verificar el mensaje procesado desde la consola de IntelliJ IDEA.

mensaje = Hola Spring WebFlux - Programación Reactiva



9.3. Verificar el  mensaje en formato REST desde un cliente browser - Google Chrome. Ingresar a través de la ruta http://localhost:8080/mensaje

Formato JSON: mensaje = Hola Spring WebFlux - Programación Reactiva



10. Conclusiones y Referencias.

Conclusiones:

  1. Creamos un proyecto desde Spring Initializr en base a la dependencia de Spring Reactive Web.
  2. Desarrollamos nuesto primer poryecto Reactiva que incluye un WebClient para consumir la API RESTful.
  3. Ejecutamos y validamos nuestra API RESTful desarrollado con Spring WebFlux en base a conceptos de la Programación Reactiva.

Referencias:


Código configurado con SonarQube y Spring Boot disponible en GitHub
Directorio restful-spring-webflux

Gracias nuevamente 😊 comentarios y apreciaciones son bienvenido, un fuerte abrazo para todos ✌...!!!

Hadsonpar

Publicadas por Hadsonpar

Apasionado por las nuevas tecnologías, la investigación, los patrones de diseño y las buenas prácticas; con experiencia y participación en diversos proyectos de banca y seguros desde la etapa de análisis, diseño, desarrollo, implementación, testing y certificación.

Publicar un comentario

0 Comentarios