Te encuentras en la páginas de Blogsperu, los resultados son los ultimos contenidos del blog. Este es un archivo temporal y puede no representar el contenido actual del mismo.

Comparte esta página:

Etiquetas: [funcional]  [java 8]  [lambda]  [tips]  
Fecha Publicación: 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 »
Etiquetas: [datasource]  [jakarta ee]  [mysql]  
Fecha Publicación: 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 »
Etiquetas: [java record]  [record]  
Fecha Publicación: 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 »
Etiquetas: [jakarta ee]  [maven]  
Fecha Publicación: 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.


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.

Etiquetas: [jakarta ee]  [microprofile]  [payaramicro]  [quarkus]  
Fecha Publicación: 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 »
Etiquetas: [contenedores]  [docker]  [jakarta ee]  [mysql]  [payara]  
Fecha Publicación: 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 »
Etiquetas: [contenedores]  [docker]  [liferay]  [mysql]  [openjdk]  
Fecha Publicación: 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 »
Etiquetas: [live]  [video]  
Fecha Publicación: 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.



Etiquetas: [microprofile]  [microservicios]  [quarkus]  
Fecha Publicación: 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

Etiquetas: [rendimiento]  
Fecha Publicación: 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 »
Etiquetas: [liferay]  [portales]  [portlets]  [tutorial]  [video]  [web]  
Fecha Publicación: 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 »
Etiquetas: [liferay]  
Fecha Publicación: 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 »
Etiquetas: [jakarta ee]  [jwt]  [microprofile]  [payara]  [seguridad]  
Fecha Publicación: 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:
  1. La publicación de Victor Orozco: A simple MicroProfile JWT token provider with Payara realms and JAX-RS
  2. JWT dispenser de Adam Bien.

¿Por qué "Lemon"?

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

Etiquetas: [jakarta ee]  [jaxrs]  [microprofile]  [restful]  
Fecha Publicación: 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 xclass 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.xclass);
}
//...
}

(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 xclass 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.xclass,
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.xclass); //.. 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í:


Etiquetas: [otj]  [tutorial]  [tutorial java]  
Fecha Publicación: 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 »
Etiquetas: [otj]  [tutorial]  [tutorial java]  
Fecha Publicación: 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 »
Etiquetas: [otj]  [tutorial]  [tutorial java]  
Fecha Publicación: 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 »
Etiquetas: [base de datos]  [entidades]  [liferay]  [servicios]  [tutorial]  
Fecha Publicación: 2019-08-09T15:07:00.000-05:00
Sigamos con Liferay, ahora con el tema Service Layer.

Liferay Service Builder es una herramienta de generación de código que permite, usando un archivo xml, generar una capa completa de servicios. La generación de código incluye definciones de base de datos, código para caché y persistencia, clases de servicios con métodos CURD y la capa de servicios remotos con compatibilidad con JSON y SOAP Web Services.

¡Y todo esto con un solo archivo service.xml !


Leer el artículo completo »
Etiquetas: [liferay]  [portlets]  [video]  
Fecha Publicación: 2019-07-17T17:24:00.001-05:00
Continuamos con las peticiones de un Portlet. En el anterior post vimos como navegar entre páginas. Esto es análogo a las peticiones GET de HTTP. Lo que ahora veremos es cómo atender peticiones tipo POST que generalmente están asociadas a las peticiones de un formulario.


Leer el artículo completo »
Etiquetas: [liferay]  [portlets]  [video]  
Fecha Publicación: 2019-07-15T18:01:00.003-05:00
Como en toda página web es necesario conocer cómo navegar entre páginas. Naturalmente usaremos un tag a, pero un portlet de Liferay necesita cierto cuidado dado que se deben pasar parámetros específicos, además de considerar valores precargados dependiendo del caso.

En este post conoceremos un poco la navegación de Liferay considerando el tag liferay-portlet:renderURL.


Leer el artículo completo »
Etiquetas: [jakarta ee]  [jsf]  [payara]  
Fecha Publicación: 2019-07-12T11:56:00.001-05:00
Siguiendo con nuestra serie de JSF (en Jakarta EE 8) hoy veremos cómo manejar campos de tipo enum y LocalDate.

Estos campos no son comunes para manejar en un formulario web, donde generalmente se maneja en campos de tipo String.

Veremos que Jakarta EE 8 manipula los de tipo enum de una manera transparente, mientras que los LocalDate necesita de una pequeña ayuda usando un javax.faces.convert.Converter.


Leer el artículo completo »
Etiquetas: [liferay]  [portlets]  [video]  
Fecha Publicación: 2019-07-11T17:02:00.002-05:00
Siguiendo con nuestros vídeos de Liferay, ahora veremos cómo crear un portlet.

Leer el artículo completo »
Etiquetas: [eclipse]  [java]  [liferay]  [portales]  [portlets]  [video]  
Fecha Publicación: 2019-07-09T19:00:00.000-05:00
Comenzaremos una serie de vídeos (adicional a la de Jakarta EE 8) para aprender a desarrollar con Liferay 7.2

En este vídeo veremos cómo configurar nuestro Eclipse IDE junto con nuestro Liferay 7.2.


Leer el artículo completo »
Etiquetas: [jakarta ee]  [java]  [java ee]  [jsf]  [netbeans]  [payara]  [tutorial]  
Fecha Publicación: 2019-06-11T22:00:00.000-05:00
Seguimos con los vídeos de JSF.

Ahora veremos cómo validar unos campos en JSF:

  • que no sea blanco
  • que sea un campo email.
Sin utilizar algún widget de Javascript, y sin agregar mucho más código.

Finalmente, seguiremos teniendo un .war totalmente liviano.



Si gustó el vídeo dale like; si te es útil, compártelo.. es gratis.
Etiquetas: [java]  
Fecha Publicación: 2019-06-11T14:24:00.001-05:00
La inicialización es el asignar un valor inicial cuando se declara una variable. Esto se puede poner en los atributos de las clases:
//...
public xclass OrdenCompra{
private java.util.Date fecha=new java.util.Date();
//...

Este ejemplo clásico, significa que cuando se instancie un nuevo objeto de OrdenCompra se le asignará un valor inicial (la fecha y hora actual) a la propiedad fecha.

De eso estamos de acuerdo todos. Pero un inicializador va más allá de una simple asignación en tiempo de ejecución.

Leer el artículo completo »