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/

Stored procedures Oracle PL/SQL / GCP BigQuery

Haciendo un poco de memoria, recordaremos lo que es un Stored Procedure.

Un Stored Procedure (procedimiento almacenado) es:

• Un subprograma que ejecuta una acción específica.
• No devuelve valor alguno (pero mediante un mecanismo podemos recuperar valores).
• Posee un nombre y puede o no tener parámetros y un bloque donde se efectuarán las acciones a realizar.
• Se puede llamar desde otros Stored Procedures y/o consultas SQL.

Si usamos Oracle, está será será su sintaxis:

CREATE {OR REPLACE} PROCEDURE nombre_proc( param1 [IN | OUT | IN OUT] tipo,... )
IS
  -- Declaración de variables locales
  BEGIN
  -- Instrucciones de ejecución
  [EXCEPTION]
  -- Instrucciones de excepción
END;

En BigQuery, sería de esta forma:

CREATE PROCEDURE dataset_name.procedure_name(OUT param1 TYPE, ...)
BEGIN
-- statements here
  [EXCEPTION]
  -- statements here
END

La forma de invocar un Stored Procedure en Oracle:

CALL miprocedimiento();

En BigQuery:

CALL mydataset.miprocedimiento();

Lenguaje procedimental

Tanto GCP BigQuery como Oracle PL/SQL poseen sus propias peculiaridades. Empecemos con los bloques.

En PL/SQL:

DECLARE
BEGIN
   dbms_output.put_line('Hola, mundo');
END;
/

En BigQuery:

BEGIN
   SELECT FORMAT('Hola, mundo');
END;

También podemos hacer esto:

DECLARE saludo STRING DEFAULT 'Hola, mundo';
SELECT FORMAT(saludo);

Para declarar variables en PL/SQL:

DECLARE 
   entero integer := 10;
   numero NUMBER(3):= 123;
   nombre VARCHAR2(45);
   flotante real;
   tiempo_salida TIMESTAMP(3):= '23-JUL-2024 07:22:53.175';
   verdadero BOOLEAN:= FALSE;
   fecha DATE;
   ...
BEGIN
 -- SENTENCIAS
END;
/
     
   

En BigQuery:

DECLARE nombre STRING DEFAULT 'MARIA';
DECLARE fecha DATE;
DECLARE verdadero BOOL DEFAULT TRUE;
DECLARE numero INT64;
DECLARE otro_num NUMERIC DEFAULT 12.0;

SET numero = 9;
SET fecha = '2024-09-12';

...    
   

Es muy parecida la forma en que se declaran las variables.

Al ser lenguajes procedimentales tendrán:

1. Sentencias Top-Down o de arriba hacia abajo. 
2. Sentencias iterativas o repetitivas. 
3. Sentencias selectivas o condicionales.

Sentencias Top-Down

Sentencias de arriba hacia abajo. No hay mucha ciencia e ello. Comencemos con PL/SQL:

DECLARE
-- Declaramos las variables
numero INTEGER;
verdadero BOOLEAN;
fecha DATE;
presente NUMBER;

BEGIN
-- Seteamos sus valores
numero := 33;
verdadero := FALSE;
fecha := TO_DATE('2024/07/09', 'yyyy/mm/dd');
presente := 2300.23;


--
END;
/

En BigQuery:

BEGIN
DECLARE numero INT64;
DECLARE verdadero BOOL;
DECLARE fecha DATE;
DECLARE presente NUMERIC;

-- Seteamos sus valores
SET numero = 33;
SET verdadero = FALSE;
SET fecha = FORMAT_DATE("%Y-%d-%m",'2024/07/09');
SET presente = 2300.23;


--
END;

Sentencias iterativas o repetitivas

Bucle FOR en PL/SQL

FOR contador IN 1..20
LOOP
   contador := contador + 1;
END LOOP;

Bucle WHILE en PL/SQL

WHILE contador <= 100
LOOP
   contador := contador + 1;
END LOOP;

Bucle FOR en BigQuery

DECLARE vector_a ARRAY<STRING>;
SET vector_a = ['_01', '_02', '_03'];

FOR loop_variable_name IN (SELECT * FROM UNNEST(vector_a))
DO
  -- Hacer algo aquí;
END FOR;

Bucle WHILE en BigQuery

declare cont int64 default 0;
set TAM = (select count(*) from `project.dataset.tabla1`);
set cont = 1;

while cont <= TAM do
   -- 
   SET cont = cont + 1;
end while;

Solo son algunas sentencias repetitivas. Ambos incluyen otras como: LOOP.

Sentencias selectivas o condicionales

IF en PL/SQL

DECLARE 
  numero INTEGER;
  titulo VARCHAR2(5):="ABCD";

BEGIN
  numero:=33;
IF numero = 33 THEN
   SELECT "Hola, "||numero FROM dual;
END IF;

IF LENGTH(titulo) = 5 THEN
   SELECT 'La cadena tiene una longitud de 5';
ELSE 
   SELECT 'La cadena tiene una longitud de '||LENGTH(titulo);
END IF;

END;
/

IF en BigQuery

DECLARE numero INT64;
DECLARE titulo DEFAULT 'ABCD';
SET numero = 33;

IF numero = 33 THEN
   SELECT FORMAT('Hola, ', CAST(numero AS STRING));
END IF;

IF LENGTH(titulo) = 5 THEN
   SELECT 'La cadena tiene una longitud de 5';
ELSE 
   SELECT 'La cadena tiene una longitud de '||LENGTH(titulo);
END IF;

Solo mostramos algunas sentencias. Si quieres ver sentencias condicionales en BigQuery, puedes echar un vistazo en este link:

https://codemonkeyjunior.blogspot.com/2024/11/gcp-funciones-condicionales-en-bigquery.html

Continuaremos con este tema en siguientes posts.

Enlaces:

https://elbauldelprogramador.com/plsql-procedimientos-y-funciones/
https://docs.oracle.com/cd/B28359_01/appdev.111/b28843/tdddg_procedures.htm

PL/SQL: creando Stored Procedures (1era parte)

PL/SQL es un lenguaje de programación procedimental diseñado para operar en entornos Oracle.

Con este lenguaje podemos hacer:

• Automatizar tareas complejas dentro de la base de datos mediante procedimientos y funciones.
• Implementar reglas de negocio complejas con triggers y validaciones. 
• Gestionar transacciones y manejar errores de manera robusta. 
• Manipular conjuntos de datos utilizando cursores. 
• Integrar lógica de negocios en aplicaciones que interactúan con bases de datos Oracle.

En esta ocasión veremos cómo crear Stored Procedures o procedimientos almacenados. Los cuales son procedimiento que pueden o no devolver algún valor (contrario a las funciones que siempre devuelven algún valor). Estos podrán, una vez que sean creado, ser invocados en tus scripts.

La sintaxis para crear un Stored Procedure es la siguiente:

-- Sintaxis para crear un Stored Procedure 
CREATE [OR REPLACE] PROCEDURE procedure_name
    [ (parameter [,parameter]) ]

IS
    [declaration_section]

BEGIN
    executable_section

[EXCEPTION
    exception_section]

END [procedure_name];

Para su invocación debemos anteponer la palabra ``CALL`` seguido del nombre.

CALL miprocedimiento();
CALL miprocedimiento(arg1, arg2, argN);

En un anterior post vimos cómo crear bloques PL/SQL. Un Stored procedure contiene bloques que harán determinada tarea que nosotros definamos.

BEGIN
  DBMS_OUTPUT.PUT_LINE('Hola desde PL/SQL');
END;

Ejemplo 1. Crear un Stored procedure para mandar un mensaje a pantalla.

hola.sql

CREATE OR REPLACE PROCEDURE hola 
IS 
  nombre VARCHAR2(6):='Thomas';
BEGIN 
  IF nombre IS NOT NULL THEN 
    dbms_output.put_line('Hola, '||nombre);
  END IF;
END;
/

Lo invocamos de está forma:

SET VERIFY OFF;
SET SERVEROUTPUT ON;

-- Invocar Stored procedure
CALL hola;

Ejemplo 2. Crear un Stored Procedure para ver la versión de Oracle instalada.

mi_proc.sql

CREATE OR REPLACE PROCEDURE mi_proc
    IS
    version_inst VARCHAR(200);
    consulta VARCHAR(200):='SELECT BANNER FROM v$version';    
BEGIN
    dbms_output.put_line('Version instalada: ');
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line(version_inst);
END;
/

Lo invocamos:

SET VERIFY OFF;
SET SERVEROUTPUT ON;

CALL mi_proc;

Enlaces:

https://codemonkeyjunior.blogspot.com/2023/07/plsql-bloques.html
https://www.plsqltutorial.com/

Aprender Oracle SQL con LiveSQL

Si deseas aprender SQL o mejorar tus habilidades existe un sitio para hacerlo: https://livesql.oracle.com/

LiveSql es un sitio con tutoriales, ejemplos y editor que nos permite ejecutar sentencias SQL como:

• Crear tablas.
• Crear vistas.
• Consultar datos de las tablas.
• Crear bloques PL/SQL.
• Crear funciones y procedimientos PL/SQL.
• etc.

¿Qué es SQL?

Son las siglas de Structured Query Language. Un lenguaje especializado para la creación y manipulación de la información contenida en tablas de información perteneciente a una base de datos.

El SQL se divide en:

• DCL: Data Control Language (GRANT/REVOQUE).
• TCL: Transaction Control Language (COMMIT/ROLLBACK/SAVEPOINT).
• DDL: Data Definition Language(CREATE/ALTER/DROP/RENAME/TRUNCATE).
• DML:Data Manipulation Language(INSERT/SELECT/UPDATE/DELETE).

DCL, nos permitirá otorgar y revocar permisos a tablas, funciones y procedimientos y otros objetos.

TCL, nos permitirá el control de las transacciones.

DDL, nos permitirá el control de la definición de los objetos.

DML, nos permitirá la manipulación de la información contenida.

LiveSql está enfocado tanto a principiantes como experimentados en el conocimiento de SQL. No permite crear o borrar bases de datos. No las necesitas, con que puedas crear tablas y manipularlas te bastará, ya que trabajarás con la BD que provee el sitio.

Oracle posee, al igual que otros SGBD (Sistema Gestor de Bases de Datos) su propios tipos de datos como lo pueden ser:

VARCHAR
CHAR
FLOAT
NUMBER
DATE
LONG
BINARY_FLOAT
BINARY_DOUBLE
TIMESTAMP
CLOB
BLOB
...

El editor nos permitirá ejecutar cualquier sentencia SQL válida:

select to_char(sysdate, 'HH:MI:SS') as hora from dual;

HORA

03:13:05

Podremos ejecutar bloques PL/SQL:

DECLARE
BEGIN
   dbms_output.put_line('Fecha: '||sysdate);
END;
/

Fecha: 12-MAY-24

Más ejemplos en próximos posts.

Enlaces:

https://livesql.oracle.com/

PL/SQL - Bloques

PL/SQL es un lenguaje de programación procedimental para manipular datos de una BD Oracle. Con este lenguaje podemos crear scripts para poder manipular información de tablas, ejecutar otros scripts, crear procedimientos que se activen ante un evento(triggers), que devuelvan valores (funciones) o que simplementen realicen una operación al invocar un procedimiento (stored procedures).

Si queremos saber la versión instalada podemos ejecutar esta sentencia:

-- Con una consulta 
SELECT * FROM v$version;

En PL/SQL podríamos ejecutar el siguiente bloque de código:

-- Con un bloque PL/SQL
SET SERVEROUTPUT ON;
DECLARE
    version_inst VARCHAR(200);
    consulta VARCHAR(200):='SELECT BANNER FROM v$version';
BEGIN
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line('Version instalada: '||version_inst);
END;
/

Si queremos podríamos crear excepciones:

-- Con un bloque PL/SQL con manejo de excepción
SET SERVEROUTPUT ON;
DECLARE
   NULL_STRING EXCEPTION;
   PRAGMA 
   EXCEPTION_INIT(NULL_STRING, -06535);
   version_inst VARCHAR(200);
   consulta VARCHAR(200);
BEGIN
    -- Ejecutamos consulta
    EXECUTE IMMEDIATE consulta INTO version_inst;
    dbms_output.put_line('Version instalada: '||version_inst);
    EXCEPTION
        WHEN NULL_STRING THEN
           dbms_output.put_line('Error: No existe la tabla o la consulta es erronea o esta vacía');
END;
/

Como se puede ver, creamos una excepción (NULL_STRING) para verificar que la cadena de consulta es nula (vacía). Usamos PRAGMA la cual es una palabra reservada de Oracle para añadir directivas al compilador. Ésta le dice al compilador que se comporte de cierta manera, en este caso es una excepción (un error en el flujo del programa).

El pragma EXCEPTION_INIT asocia un nombre de excepción con un número de error de Oracle. Puede interceptar cualquier error ORA- y escribir un controlador específico para él en lugar de usar el controlador OTROS (OTHERS).

La sección de EXCEPTION WHEN se ejecuta cuando ocurre alguna excepción. Dependiendo de la programación se podrá (o no) cachar correctamente la excepción. Recordar que una excepción es una anomalía en el flujo de un programa, no necesariamente es un error grave. En caso de un error, el programa se terminará abruptamente.

Al final tendríamos algo como esto:

-- Con un bloque PL/SQL y verificando consulta
SET SERVEROUTPUT ON;
DECLARE
   NULL_STRING EXCEPTION;
   PRAGMA 
   EXCEPTION_INIT(NULL_STRING, -06535);
   version_inst VARCHAR(200);
   consulta VARCHAR(200):='SELECT BANNER FROM v$version';
BEGIN
    IF LENGTH(consulta) > 0 THEN
       -- Ejecutamos consulta
       EXECUTE IMMEDIATE consulta INTO version_inst;
       dbms_output.put_line('Version instalada: '||version_inst);
    END IF;
    EXCEPTION
        WHEN NULL_STRING THEN
           dbms_output.put_line('Error: No existe la tabla o la consulta es erronea o esta vacía');
END;
/

En próximos post veremos más ejemplos.

Enlaces:

https://livesql.oracle.com/
https://www.techonthenet.com/oracle
http://www.rebellionrider.com
https://docs.oracle.com
https://www.codifica.me/pragma/
https://elbauldelprogramador.com/plsql-excepciones/