Hablemos de Micronaut y Helidon

En la entrega anterior hablamos de Quarkus (Supersonic Subatomic Java), el cual es un framework cuya filosofía es trabajar en Cloud y forma de trabajo nos recuerda a Spring Boot (sin decir que los "copia").

Ahora hablaremos de Micronaut y Helidon.

Micronaut es un framework moderno, basado en JVM y de pila completa para la creación de aplicaciones modulares, de microservicios y sin servidor, fácilmente comprobables.

Para instalarlo hay varias formas: https://micronaut.io/download/

Helidon es una colección de bibliotecas Java para escribir microservicios que se ejecutan en un núcleo web rápido impulsado por Netty. Es pequeño, rápido y divertido de usar.

Tiene dos versiones:

• Helidon SE. 
• Helidon MP.

Existen varias formas de instalarlo, pero se recomienda instalar la herramienta CLI: https://helidon.io/docs/v4/about/cli

Ambos frameworks comparten similitudes y diferencias entre otras herramientas como Quarkus/RESTEasy y Spring Boot.

Observemos la siguiente tabla comparativa:

Característica	Helidon	Micronaut
Origen	Desarrollado por Oracle	Desarrollado por Object Computing, Inc. (OCI)
Arquitectura	Dos sabores: Helidon SE (funcional, ligero) y Helidon MP (basado en MicroProfile)	Diseñado desde cero para microservicios, con fuerte soporte a inyección de dependencias y AOP
Modelo de programación	Funcional (SE) y MicroProfile (MP)	Basado en anotaciones, DI y configuración simplificada
Soporte Cloud-Native	Kubernetes-native, integración con GraalVM	Optimizado para GraalVM y entornos serverless
Tiempo de arranque	Muy rápido, especialmente con Helidon SE	Extremadamente rápido, diseñado para aplicaciones serverless
Consumo de memoria	Bajo, ideal para microservicios en contenedores	Bajo, con optimizaciones para entornos de alta densidad
Compatibilidad	Java EE, MicroProfile, integración con APIs estándar	Compatibilidad con Spring, soporte para múltiples lenguajes JVM
Ventajas principales	- Simplicidad con Helidon SE - Estándares MicroProfile - Integración nativa con Oracle Cloud	- Arranque ultrarrápido - Bajo consumo de memoria - Ecosistema activo y flexible
Similitudes	- Ambos soportan GraalVM - Orientados a microservicios cloud-native - Bajo consumo de recursos - Integración con Kubernetes y contenedores

Empezando con Micronaut

Con Chocolatey:

$ choco install micronaut

Con SDKMAN!:

$ sdk update
$ sdk install micronaut

Verificamos la instalación:

$ mn

Empezando con Helidon

Con Powershell:

$ PowerShell -Command Invoke-WebRequest -Uri "https://helidon.io/cli/latest/windows/helidon.exe" -OutFile "C:\Windows\system32\helidon.exe"

Con Linux bash:

$ curl -L -O https://helidon.io/cli/latest/linux/helidon
$ chmod +x ./helidon
$ sudo mv ./helidon /usr/local/bin/

Verificamos:

$ helidon version

Hemos instalado tanto Helidon como Micronaut.

Hola, mundo con Micronaut

1. Iniciamos un proyecto:

$ mn create-app hello-world

Nos ubicamos en el directorio creado.

2. Modificamos la clase ``HolaController.java``:

package com.inforhomex.app.controller;

import com.inforhomex.app.resource.HolaResource;
import io.micronaut.http.annotation.Controller;
import io.micronaut.http.annotation.Get;
import io.micronaut.http.MediaType;

/**
 * Clase controller de la aplicación.
 */
@Controller("/hola")
public class HolaController implements HolaResource{
	
    @Override
	@Get(produces = MediaType.TEXT_PLAIN)
    public String getSaludo(){
        return "¡Hola, mundo en Micronaut!";
    }
}

3. Construimos:

$ mvn clean install

4. Ejecutamos:

$ ./mvnw mn:run

Abrimos el navegador en la ruta: http://localhost:8080/hola

Salida:

¡Hola, mundo en Micronaut!

Hola, mundo con Helidon

1. Iniciamos un proyecto:

$ helidon init
$ cd holamundo-se

2. Modificamos la clase ``Main.java``, específicamente en este método:

 static void routing(HttpRouting.Builder routing) {
        routing
               .register("/greet", new GreetService())
               .get("/simple-greet", (req, res) -> res.send("Hola, mundo!")); 
    }

3. Construimos:

$ mvn clean package

4. Ejecutamos:

Abrimos el navegador en la ruta: http://localhost:8080/simple-greet

Salida:

Hola, mundo!

Continuaremos con este tema en próximas entregas.

Enlaces:

https://alquimistadecodigo.blogspot.com/2023/03/micronaut.html
https://alquimistadecodigo.blogspot.com/2025/04/helidon-instalando-el-cli.html

RESTEasy: un REST de manera fácil

RESTEasy es, en pocas palabras, una implementación de JAX-RS; un framework para crear servicios web RESTful.

Permite crear servicios REST usando anotaciones como @Path, @GET, @POST, etc., sobre clases e interfaces Java. También permite crear clientes RESTful, pues provee frameworks para realizar esa tarea.

Ayuda al desarrolllador web a crear APIs que se comunican a través de HTTP, facilitando la creación de microservicios y servicios web ligeros en el ecosistema Java.

Se puede integrar con Quarkus y Wildfly.

Para mayor información puedes consultar este sitio: https://docs.resteasy.dev/7.0/userguide/

Empezando con RESTEasy

Existen dos formas recomendadas:

• La manera clásica: con Jakarta EE 10 y Wildfly. 
• La moderna y recomendada: con Quarkus y RESTEasy Reactive.

Nosotros elegiremos Quarkus con RESTEasy Reactive (Quarkus REST) para crear un sencillo servicio.

Tenemos dos opciones para crear el proyecto.

Con Quarkus CLI:

$ quarkus create app mx.inforhomex:hola-quarkus-rest --extension=rest

Si no contamos con la herramienta, la podemos instalar con estos comandos:

Linux:

$ curl -Ls https://sh.jbang.dev | bash -s - trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/
$ curl -Ls https://sh.jbang.dev | bash -s - app install --fresh --force quarkus@quarkusio

Usando SDKMAN!:

$ sdk install quarkus

Windows:

$ iex "& { $(iwr https://ps.jbang.dev) } trust add https://repo1.maven.org/maven2/io/quarkus/quarkus-cli/"
$ iex "& { $(iwr https://ps.jbang.dev) } app install --fresh --force quarkus@quarkusio"

La otra alternativa para crear el proyecto es con Maven:

$ mvn io.quarkus.platform:quarkus-maven-plugin:3.15.1:create -DprojectGroupId=mx.inforhomex -DprojectArtifactId=hola-quarkus-rest -Dextensions=rest

Una vez creado el proyecto nos ubicaremos en el directorio principal.

$ cd hola-quarkus-rest

Abrimos y editamos la clase ``GreetingResource.java`` para que luzca de esta forma:

package mx.inforhomex;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.core.MediaType;
import java.util.HashMap;

@Path("/saludar")
public class GreetingResource {

    @GET
    @Produces(MediaType.APPLICATION_JSON)
    public HashMap<String, Object> saludar() {
        HashMap<String, Object> map = new HashMap<String, Object>();
        map.put("message","Hola, mundo desde Quarkus REST");
        map.put("active",true);
        map.put("id",1202029L);
        return map;
    }
}

Ejecutamos con Quarkus:

$ quarkus dev

O con Maven:

$ ./mvnw quarkus:dev

Abrimos el navegador en la ruta: http://localhost:8080/saludar

Si todo va bien, veremos esta salida:

{active=true, id=1202029, message=Hola, mundo desde Quarkus REST}

¡Hemos creado nuestro primer proyecto con RESTEasy y Quarkus!

En próximas entregas hablaremos de Quarkus, un fuerte contendiente de Spring Boot.

Enlaces:

https://resteasy.dev/
https://docs.resteasy.dev
https://codemonkeyjunior.blogspot.com/2026/01/un-vistazo-jakartaee.html
https://es.quarkus.io/