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/
