JDBI con Spring Boot

JDBI es una librería de código abierto para Java que actúa como una capa de abstracción sobre JDBC (Java Database Connectivity).

Permite interactuar con bases de datos relacionales de forma más rápida y limpia, reduciendo el código repetitivo (boilerplate) sin ocultar el lenguaje SQL.

Creando un proyecto Spring Boot con JDBI

Iremos al sitio para crear nuestro proyecto: https://start.spring.io/

Agregaremos las dependencias de MariaDB y Spring Jdbc.

Una vez creado el proyecto agregaremos una más, la dependencia de JDBI:

pom.xml

        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-core</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-sqlobject</artifactId>
            <version>3.2.5</version>
        </dependency>
        <dependency>
            <groupId>org.jdbi</groupId>
            <artifactId>jdbi3-spring5</artifactId> 
            <version>3.2.5</version>
        </dependency>

El diseño de nuestra aplicación será modular:

• repository: para el acceso a los datos de la BD. 
• model: para el mapeo objeto-relacional. 
• service: contiene la lógica de negocio. 
• controller: el punto de entrada de las peticiones HTTP.
• config: para las configuraciones.

Base de datos de la aplicación

Usaremos MariaDB como BD. El nombre de la BD sera ``soporte_tecnico``. Nuestra tabla es la siguiente:

CREATE OR REPLACE TABLE usuarios(
id int PRIMARY KEY, password varchar(255),
nombre varchar(255), apellidos varchar(255),
correo varchar(255), cvesis varchar(255)
);

Esta entidad relacional describe los atributos de un usuario.

Capa de mapeo objeto-relacional

Crearemos nuestra clase tipo que mapee los atributos de la tabla usuarios.

Usuario.java

package com.codemonkey.demo_jdbi.model;

import org.jdbi.v3.core.mapper.reflect.ColumnName;
import org.jdbi.v3.core.mapper.reflect.JdbiConstructor;

public class Usuario {
    @ColumnName("id") private Long id;
    @ColumnName("nombre") private String nombre;
    @ColumnName("apellidos")private String apellidos;
    @ColumnName("correo") private String correo;
    @ColumnName("cvesis")private String cvesis;


   public Usuario(
    @ColumnName("id") Long id,
    @ColumnName("nombre") String nombre,
    @ColumnName("apellidos") String apellidos,
    @ColumnName("correo") String correo,
    @ColumnName("cvesis") String cvesis) {
    this.id = id;
    this.nombre = nombre;
    this.apellidos = apellidos;
    this.correo = correo;
    this.cvesis = cvesis;
	}


    public Long getId() {
        return id;
    }

    public void setId(Long id) {
        this.id = id;
    }

    public String getNombre() {
        return nombre;
    }

    public void setNombre(String nombre) {
        this.nombre = nombre;
    }

    public String getApellidos() {
        return apellidos;
    }

    public void setApellidos(String apellidos) {
        this.apellidos = apellidos;
    }

    public String getCorreo() {
        return correo;
    }

    public void setCorreo(String correo) {
        this.correo = correo;
    }

    public String getCvesis() {
        return cvesis;
    }

    public void setCvesis(String cvesis) {
        this.cvesis = cvesis;
    }
}

No incluiremos el campo del password.

Capa de datos

Crearemos una interface para el repositorio de datos.

UsuarioRepository.java

package com.codemonkey.demo_jdbi.repository;

import com.codemonkey.demo_jdbi.model.Usuario;
import org.jdbi.v3.sqlobject.config.RegisterConstructorMapper;
import org.jdbi.v3.sqlobject.statement.SqlQuery;
import org.jdbi.v3.sqlobject.statement.SqlUpdate;
import java.util.List;

@RegisterConstructorMapper(Usuario.class) 
public interface UsuarioRepository {

    @SqlQuery("SELECT id, nombre, apellidos, correo, cvesis FROM usuarios")
    List<Usuario> listarUsuarios();

    @SqlUpdate("INSERT INTO usuarios(id, password, nombre, apellidos, correo, cvesis) VALUES (:id, :password, :nombre, :apellidos, :correo, :cvesis)")
    void insertar(Long id, String password,String nombre, String apellidos, String correo, String cvesis);
}

Esta interface tendrá dos métodos. Uno para consultar los datos con la instrucción SELECT y otro para insertar datos con INSERT.

Capa del servicio

Crearemos una clase tipo service para la lógica del negocio.

UsuarioService.java

package com.codemonkey.demo_jdbi.service;

import com.codemonkey.demo_jdbi.model.Usuario;
import com.codemonkey.demo_jdbi.repository.UsuarioRepository;
import org.jdbi.v3.core.Jdbi;
import org.springframework.stereotype.Service;

import java.util.List;

@Service
public class UsuarioService {

    private final UsuarioRepository usuarioRepository;

    public UsuarioService(Jdbi jdbi) {
        this.usuarioRepository = jdbi.onDemand(UsuarioRepository.class);
    }

    public List<Usuario> listarUsuarios() {
        return usuarioRepository.listarUsuarios();
    }

    public void insertarUsuario(Long id, String password, String nombre, String apellidos, String correo, String cvesis) {
        usuarioRepository.insertar(id, password, nombre, apellidos, correo, cvesis);
    }
}

Capa para el acceso a las peticiones HTTP

Crearemos una clase tipo controller.

UsuarioController.java

package com.codemonkey.demo_jdbi.controller;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.RestController;
import org.springframework.web.bind.annotation.RequestMapping;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.ResquestBody;
import java.util.logging.Logger;
import java.util.logging.Level;
import com.codemonkey.demo_jdbi.service.UsuarioService;
import com.codemonkey.demo_jdbi.model.Usuario;
import java.util.List;
import org.springframework.http.HttpStatus;
import org.springframework.http.ResponseEntity;


@RestController
@RequestMapping("/api/usuarios")
public class UsuarioController {

    private static final Logger LOGGER = Logger.getLogger(UsuarioController.class.getName());
	
	private UsuarioService usuarioService;

	@Autowired
    public UsuarioController(UsuarioService usuarioService) {
        this.usuarioService = usuarioService;
    }
	
    // http://localhost:8083/api/usuarios/hola
    @GetMapping("/hola")
    public String hola() {
        LOGGER.log(Level.INFO, "Entramos al primer servicio.");
        return "El servicio esta vivo.";
    }
	
	// http://localhost:8083/api/usuarios/all
	@GetMapping("/all")
	public ResponseEntity<List<Usuario>> getUsuarios() {
		LOGGER.info("\t ==== Obtenemos todos los usuarios. ====");
		List<Usuario> usuarios = usuarioService.listarUsuarios();
		
		if(usuarios.isEmpty()) {
			return ResponseEntity.noContent().build();
		}
		return ResponseEntity.ok(usuarios);
	}
	
	// http://localhost:8083/api/usuarios/insertar
    @PostMapping("/insertar")
    public ResponseEntity<String> insertarUsuario(@RequestBody Usuario usuario) {
    try {
        LOGGER.info("Insertando nuevo usuario: " + usuario.getNombre());
        usuarioService.insertarUsuario(
            usuario.getId(),
            "qwErt@3200$",
            usuario.getNombre(),
            usuario.getApellidos(),
            usuario.getCorreo(),
            usuario.getCvesis()
        );
        return ResponseEntity.status(HttpStatus.CREATED)
                             .body("Usuario insertado correctamente.");
    } catch (Exception e) {
        LOGGER.log(Level.SEVERE, "Error al insertar usuario", e);
        return ResponseEntity.status(HttpStatus.INTERNAL_SERVER_ERROR)
                             .body("Error al insertar usuario: " + e.getMessage());
    }
}


	
}

Esta clase expone tres apis:

• GET http://localhost:8083/api/usuarios/hola 
• GET http://localhost:8083/api/usuarios/all 
• POST http://localhost:8083/api/usuarios/insertar

La primera es para probar que la aplicación está activa. La segunda para consultar todos los datos de la tabla usuarios. La tercera para agregar un nuevo usuario.

Construimos la aplicación:

$ mvn clean install -X

Ejecutamos la aplicación:

$ mvn spring-boot:run

Hemos visto cómo crear una aplicación Spring Boot con Jdbi.

Enlaces:

https://jdbi.org/
https://codemonkeyjunior.blogspot.com/2016/02/jdbi-como-alternativa-jdbc.html
https://codemonkeyjunior.blogspot.com/2016/01/conociendo-jdbi.html
https://codemonkeyjunior.blogspot.com/2017/04/jdbi-con-groovy-2.html

¿Cómo funcionan los flujos en MuleSoft?

En la anterior entrega vimos que MuleSoft es una herramienta que nos permite conectar aplicaciones, datos y APIs de manera centralizada.

Ahora veremos cómo funciona los flujos de MuleSoft.

Flujo de una aplicación Spring Boot con Mulesoft

Digamos que se tiene una API con Spring Boot y se quiere integrar mediante MuleSoft.

┌─────────────────┐
│ Aplicación      │
│ Consumidora     │
│ (Web/Móvil/ERP) │
└────────┬────────┘
         │ HTTPS/REST
         ▼
┌─────────────────┐
│ MuleSoft API    │
│ Experience API  │
└────────┬────────┘
         │
         │ Validación
         │ Seguridad (OAuth/JWT)
         │ Rate Limit
         ▼
┌─────────────────┐
│ Mule Flow       │
│ Orquestación    │
└────────┬────────┘
         │
         ├─────────────┐
         │             │
         ▼             ▼
┌────────────┐   ┌─────────────┐
│ Transform  │   │ Enriquecer  │
│ DataWeave  │   │ Datos       │
└─────┬──────┘   └──────┬──────┘
      │                 │
      └────────┬────────┘
               ▼
     ┌─────────────────┐
     │ System API      │
     │ Spring Boot API │
     └───────┬─────────┘
             │ REST/JSON
             ▼
     ┌─────────────────┐
     │ Spring Boot     │
     │ Business Logic  │
     └───────┬─────────┘
             │
             ▼
     ┌─────────────────┐
     │ Base de Datos   │
     │ MySQL/Postgres  │
     └─────────────────┘
	 
	 

Esto nos muestra el flujo de la aplicación con Mulesoft.

Flujo detallado (Spring Boot)

Todo inicia desde la petición del cliente hasta obtener la respuesta.

Cliente
   │
   ▼
HTTP Listener
   │
   ▼
Validar JWT/OAuth
   │
   ▼
Logger Request
   │
   ▼
Transform Message
(DataWeave)
   │
   ▼
HTTP Request
(Spring Boot API)
   │
   ▼
Spring Boot
   │
   ├── Consulta DB
   ├── Procesa lógica
   └── Devuelve JSON
   │
   ▼
Transform Response
(DataWeave)
   │
   ▼
Logger Response
   │
   ▼
Retorna al Cliente

Teniendo una API Spring Boot:

GET /api/clientes/123

Respuesta:

{
  "id": 123,
  "nombre": "Thomas Muller",
  "email": "thomas.muller@empresa.com"
}

Exponiendo una API corporativa con MuleSoft:

GET /clientes/123

Respuesta:

{
  "id": 123,
  "nombre": "Thomas Muller",
  "email": "thomas.muller@empresa.com"
}

Arquitectura API-Led Connectivity

MuleSoft recomienda tres capas:

                 CLIENTES
                     │
                     ▼
        ┌─────────────────────────┐
        │ Experience API          │
        │ Web / Mobile / Partner  │
        └──────────┬──────────────┘
                   │
                   ▼
        ┌─────────────────────────┐
        │ Process API             │
        │ Orquestación negocio    │
        └──────────┬──────────────┘
                   │
         ┌─────────┴─────────┐
         ▼                   ▼
┌────────────────┐  ┌────────────────┐
│ System API     │  │ System API     │
│ Spring Boot    │  │ SAP / Oracle   │
└────────┬───────┘  └────────────────┘
         │
         ▼
   ┌──────────┐
   │ Database │
   └──────────┘

Responsabilidad de cada API

• Experience API: adapta la información para cada canal.
• Process API: aplica reglas de negocio y orquesta sistemas.
• System API: conecta directamente con Spring Boot, SAP, Salesforce, bases de datos, etc.

Ejemplo de Mule Flow XML

Observemos un ejemplo de flujos (flow):

<flow name="getCustomerFlow">

    <http:listener
        path="/clientes/{id}"
        config-ref="HTTP_Listener"/>

    <logger
        level="INFO"
        message="Consultando cliente"/>

    <http:request
        method="GET"
        url="http://springboot:8080/api/clientes/#[attributes.uriParams.id]" />

    <ee:transform>
        <ee:message>
            <ee:set-payload>
<![CDATA[
%dw 2.0
output application/json
---
{
  customerId: payload.id,
  fullName: payload.nombre,
  contact: {
      email: payload.email
  }
}
]]>
            </ee:set-payload>
        </ee:message>
    </ee:transform>

</flow>

A simple vista es algo complejo estar trabajando con flujos, pero una vez aue se entiende la lógica ya no es tan complicado. Como se dijo arriba, todo inicia desde la petición del cliente hasta obtener una respuesta. Esa respuesta puede ser válida o indicar un error si la aplicación no puede atender correctamente la petición.

Beneficios de usar MuleSoft delante de Spring Boot:

• Seguridad centralizada (OAuth, JWT, Client ID).
• Monitoreo en Anypoint Platform.
• Transformación de formatos con DataWeave.
• Orquestación entre múltiples APIs.
• Reutilización mediante API-Led Connectivity.
• Desacoplamiento entre consumidores y backend Spring Boot.

Proyecto en AnyPoint Studio MuleSoft

AnyPoint Studio MuleSoft es un entorno de desarrollo integrado (IDE) basado en Eclipse. Permite a los desarrolladores diseñar, construir y probar APIs e integraciones empresariales mediante una interfaz visual de arrastrar y soltar, simplificando la conexión entre diferentes aplicaciones y servicios.

Un proyecto luciría de esta forma:

MuleSoft es un mundo por aprender; nos permite conectar sistemas, diseñar, crear, probar y gestionar APIs empresariales; además de facilita la automatización de procesos, denominados flujos de trabajo; también permite visualizar toda la infomación involucrada.

Continuaremos con este tema en próximas entregas.

Enlaces:

https://www.mulesoft.com/
https://es.wikipedia.org/wiki/MuleSoft
https://www.seidor.com/es-mx/blog/salesforce-mulesoft-que-es
https://rootstack.com/es/blog/mulesoft-todo-lo-que-tienes-que-saber

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

Hablemos de Quarkus

Quarkus es un framework (creado por Red Hat) moderno de Java diseñado para optimizar aplicaciones en entornos de nube, contenedores y Kubernetes. Su principal ventaja es ofrecer tiempos de arranque ultrarrápidos y bajo consumo de memoria, lo que lo hace ideal para microservicios y arquitecturas serverless.

Diseñado para funcionar tanto en JVM tradicional como en compilaciones nativas con GraalVM. 

Compatible con librerías y estándares conocidos: Eclipse MicroProfile, Spring, RESTEasy (JAX-RS), Hibernate ORM (JPA), Apache Kafka, Infinispan, Camel, entre otros.

Su sistema de inyección de dependencias (CDI) y extensiones permite integrar fácilmente nuevas funcionalidades.

Lo podemos usar para:

• Microservicios en Kubernetes: optimiza despliegues en contenedores con tiempos de arranque mínimos. 
• Aplicaciones serverless: ideal para funciones que requieren ejecución rápida y eficiente. 
• Aplicaciones reactivas y REST: soporta APIs modernas y comunicación asíncrona. 
• Integración con bases de datos y mensajería: Hibernate, Kafka, PostgreSQL, entre otros. 
• Desarrollo ágil: incluye un modo de desarrollo con recarga en caliente para iterar rápidamente.

Principales características:

• Arranque ultrarrápido: aplicaciones listas en milisegundos. 
• Consumo reducido de memoria: optimizado para entornos con recursos limitados. 
• Compilación nativa con GraalVM: genera binarios ligeros y eficientes. 
• Extensible: gran ecosistema de extensiones para añadir soporte a tecnologías populares. 
• Developer Joy: herramientas integradas para mejorar la experiencia del desarrollador (live reload, CLI). 
• Integración con la nube: pensado para Kubernetes, OpenShift y servicios cloud.

Para usar Quarkus lo puedes instalar de las siguientes formas:

Desde una terminal Linux, Mac OS, Windows (con WSL o Cygwin/MinGW):

$ 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

Con SDKMAN!:

$ sdk install quarkus

Con Powershell:

$ 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"

Nota: También podemos crear un proyecto Quarkus usando Maven.

Verificamos la instalación:

$ quarkus --version

Emepzando con Quarkus

1. Vamos a abrir una terminal y tecleamos lo siguiente:

$ quarkus create && cd code-with-quarkus

Esto nos creará un proyecto y nos ubicará en el directorio principal.

2. Ejecutamos la aplicación:

$ quarkus dev

Si todo va bien, abrimos un navegador en la URL: http://localhost:8080/

Con esto hemos creado nuestra primera aplicación con Quarkus.

Este framework se podría considerar como el verdadero contendiente de Spring Boot dadas sus similitudes. Aunque existen otras alternativas como Helidon y Micronaut que no se quedan atrás.

En este blog ya hemos hablado de Quarkus indirectamente y vimos cómo es ideal para crear aplicaciones tipo REST.

En próximas entregas hablaremos un poco de Helidon y Micronaut.

Enlaces:

https://es.quarkus.io/
https://alquimistadecodigo.blogspot.com/2022/11/un-vistazo-quarkus-el-supersonic.html
https://code.quarkus.io/
https://alquimistadecodigo.blogspot.com/2023/01/quarkus-un-spring-boot-mejorado.html

Un vistazo a JakartaEE

Los que vienen programando en Java algún tiempo sabrán que trabajar con este lenguaje tiene sus pros y contras. No todo ha sido fácil, pero tampoco algo imposible.

Crear aplicaciones web con Servlets y JSP con sus configuraciones tediosas le complicaban la vida a más de uno. Ni se diga con los odiosos EJB y el uso de servidores como JBoss, Glassfish, etc.

Después vino Spring Framework con su Spring Boot que facilitó la vida a los desarrolladores web. Pues está herramienta se encargaba de lo complicado y dejaba al programador enfocarse en una sola cosa: su código.

Jakarta EE es la evolución directa de Java EE, el Java empresarial que muchos sufrían en antaño. La documentación oficial nos dice:

• Es conjunto de especificaciones que se utiliza para crear productos y frameworks Java para aplicaciones empresariales a gran escala. 
• Impulsa sistemas como bancos, sitios de comercio electrónico y plataformas empresariales. 
• Se basa en Java SE con API adicionales para desarrollo web, acceso a bases de datos, mensajería y seguridad.

Características principales:

• Tecnologías web: Servlets, JSP, JSF.
• Lógica de negocio: EJB (Enterprise JavaBeans).
• Persistencia de datos: JPA Mensajería: JMS Seguridad y transacciones.

Jakarta EE se ejecuta en servidores de aplicaciones como WildFly, GlassFish y Payara, que gestionan la configuración, la escalabilidad y el ciclo de vida.

Jakarta EE Get Started

Para los que vienen de Spring Boot este sitio se les hará familiar:

https://start.jakarta.ee/

Pues es similar al sitio https://start.spring.io/, el cual nos ayuda a crear un proyecto listo para usar y que nos evita las odiosas y tediosas configuraciones.

La documentación oficial nos dice:

"Jakarta EE Get Started crea rápidamente una aplicación Jakarta EE lista para usar, eliminando las complicaciones habituales de configuración. En lugar de empezar con una carpeta vacía, obtienes un proyecto completo y funcional, listo para construir, como si empezaras con un set de LEGO preconstruido que puedes personalizar al instante. Incluye la configuración correcta de Maven, estructuras de directorios estándar y código de ejemplo que demuestra los conceptos clave de Jakarta EE".

En pocas palabras, Jakarta EE aprendió lo que no hizo Java EE.

Al entrar al sitio podemos ver un formulario similar al de Spring Boot Initializer:

Comencemos con un proyecto sencillo.

Descargamos el archivo ZIP y lo descomprimimos en algún directorio:

$ cd jakartaee-hello-world

Veamos el contenido del proyecto:

src\main\java\org\eclipse\jakarta\hello\Hello.java
src\main\java\org\eclipse\jakarta\hello\HelloApplication.java
src\main\java\org\eclipse\jakarta\hello\HelloWorldResource.java

Hello.java

package org.eclipse.jakarta.hello;

public class Hello {

    private String name;

    public Hello(String name) {
        this.name = name;
    }

    public String getHello(){
        return name;
    }
}

La cual es una clase o un bean.

HelloApplication.java

package org.eclipse.jakarta.hello;

import jakarta.ws.rs.core.Application;
import jakarta.ws.rs.ApplicationPath;

@ApplicationPath("rest")
public class HelloApplication extends Application {
    
}

Similar a la aplicación tipo Spring Boot.

HelloWorldResource.java

package org.eclipse.jakarta.hello;

import jakarta.ws.rs.GET;
import jakarta.ws.rs.Path;
import jakarta.ws.rs.Produces;
import jakarta.ws.rs.QueryParam;
import jakarta.ws.rs.core.MediaType;

@Path("hello")
public class HelloWorldResource {

    @GET
    @Produces({ MediaType.APPLICATION_JSON })
    public Hello hello(@QueryParam("name") String name) {
        if ((name == null) || name.trim().isEmpty()) {
            name = "world";
        }

        return new Hello(name);
    }
}

La cual es una clase similar a un Controller en Spring Boot.

En teoría, es una aplicación funcional. Comprobemos esto.

Compilamos el proyecto:

$ mvn clean install

Si todo va bien, nuestra aplicación estará compilada y se habrá creado el WAR en la carpeta generada llamada target.

Ahora será necesario descargar e instalar Glassfish:

https://glassfish.org/download

Una vez descargado y descomprimido en algún directorio en específico, debemos crear la variable de entorno para poder ejecutarlo:

C:\glassfish7\bin

Ahora iniciaremos el servidor Glassfish:

$ asadmin start-domain

Abriremos el navegador en la ruta: http://localhost:4848

Entraremos al administrador de Glassfish. Vamos a Application/Deploy. Seleccionamos nuestro WAR y damos ok. Ya podemos ejecutar la aplicación.

Abrimos el navegador en la ruta: http://localhost:8080/jakartaee-hello-world/rest/hello?name=Thomas_Muller

Salida:

¡Hemos creado nuestra primera aplicación con Jakarta EE!

Detenemos el servidor Glassfish:

$ asadmin stop-domain

Actualización:

Si no quieres instalar Glassfish, puedes ejecutar este comando:

$ mvnw clean package wildfly:run

Deberás descargar la última versión de Wildfly:

https://www.wildfly.org/downloads/

Descomprimir el ZIP y colocarlo en algún directorio (C:\wildfly).

Además de editar el pom.xml

<?xml version="1.0" encoding="UTF-8"?>
<project xmlns="http://maven.apache.org/POM/4.0.0"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 
                             http://maven.apache.org/xsd/maven-4.0.0.xsd">
    <modelVersion>4.0.0</modelVersion>

    <groupId>org.eclipse</groupId>
    <artifactId>jakartaee-hello-world</artifactId>
    <version>0.1-SNAPSHOT</version>
    <packaging>war</packaging>

    <name>jakartaee-hello-world</name>
    <description>
        Simple Jakarta EE 11 application running on WildFly.
    </description>

    <properties>
        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
        <project.report.sourceEncoding>UTF-8</project.report.sourceEncoding>
        <maven.compiler.release>21</maven.compiler.release>
        <jakartaee-api.version>11.0.0-RC1</jakartaee-api.version>
        <compiler-plugin.version>3.13.0</compiler-plugin.version>
        <war-plugin.version>3.4.0</war-plugin.version>
    </properties>

    <dependencies>
        <dependency>
            <groupId>jakarta.platform</groupId>
            <artifactId>jakarta.jakartaee-core-api</artifactId>
            <version>${jakartaee-api.version}</version>
            <scope>provided</scope>
        </dependency>
    </dependencies>

    <build>
        <finalName>jakartaee-hello-world</finalName>
        <plugins>
            
            <plugin>
                <groupId>org.wildfly.plugins</groupId>
                <artifactId>wildfly-maven-plugin</artifactId>
                <version>4.2.0.Final</version>
                <configuration>
                    <jbossHome>C:\wildfly</jbossHome>
                    <startupTimeout>180</startupTimeout>
                </configuration>
            </plugin>

            
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-compiler-plugin</artifactId>
                <version>${compiler-plugin.version}</version>
            </plugin>

           
            <plugin>
                <groupId>org.apache.maven.plugins</groupId>
                <artifactId>maven-war-plugin</artifactId>
                <version>${war-plugin.version}</version>
                <configuration>
                    <failOnMissingWebXml>false</failOnMissingWebXml>
                </configuration>
            </plugin>
        </plugins>
    </build>
</project> 

Ya podrás desplegarlo sin la necesidad de iniciar Glassfish.

Feliz año 2026

Este es el post número 400 del blog.😉

Enlaces:

https://jakarta.ee/
https://www.linkedin.com/pulse/java-explained-servlets-jsp-jakarta-ee-rohit-bhosale-r2gzf/?trackingId=XgJjdE8PQombg7SZoMmx9Q%3D%3D
https://jakarta.ee/learn/starter-guides/a-comprehensive-beginners-guide-to-the-get-started/