🚀 Quarkus: El Framework en la Sombra. 🚀

Recientemente, hemos estado inmerso en un viaje de exploración y tendencias tecnológica donde he descubierto algo que ya existía, pero no conocía realmente su potencial.

Este maravillo framework es: Quarkus, sobre el cual he podido profundizar en las capacidades que ofrece y quiero compartir contenido que os sea de utilidad.

Entendiendo Quarkus

Quarkus es mucho más que un simple framework de desarrollo. Es una revolución en sí misma, diseñada para impulsar el desarrollo de aplicaciones nativas en la nube y microservicios. Lo que realmente destaca de Quarkus es su capacidad para combinar eficiencia y rendimiento sin sacrificar la productividad del desarrollador, es decir, no necesitas tener conocimientos profundos sobre este framework para poder empezar a trabajar con él, y más, si ya vienes por ejemplo del mundo spring.

Beneficios de Adoptar Quarkus

• Ultraeficiente y Liviano: Quarkus está diseñado desde cero para ser increíblemente eficiente, lo que lo convierte en la opción ideal para entornos de contenedores y microservicios.
• Incrementa la Productividad: Gracias a características como el modo de desarrollo interactivo y las pruebas continuas, Quarkus facilita y agiliza el proceso de desarrollo.
• Compatibilidad Total: Quarkus se integra sin problemas con estándares de la industria como MicroProfile y Jakarta EE, lo que garantiza una transición suave para los desarrolladores y una amplia gama de herramientas disponibles.
• Gran Comunidad de Soporte: Con una comunidad activa y colaborativa, Quarkus ofrece un entorno de desarrollo sólido y orientado a la comunidad.

Profundizando en Quarkus: Ejemplos Prácticos

Persistencia con Panache y Active Record

Quarkus hace que la persistencia de datos sea una tarea sencilla y eficiente. Con la ayuda de Panache y Active Record, podemos gestionar fácilmente las entidades de nuestra aplicación.

Definición de la Entidad Fruta

@Entity
public class Fruit extends PanacheEntity {
    public String name;
    public Integer kcal;
    public String season;

    public static Fruit find(String name) {
        return find("name", name).firstResult();
    }

    public static List<Fruit> findSeason(String season) {
        return list("season", season);
    }

    public static void deleteByName(String name) {
        delete("name", name);
    }
}

@Entity
public class Fruit extends PanacheEntity {
    public String name;
    public Integer kcal;
    public String season;

    public static Fruit find(String name) {
        return find("name", name).firstResult();
    }

    public static List<Fruit> findSeason(String season) {
        return list("season", season);
    }

    public static void deleteByName(String name) {
        delete("name", name);
    }
}

Desarrollo Reactivo con SmallRye Mutiny

Ofrece soporte para el desarrollo reactivo, lo que nos permite construir aplicaciones altamente eficientes y escalables.

Implementación Reactiva del Recurso de Fruits

import io.smallrye.mutiny.Uni;

@Path("/fruits")
public class ReactiveFruitResource {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public Uni<List<Fruit>> getAllFruits() {
        return Fruit.findAll().list();
    }
}

Integración de Servicios Externos con RestClient

Simplifica la integración de servicios externos mediante el uso de RestClient.

Definición del Cliente de Servicio de Recibos

import javax.ws.rs.*;
import javax.ws.rs.core.MediaType;
import java.util.List;

@Path("/receipts")
@RegisterRestClient
public interface ReceiptsService {

    @GET
    Receipt getById(@QueryParam("id") Integer id);

    @GET
    @Path("/ingredient/{name}")
    @Produces(MediaType.APPLICATION_JSON)
    List<Response> getByIngredient(@PathParam("name") String name);
}

Gestión de Eventos con CloudEvents

Facilita la gestión de eventos mediante la integración de CloudEvents.

Recepción de CloudEvents

@Path("/fruit")
public class FruitEventReceiver {

    @Inject
    FruitService fruitService;

    @POST
    public void handleFruitEvent(final CloudEvent event) {
        FruitEvent fruitEvent = map(event);
        fruitService.process(fruitEvent);
    }
}

Envío de CloudEvents

public class EventPublisher {

    @Inject
    CloudEventSender eventSender;

    public void sendFruitEvent(final FruitEvent event) {
        CloudEvent cloudEvent = CloudEventBuilder.v1()
            .withSource(URI.create("/fruit"))
            .withType("com.example.fruit")
            .withId(UUID.randomUUID().toString())
            .withDataContentType(MediaType.APPLICATION_JSON)
            .withData(PojoCloudEventData.wrap(event, mapper::writeValueAsBytes))
            .build();
        eventSender.send(cloudEvent);
    }
}

Resiliencia con Fault Tolerance

En un entorno de microservicios, la resiliencia es fundamental. Quarkus ofrece una integración perfecta con SmallRye Fault Tolerance para mejorar la tolerancia a fallos de nuestras aplicaciones. Veamos cómo podemos implementar estrategias de resiliencia en nuestro servicio de frutas:

Implementación de Retries y Fallbacks

@Path("/fruits")
public class FruitResource {

    @POST
    @Retry(maxRetries=3, delay=1000, maxDuration=5000)
    @Fallback(fallbackMethod="handleFallback")
    public void add(final FruitEvent event) {
        Fruit stored = Fruit.findByName(event.getName());
        if (stored == null) {
            map.toEntity(event).persist();
        }
    }

    public void handleFallback(final FruitEvent event) {
        // Manejo de fallback
    }
}

Monitorización con Microprofile Metrics

Quarkus proporciona integración con Microprofile Metrics para facilitar la monitorización de nuestras aplicaciones.

Anotaciones de Métricas

@Path("/fruit")
public class FruitResource {

    @POST
    @Counted(name = "ProcessedFruitsCount", displayName = "Processed fruits")
    @Timed(name = "ProcessingTime", displayName = "Fruit processing time")
    public void processFruit(final FruitEvent event) {
        FruitEvent fruitEvent = map(event);
        fruitService.process(fruitEvent);
    }
}

Conclusiones

En este recorrido por las características de Quarkus, hemos explorado diferentes aspectos, desde la creación de servicios REST hasta la gestión de eventos y la monitorización de nuestras aplicaciones. Quarkus ofrece una plataforma robusta y eficiente para el desarrollo de microservicios en Java, lo que lo convierte en una opción atractiva para proyectos modernos y escalables.

¿Qué hemos aprendido?

• Quarkus es una plataforma diseñada específicamente para aplicaciones nativas de la nube y microservicios.
• Ofrece integración con tecnologías como Panache, SmallRye Mutiny, RestClient y Microprofile Metrics.
• Facilita la implementación de estrategias de resiliencia y la gestión de eventos mediante CloudEvents.

¿Por qué no lo usan en TODAS las empresas?

• Falta de Conocimiento: Muchas empresas desconocen Quarkus o no comprenden sus capacidades.
• Percepciones Erróneas: Algunos piensan que Quarkus tiene limitaciones o que requiere una curva de aprendizaje significativa.
• Madurez de la Tecnología: Existe preocupación sobre la estabilidad y confiabilidad de Quarkus en entornos empresariales críticos.
• Educación y Concientización: Es clave educar a las empresas sobre las capacidades reales de Quarkus y sus beneficios.
• Adopción Progresiva: Las empresas están optando por una adopción gradual, comenzando con proyectos piloto.
• Comunidad y Soporte: La sólida comunidad y el respaldo de Red Hat brindan confianza y recursos a las empresas.

Si estás interesado en este desconocido framework, espero que este post te haya aportado información como para seguir investigando sobre su maravillo potencial.