Apuntes de Java

La Gran Mentira de Kubernetes: Desmontando el Hype con la Suite de HashiCorp

2026-01-31T12:30:00.000-05:00

La Mentira

Nos han vendido una mentira industrial.

Te han repetido hasta el cansancio que, para desplegar software moderno, necesitas la complejidad de Google. Te han dicho que si no usas Kubernetes (K8s), tu infraestructura es "legacy", irrelevante o amateur. Te han convencido de que sacrificar 4GB de RAM solo para mantener vivo el plano de control es "el costo de hacer negocios".

La realidad es más oscura: Kubernetes es un monstruo de sobre-ingeniería diseñado para venderte nubes costosas y horas de consultoría eterna.

La "Herejía" que propongo hoy es simple: No necesitas esa complejidad. Puedes tener orquestación, descubrimiento de servicios, balanceo de carga y escalado automático consumiendo una fracción de los recursos y con una curva de aprendizaje humana.

Hoy vamos a desmontar el mito. Vamos a levantar una infraestructura completa usando la "Vía HashiCorp" (Nomad & Consul) sobre un entorno hostil (WSL2), y vamos a probar su resistencia con fuego real (k6).

Leer el artículo completo »

CodeHaus Cargo - Ejecutando aplicaciones Jakarta EE sin descargar servidores

2025-05-17T14:28:00.002-05:00

Una de las tantas dificultas que tiene un desarrollador de Jakarta EE es el configurar un servidor de - justamente - Jakarta EE. Aparte que existe varias como GlassFish, JBoss, Resin, Tomcat / TomEE, WebLogic, Wildfly (y de más), lo más complicado es:

Descargar
Configurar

Pues en este artículo vamos a conocer un plugin que ha reducido el dolor de cabeza. Se llama Code Haus Cargo.

Leer el artículo completo »

Jakarta EE 11 - Jakarta Data - Parte 1

2025-03-05T12:15:00.001-05:00

A la fecha de esta publicación, aún no se ha lanzado oficialmente Jakarta EE 11. Pero ya hay unos avances de ciertas especificaciones, como Jakarta Data la que yo considero una de las más interesantes e importantes.

En este post veremos cómo podemos configurar nuestro proyecto con Jakarta EE 11 + Jakarta Data, utilizando la implementación de Hibernate sobre Payara Server.

Leer el artículo completo »

¿Qué son los Virtual Threads ?

2024-09-27T16:16:00.004-05:00

Ya se ha leído "Virtual Threads" por aquí y por allá desde Java 19, pero ¿realmente, qué son?

En este post trataré de explicar su definición, por qué deberíamos usarlos y cómo podríamos ir cambiando nuestros proyectos a los Virtual Threads.

Vamos a ello

Leer el artículo completo »

¿Cuál IDE debo usar para programar en Java?

2024-02-24T23:59:00.004-05:00

Cuando comenzamos a programar en Java, quizás uno de los grandes dilemas es ¿con qué software haremos nuestro programas?

Escuchamos, nos invitan, nos mencionan, y hasta nos persuaden (creo que no han llegado a amenazarnos) que debamos usar cierto IDE y no otro (a menos que sea una política de la empresa)

En esta publicación analizaremos qué es y no es un IDE, mencionaremos y analizaremos los más conocidos, y veremos cuál es el "mejor".

Leer el artículo completo »

Roadmap Java Fullstack Developer 2024

2024-01-11T17:01:00.004-05:00

Vuelvo al blog después de tiempo, porque no tenía tiempo 😁

Esta vez tengo la motivación de desarrollar un roadmap para que cualquier desarrollador que tenga la intensión de ser un Java Developer pueda seguir estos niveles.

Leer el artículo completo »

Las redes sociales

2023-07-06T13:42:00.003-05:00

Bueno, esto ya se salió de control.

Desde que Elon Musk tomó el control de Twitter para hacerlo más libre, solo logró que sea más restringido.
Ahora Reddit cobra por los subreddit... ya no es libre como lo era.
Hay redes sociales que de verdad son libres, pero no le dan tanta publicidad.
Hay redes sociales que son basura y son muy usadas.

Así que, aquí listaré las redes sociales que he creado y que trataré de tener algún contenido, y claro, que aporten al conocimiento (y de hecho que no tendrán mucha acogida).

Leer el artículo completo »

Conociendo las Expresionas Lambdas: desde lo simple hasta lo avanzado.

2023-04-01T13:24:00.004-05:00

Veamos las expresiones Lambda, desde lo simple hasta lo complejo, para saber cómo aplicarlo y por qué aplicarlo.

Vamos

Leer el artículo completo »

¿Qué son los :: en Java?

2022-11-05T15:40:00.000-05:00

¿Vas llevando tiempo programando en Java y de repente encuentras que usan esta notación?

String::toUpperCase

Y te preguntas ¿Ya parece C++? ¿Qué es eso? ¿Cómo funciona ese ::

Aquí explicaremos un poco de qué trata.

Leer el artículo completo »

DataSource en Jakarta EE

2022-08-31T18:24:00.001-05:00

Para que nuestra aplicación Jakarta EE tenga conexión a la base de datos, debemos configurar un DataSource. No debemos usar la clase java.sql.DriverManager, es decir, la conexión nativa a JDBC, sino, debemos usar lo que ofrece el servidor Jakarta EE. Aquí mostraremos dos maneras: configurando el DataSource en la misma aplicación, y configurando en el Servidor Jakarta EE.

Leer el artículo completo »

JDK Record ¿Lo necesito?

2022-07-15T23:16:00.000-05:00

JEP 395: Records : https://openjdk.org/jeps/395.

Apareció en la versión JDK 14 como preliminar, y ya fue lanzado como oficial en la versión JDK 16. ¿Para qué es? ¿Para qué sirve? ¿Será peligroso para mis proyectos? ¿Será más peligroso para mis hijos?. En este artículo examinaremos hasta qué tan útil puede ser los Records en JDK.

Leer el artículo completo »

Jakarta EE 9 Essentials Archetype

2022-06-21T12:20:00.000-05:00

Acabo de publicar mi primer arquetipo a Maven 🎉🎉🎉

Se llama "Jakarta EE 9 Essentials Archetype".

Permite crear un proyecto básico con las mínimas dependencias, compatible para cualquier servidor Jakarta EE 9. Tiene una nada de dependencias y de plugins, solo lo necesario para que se construya una aplicación Jakarta EE.

El sitio web del proyecto:https://apuntesdejava.github.io/jakartaee9-essentials-archetype/
Detalles del arquetipo en el repositorio central: https://search.maven.org/artifact/com.apuntesdejava/jakartaee9-essentials/0.1/maven-archetype

Modo de uso

Para crear un proyecto basta con ejecutar el siguiente comando desde la consola desde una carpeta / directorio en blanco:

mvn -DarchetypeGroupId=com.apuntesdejava \
    -DarchetypeArtifactId=jakartaee9-essentials \
    org.apache.maven.plugins:maven-archetype-plugin:generate

Si se ejecuta así, el maven preguntará por el nombre el grupo, del artefacto y del paquete del proyecto a crear.

Con NetBeans

Con IntelliJ

Con Visual Studio Code

Con Eclipse IDE

Motivación

En principio, porque cuando creaba un proyecto Jakarta EE usando algún IDE, éste me creaba con muchas dependencias y plugins.

Otra motivación es porque este proyecto es un anticipo de otro proyecto que estamos desarrollando. Ya lo estaré compartiendo por este medio y por las redes.

Cambiando propiedades de conexión JDBC en Quarkus.... durante ejecución (y en Payara Micro)

2022-03-28T16:06:00.004-05:00

Normalmente, los valores de las conexiones DEBEN estar separado del código (si eres principiante, ya debes saberlo a rajatabla). Y si usamos frameworks como Quarkus, PayaraMicro, OpenLiberty, etc (ah, también Springboot) estos ya tienen preparado características como "perfiles" donde las propiedades pueden establecerse de acuerdo a cada perfil, o también podemos usar los perfiles del Maven para usar tal o cual propiedades. O también podemos hacer que tomen los valores del entorno (variables del entorno donde se está ejecutando, sea test, staging, producción, etc). En fin, podemos configurar los valores de las propiedades ANTES de que se ejecute la aplicación para que funcione tranquilamente. Y así, no pasó nada.

PEROOO!!! Hay veces que el cliente, en su afán de implementar seguridad extrema dice que nada de las credenciales de base de datos puede estar en variables de entorno, ni en las propiedades de despliegue, ni nada. Sino que están en un recurso externo (puede ser un Azure Table Storage, AWS Secret Manager, REST API, en otra base de datos, etc) solo nos dicen "tú consumes este nombre y ahí están las credenciales". Suena comprensible, pero - considerando lo expuesto en el anterior párrafo - no habría manera directa de leer los valores de las credenciales antes de insertar en las propiedades justo antes que termine de ejecutarse la aplicación. Deberíamos interceptar la ejecución de la lectura de las propiedades, o de la creación de la conexión de la base de datos.

En este post veremos la solución para dos Frameworks: Quarkus y PayaraMicro. Las credenciales serán tomadas de un servicio REST ficticio. La base de datos será H2 para no tener que pensar en configurar un ambiente. Espero que les sea útil

Leer el artículo completo »

Payara + MySQL en contenedores

2022-02-04T20:24:00.001-05:00

Seguimos con la contenedir.. bueno, poniendo todo en contenedores. Ahora, una aplicación que estaba desarrollando en vivo, una aplicación Jakarta EE (con EJB, JPA y JSF) lo he puesto para que, en desarrollo, se pueda ejecutar en un Payara normal del IDE, y que también pueda ejecutarse en contenedores. Aquí explicaré un poco de cómo se logra esto, y un breve repaso a la organización de la aplicación.

Leer el artículo completo »

OpenJDK + Liferay + MySQL, en contenedores

2022-01-28T19:36:00.003-05:00

Estamos en el mundo de la contened.. conteneni...contenedoriza... bueno, que todo lo colocan en contenedores. Lo cual es un gran alivio en la configuración y puesta en producción de servidores. No tendríamos de qué preocuparnos más que esté bien configurado a través de un archivo YAML.

Una de los temas más recurrentes que he hablado en este humilde blog es sobre el CMS hecho en Java llamado Liferay. Siempre la parte que más me preocupaba era: ¿cómo diablos podemos ponerlo en producción con algunos pasos?. Pues bueno, aquí lo explico en este post: usando Docker.

Leer el artículo completo »

Hablemos Java - Primer "En vivo" del blog: Streams, Lambdas y otras cosas más

2021-07-12T18:58:00.000-05:00

Comenzando una nueva sección: los vídeos en vivo. Para que se vea que no hay truco o trampa, y si hay, que aparezcan en vivo.

Aquí la primera emisión donde hablamos sobre Streams y Lambdas.

Si te gusta el contenido y deseas ver más, apóyame con un like y suscribíendote al canal. Estate atento a las siguientes emisiones. Podemos conversar ahí y hasta podríamos resolver problemas juntos.

Quarkus con NetBeans 12

2020-12-11T09:00:00.001-05:00

En este vídeo conoceremos un poco de Quarkus, crear una aplicación MicroProfile, y ejecutarlo desde NetBeans.

Luego iremos desarrollando más funcionalidades MicroProfile en este proyecto de Quarkus

Midiendo el rendimiento de rutinas

2020-04-09T22:35:00.005-05:00

Estos días me ha tocado revisar código hecho por otros, y encontré un par de rutinas que me parecieron interesantes para revisar. Estas las publiqué en la cuenta de twitter:

#CodeReviewChallenge

A ver, cómo optimizarían este código (que encontré)? pic.twitter.com/PUWZy0erpG
— ☕ Apuntes de Java ☕ 😷🏠 (@apuntesdejava) April 6, 2020

#CodeReviewChallenge #QuedateEnCasa #StayHome
¿Cómo simplificarían el contenido de este método? (sin usar bibliotecas adicionales) pic.twitter.com/rfRn8Qb2Ga
— ☕ Apuntes de Java ☕ 😷🏠 (@apuntesdejava) April 7, 2020

He recibido respuestas interesantes.

Lo que publicaré en este post y en un vídeo es ver cuál es la rutina más rápida, en base a sus respuestas.

Leer el artículo completo »

Liferay 7.2. Service Layer + Portlet. Un CRUD básico

2020-02-04T11:51:00.001-05:00

En este post conoceremos cómo implementar un CRUD muy básico, pero consiste en unir el Service layer con el Portlet. Aquí ya unimos las piezas que forman el MVC en Liferay.
Leer el artículo completo »

Liferay 7.2. Service Layer - Consultas personalizadas

2019-12-10T17:51:00.000-05:00

Hasta el momento hemos creado consultas simples, como listar todos los registros con un campo u otro campo iguales.

Pero necesitamos que nuestros registros puedan ser leídos con cualquier combinación de los cambios.

El Service Layer nos cubre grandes funcionalidades con las características básicas del CRUD. Además, podemos agregar otros tipos de consultas. Estos tipos de consulta se llama DynamicQuery, y es lo que veremos en este post.
Leer el artículo completo »

Presentando MP Lemon Builder

2019-12-10T13:45:00.001-05:00

Aquí les presento la primera versión de mi aplicación MP Lemon Builder.

¿En qué consiste?

Es un generador de proyectos MP (MicroProfile), y en esta primera versión permite crear una aplicación asegurada con JWT. La autenticación utilizará el realm del servidor (en esta primera versión utiliza a Payara) y la validación de los roles lo hará utilizando el estándar de JakartaEE.

Aquí muestro un vídeo de cómo funciona.

Fuentes

Esta aplicación está basada en dos proyectos:

La publicación de Victor Orozco: A simple MicroProfile JWT token provider with Payara realms and JAX-RS
JWT dispenser de Adam Bien.

¿Por qué "Lemon"?

Porque me gustan las frutas, y el limón es una de mis preferidas.

Cliente Standalone de JAX-RS (o cualquier endpoint RESTful)

2019-11-06T18:16:00.003-05:00

Si tenemos una aplicación standalone (puede ser un JavaFX, de línea de comandos, batch, etc) que necesite consumir un endpoint hecho en RESTful, por lo general usaríamos algo como esto:

public class RestClient {
  
    private static final String REST_URI 
      = "http://localhost:8082/spring-jersey/resources/employees";
  
    private Client client = ClientBuilder.newClient();
 
    public Employee getJsonEmployee(int id) {
        return client
          .target(REST_URI)
          .path(String.valueOf(id))
          .request(MediaType.APPLICATION_JSON)
          .get(Employee.class);
    }
    //...
}

(Tomado de https://www.baeldung.com/jersey-jax-rs-client)

Lo cual no está mal, pero creo que debería ser lo más transparente posible. ¿Cómo es eso?
Si ven en la línea 13 del código anterior, significa que hay que decirle que haga un GET a la petición, además de pasarle el tipo de respuesta y otras cosas más. La cuestión se volvería algo compleja si queremos hacer otras peticiones como POST, DELETE, etc.

Pues aquí vengo con una solución que encontré revisando la documentación de JAX-RS.

El servidor

Para este ejemplo, he creado un pequeño servidor CRUD en Payara Micro, el cual puedes obtener su código aquí: https://github.com/apuntesdejava/demo-jaxrs-standalone/tree/master/demo-jaxrs-server

El Endpoint principal es este:

@Path("person")
@Produces(APPLICATION_JSON)
@Consumes(APPLICATION_JSON)
@ApplicationScoped
public class PersonEndpoint {

    @Inject
    private PersonRepository personRepository;

    @POST
    public Response create(PersonParam param) {
        Person p = personRepository.create(param.getName(), param.getEmail());
        return Response.ok(p).build();
    }

    @GET
    public Response list() {
        List<Person> list = personRepository.findAll();
        return Response.ok(list).build();
    }
    
    @DELETE
    @Path("{id}")
    public Response delete(@PathParam("id")long personId){
        personRepository.delete(personId);
        return Response.ok().build();
    }

}

El cual tiene tres métodos principales:

@POST create() para insertar registros
@GET list() para leer todos los registros
@DELETE delete() para borrar un registro

Una manera para probarlo es ejecutándolo y llamando desde un cliente:

Insertando un registro:

Listando los registros:

Borrando ese registro (en mi caso, el 97)

El Cliente

En el cliente tiene que existir un método que luzca igual que la clase del endpoint servidor para que sea "transparente" la invocación.

@Path("person")
@Produces(APPLICATION_JSON)
@Consumes(APPLICATION_JSON)
public interface PersonEndpoint {

    @POST
    Response create(PersonParam param);

    @GET
    Response list();

    @DELETE
    @Path("{id}")
    Response delete(@PathParam("id") long personId);
}

Pero esto tiene un tratamiento muy especial: no es una clase, es una interfaz. Aquí es lo divertido ¿cómo es que lo podrá identificar cada petición? Pues esta es la magia del cliente JAX-RS.

Hay varios clientes de JAX-RS, algunos son:

RestEasy: https://github.com/resteasy/resteasy-examples/tree/3.6.0.Final/jaxrs-2.0/simple-client
Quarkus: https://quarkus.io/guides/rest-client
Apache CXF: https://cxf.apache.org/

Aquí usaré el Apache CXF. Independientemente puede usarse cualquier implementación, pero seguirá siendo la misma interfaz. Solo cambia cómo se invoca al Endpoint del Cliente.

Así se construye usando Apache CXF:

        PersonEndpoint client = JAXRSClientFactory.create(
                REST_URI,
                PersonEndpoint.class,
                Arrays.asList(
                        new JacksonJaxbJsonProvider()
                ));

Luego, se llama como si fuera cualquier método "local":

        PersonParam param = new PersonParam("persona 1", "abc@mail.com"); //creo los parámetros
        Response resp = client.create(param); //invoco al endpoint
        LOG.log(Level.INFO, "status:{0}", resp.getStatusInfo().getReasonPhrase()); //muestro la respuesta
        if (resp.getStatus() == Response.Status.OK.getStatusCode()) { //si está ok...
            Person p = resp.readEntity(Person.class); //.. convierto la petición en la entidad que se recibió...
            LOG.log(Level.INFO, "-> registro insertado:{0}", p.toString()); //... y muestro el contenido
        }

Si deseamos listar, también se haría lo mismo:

        resp = client.list(); //invocamos el método de listado
        LOG.log(Level.INFO, "status:{0}", resp.getStatusInfo().getReasonPhrase()); //mostramos el resultado...
        List<Person> list = null;  //preparamos nuestra lista que vamos a recibir
        if (resp.getStatus() == Response.Status.OK.getStatusCode()) { //evaluamos el contenido... si está OK...
            list = resp.readEntity(new GenericType<List<Person>>() {  //... convertimos la petición en el listado
            });
            list.forEach((p) -> { //... y podemos listar el contenido.
                LOG.log(Level.INFO, "id:{0}\tname:{1}\temail:{2}", new Object[]{p.getPersonId(), p.getName(), p.getEmail()});
            });
        }

Código fuente

El código fuente para este proyecto se puede encontrar aquí:

Otro tutorial de Java: Sesión 3 - Tipos de variables y cómo nombrarlas

2019-10-12T12:22:00.001-05:00

Las variables, cuáles son sus tipos, y cómo se deberían declarar.

Leer el artículo completo »

Otro tutorial de Java: Sesión 2 - Teoría OOP y aplicación en Java

2019-10-12T12:21:00.001-05:00

Comenzaremos un poco con la teoría de Objetos, y veremos cómo se aplica en Java.

Leer el artículo completo »

Otro tutorial de Java: Sesión 1 - Instalación de entorno y primer programa

2019-10-12T12:19:00.001-05:00

Comenzaremos una nueva serie de videos tutoriales llamado: OTRO TUTORIAL DE JAVA

Leer el artículo completo »