6 Herramientas para mejorar la productividad del desarrollador Java

Los desarrolladores de Java tienen perspectivas laborales muy altas en la industria del desarrollo de software. Con razón, Java impulsa muchas de las aplicaciones y servidores de escritorio, web y móviles del mundo. La mayoría de las empresas que reclutan desarrolladores de Java pertenecen a las industrias más maduras, como la atención médica y el Retail.

En consecuencia, es importante que los desarrolladores de Java sean eficaces y eficientes en sus trabajos.

A continuación se muestran seis de las herramientas más útiles que los desarrolladores de Java deberían considerar usar.

Netbeans

Son pocos los desarrolladores de Java que no conocen Netbeans. Es un entorno de desarrollo integrado (IDE) de código abierto en varios idiomas.

Lejos de ser un simple editor de texto, proporciona algunas características interesantes que ayudan a los desarrolladores a ser productivos.

Las características clave incluyen su resaltado de sintaxis que facilita la refactorización del código, ya que no solo le brinda información de sintaxis sino también de semántica. También proporciona excelentes plantillas y asistentes para una amplia gama de lenguajes de programación.

También es una plataforma de aprendizaje: tiene un tutorial completo de Java (y también PHP). Otra cosa que se destaca de Netbeans es que facilita a los desarrolladores la gestión de sus proyectos mediante el uso de favoritos y el control de versiones. También se sincroniza bien con Github.

La comunidad crea continuamente una gran cantidad de herramientas poderosas para hacer que el uso de Netbeans sea más placentero.

¿Cuál es tu nivel de conocimiento en NetBeans?, ¿Básico, medio o experto?. 

Rookout

Como desarrollador de Java, al igual que con todos los desarrolladores, encontrar y solucionar errores son dos de las actividades que requieren más tiempo. Estos no solo consumen mucho tiempo, sino que causan mucha angustia innecesaria cada vez que parece que un error da origen a otros errores en el futuro.

El problema se agrava cuando el error se experimenta en producción y el equipo de operaciones querría que corrigiera los errores en el código de producción.

Si bien es importante contar con una buena estrategia de depuración, es aún más esencial contar con las herramientas adecuadas para ayudarlo a hacerlo. Después de todo, nuestros ojos humanos están limitados en lo que pueden sentir.

Aquí es donde una herramienta de depuración como Rookout puede ayudar. Te permite depurar en cualquier entorno. El equipo de operaciones quiere que vayas y averigües qué está mal con el código enviado a producción. Puede realizar una depuración remota en vivo allí. También puede implementar la depuración de producción, lo que permite una experiencia perfecta.

También mejora la colaboración al proporcionar excelentes datos e información sobre los errores encontrados y también comparte métricas comerciales a pedido.

Y tu, ¿ya has usado Rookout?  ¿Te atreverías a probarlo?

JUnit

Corregir errores es una gran cosa. Pero, a menudo, el código que no presenta errores no se comporta como se esperaba durante la ejecución. Por ejemplo, declarar una calculo matemático incorrecto, tu programa puede no presentar errores de compilación, pero como garantizas que el resultado es el correcto?. O cuando realizas modificación en una clase, ¿Cómo garantizas que el cambio no impacta en toda la funcionalidad?

Este error se puede detectar mediante pruebas automatizadas.

JUnit es una herramienta de prueba elegida por los desarrolladores de Java. Es un Framework de código abierto. Por lo general, usa anotaciones para que las pruebas tengan accesorios antes de ejecutarlas. Algunas de sus ventajas incluyen la simplicidad de uso, proporciona informes de inmediato, no solo te permite escribir pruebas sino también todo un conjunto de pruebas.

La mayoría de los IDE son compatibles con JUnit, por lo que se ha convertido en uno de los Framework de prueba más populares, si no el más popular, para Java.

Y tu, ¿Haces pruebas unitarias de tus funcionalidades?

Apache Maven

Apache Maven es simplemente un software de gestión de proyectos de software. Si bien probablemente pueda usar cualquier otra herramienta para este propósito, Maven también administra compilaciones para sus proyectos Java.

Su principio de funcionamiento se basa en el concepto de modelo de objetos de proyecto (POM). La creación de un proyecto con Maven le facilitará automáticamente la creación de los siguientes. Una de las cosas que ayuda a aumentar la productividad de los desarrolladores de Java es su actualización automática de dependencias.

Dado que es de código abierto, la comunidad siempre agrega nuevas herramientas a su ya enorme biblioteca. No necesitará muchas configuraciones cuando lleguen nuevas herramientas útiles o se necesiten actualizaciones.

En este blog puedes encontrar muchos artículos útiles sobre Maven.

Git

Git es un software de control de versiones diseñado por Linus Torvalds, pensando en la eficiencia, la confiabilidad y compatibilidad del mantenimiento de versiones de aplicaciones cuando estas tienen un gran número de archivos de código fuente. Contar con un sistema de versionamiento te permitirá gestionar tu proyecto de forma flexible, revertir cambios, comparar versiones, aprobar cambios y restaurar cambios.

En este blog puedes encontrar una guía básica pero muy útil de GitHub

Apache Spark

Apache Spark permite a los desarrolladores de Java crear aplicaciones de procesamiento de datos intensivo. Permite procesar grandes cantidades de datos de forma rápida y escalable.

Es un marco basado en el modelo de programación MapReduce de Hadoop. Incluso amplía este modelo para incluir cálculos en una amplia gama de tipos de datos y tipos de consultas (incluida la transmisión).

A los desarrolladores de Java interesados en la ciencia de datos les encantará.

Conclusión

La productividad es más que usar herramientas. Es importante que un desarrollador también sepa jugar bien con todo el equipo. Sin embargo, estas herramientas, ya sea que se utilicen individualmente o juntas, de hecho pueden aumentar la cantidad de trabajo de calidad realizado por los desarrolladores.

Como publicar mi proyecto Java EE en internet

Este 2021 inicio con un proyecto personal, para ello he desarrollado mi aplicación Java EE tomando como base Shopizer, y llegado la hora de publicarlo a internet me he encontrado con desafíos, le he dedicado muchas horas a investigar, por ello en esta entrada documento todo.

Conceptos que aprendí

Sitio Web, Aplicación Web, Hosting, Servidor en la nube (cloud), Servidor VPS, 

Esta entrada trata sobre

Preparar un servidor virtual para desplegar aplicaciones Java EE y hacerlo accesible a Internet con un presupuesto de 50USD anual.

Lo primero que hice fue comprar el dominio, este lo compré en GoDaddy, no tuve mayores problemas. Luego voy por el Hosting, y aquí me encontré con muchas confusiones, probé con Wordpress para luego enterarme que Wordpress es un Hosting + CMS, algo que definitivamente no me sirve, yo solo tenía acceso a la aplicación CMS, olvídate de tener un MySQL, Wildfly y Apache.

Investigando descubrí que generalmente un Hosting es un ambiente preconfigurado para subir un sitio web y no una aplicación web. La mayoría de los Hosting vienen con un conjunto de software pre instalado y configurado para sitios web PHP.

Seguí investigando y encontré que lo que yo buscaba era un servidor web en la nube, en realidad podría tener mi propio servidor web en el departamento pero al hacer cálculos de costes no es muy conveniente que digamos. 

Siguiendo con la historia, encontré un servidor en la nube muy bueno, viene pre configurado para la tecnología Java, Red Hat Openshift, ya viene instalado MySQL, Java, Tomcat o Wildfly. El problema es el costo, 50 USD mensual, estamos hablando de 600 USD anual. y pues se sale de mi presupuesto, mi presupuesto es de 50 USD anual. Jajajaja.

Seguí investigando y encontré que hay un servidor en la nube virtual, sin nada pre instalado mas que solo el SO, y el costo es de un poco menos de 50 USD anual. Estos son los conocidos Servidor VPS. Por ahora me encuentro en Chile así que elegí a mi proveedor https://www.hosty.cl/cloud-vps/

Una segunda buena opción erá https://www.digitalocean.com/products/droplets/ pero ligeramente más caro, 20 USD aprox más que hosty. Por el precio lo descarté, quizás en el futuro.

Una tercera opción que no me convence del todo es https://www.hostignition.com/index.php?page=jsp-servlets, no me terminar de convencer ya que viene pre configurado con Tomcat y sospecho no se puede instalar Wildfly, pero igual debería darle una revisada.

Conectarte al Servidor VPS

Un servidor VPS es como cualquier servidor, solo que está en la nube, en internet, tiene su SO, en mi caso elegí Ubuntu Server 18, y para acceder a el lo haces mediante un cliente SSH Putty. El proveedor te da la dirección IP, el puerto, y la contraseña del usuario root  la cual puedes cambiar  mas adelante. De entrada Putty no me pareció muy amigable, cuando llegué al login en ingresaba el password de mi usuario Linux, en la consola, el promt no dibuja los caracteres ingresados, por fortuna puedes copiar y pegar el password haciendo click derecho sobre la consola.

Instalando MySQL

Para instalar MySQL ejecutar el siguiente comando Ubuntu

sudo apt install mysql-server

Para verificar si el servicio de MySQL esta ejecutándose correctamente ejecutar el siguiente comando

sudo netstat -tap | grep mysql

Y deberías ver la siguiente salida

tcp        0      0 localhost:mysql         0.0.0.0:*               LISTEN                              6874/mysqld

En caso de que el servicio no esté corriendo puedes iniciarlo ejecutando el siguiente comando

sudo systemctl restart mysql.service

Instalando Java

He decidido instalar OpenJDK ya que es la opción mas sencilla, para instalar, ejecutar los siguientes comandos.

sudo apt update

sudo apt install default-jdk

Instalando Apache Tomcat

Decidí instalar Apache Tomcat en lugar de Wildfly, la razón principal es porque no voy a usar EJB, aquí puedes leer una entrada exclusiva para saber como instalar Tomcat. ¿Cómo instalar Apache Tomcat en un servidor VPS Linux? 

Configurando el nombre del dominio web en Apache Tomcat

Para mostrar tu aplicación web cuando el usuario ingrese en su navegador el nombre de tu dominio deberás configurar el dominio en Apache Tomcat, aquí puedes leer una entrada exclusiva para saber como configurarlo. ¿Cómo configurar el nombre del dominio web en Apache Tomcat?

Configurando nuestro dominio

Pronto...

Seguridad

Pronto...

Y bueno... aun me queda mucho trabajo por hacer, instalar MySQL, Java, Wildfly, Apache Web, y configurar Wildfly con Apache Web.

Seguiré documentando...

Persistencia de Datos con JPA

Gestionando Objetos Persistentes

Siempre me gusta tomar como referencia la documentación oficial, en el caso de JPA tenemos la especificación la cual lo puedes consultar en 

JPA 2.2 https://jcp.org/en/jsr/detail?id=338

Desarrollo de Aplicaciones con Java EE 8

Java Enterprise Edition 8 (Java EE8), es la ultima versión de la especificación de Java EE, agrega varias características nuevas a la especificación anterior. Varias APIs que ya existían han sido mejoradas en esta versión, y otras APIs nuevas han sido agregadas. Este curso cubre la ultima versión de la especificación de Java EE, el cual es la más popular, incluye JavaServer Faces (JSF), Java Persistence API (JPA), Enterprise JavaBeans (EJB), Contexts and Dependency Injection (CDI), JSON Processing JSON-P, JSON Binding (JSON-B), WebSocket, Java Messaging Service JMS, JAX-WS, JAX-RS. También cubre aspectos de seguridad en las aplicaciones Java EE con la nueva de seguridad para Java EE.

Si deseas conocer la lista completa de los cambios y APIs agregadas puedes consultar la entrada Qué hay de nuevo en Java EE 8

Tabla de Contenidos

Capitulo 1: Introducción a Java EE

Capitulo 2: JavaServer Faces
Capitulo 3: Persistencia de datos con JPA
Capitulo 4: Enterprise Java Beans
Capitulo 5: Contexto e Inyección de Dependencias
Capitulo 6: 

Como usar c3p0 en JPA Hibernate

Cuando damos nuestros primeros pasos en JPA/Hibernate no nos preocupan los detalles, solo queremos ver lo fácil y rápido que es poder persistir objetos en nuestra base de datos. Realizar consultas y otros temas relacionados con la persistencia de datos.

Cierto día mi servidor de Base de datos MySQL estaba apagado, mi aplicación se demoró unos 5 minutos en intentar establecer conexión. Dejando la aplicación congelada durante ese tiempo. Este fue el motivo que me llevó a investigar como tener mayor control con la conexión a la base datos, me llevó a preguntarme como establecer un time-out.

El otro motivo fue el log que me llamó la atención, el mensaje decía "using hibernate built-in connection pool (not for production use )". Esto significa que Hibernate viene con un pool de conexiones integrado, un pool de conexiones que no está recomendado para ser usado en producción, solo para desarrollo.

C3P0 es un pool de conexiones de base de datos, tu puedes establecer un rango de conexiones permitidos, estás conexiones se van instanciando a demanda. Por ejemplo, al iniciar tu aplicación es posible que se instancie una primera conexión, si tu sistema es multi-hilo posiblemente estás cargando los datos de configuración mientras el usuario necesita hacer login, el pool de conexiones se da cuenta de que necesitas una conexión más, primero buscará una conexión ya instanciada pero que este sin usar, de existir te entregará esa conexión, si no existe entonces va a crear una nueva instancia.

C3P0 no solo es un pool de conexiones, tiene muchas otras características, una de ellas es poder establecer un timeOut de conexión, un timeOut de consulta entre otras características.

Voy a explicar como integrar y usar C3P0 en proyecto Maven y en un proyecto Java estándar.

Integrar C3P0 en un proyecto Maven

Lo que debemos hacer es agregar la dependencia en nuestro archivo pom.xml

<dependency>
    <groupId>org.hibernate</groupId>
    <artifactId>hibernate-c3p0</artifactId>
    <version>5.3.6.Final</version>
</dependency>

La versión debe ser similar o lo más cercano a la versión de hibernate-entitymanager, la ventaja de usar Maven es que automáticamente va identificar si hibernate-c3p0 requiere de otras dependencias y así recursivamente, por eso, si vas a la lista de dependencias de tu proyecto, vas a notar que ahora tienes las siguientes dependencias.

hibernate-c3p0-5.3.6.Final.jar
c3p0-0.9.5.2.jar
mchange-commons-java-0.2.11.jar

Si te preguntas como me he enterado de todos los jars necesarios, pues te diré que en el repositorio de maven está la lista de todas las dependencias. Tu buscas hibernate-c3p0-5.3.6.Final.jar y se te mostrará las dependencias necesarias para compilar y/o ejecutar.

Integrar C3P0 en un proyecto estándar

Para integrar c3p0 en un proyecto estándar debes descargar los jars por separados, los puedes descargar desde el repositorio de maven. Una vez descargados debes agregarlos al classpath de tu proyecto.

Propiedades C3P0
Las propiedades más relevantes para c3p0 son:

hibernate.c3p0.min_size: El numero minimo de conexiónes a mantener en el pool de conexiones. Conexiones que si no se usan estarán "dormidas"

hibernate.c3p0.max_size: El numero maximo de conexiones a mantener en el pool de conexiones. Si se llega al numero máximo de conexiones y la aplicación requiere más conexiones entonces la petición quedará bloqueada hasta que una conexion esté disponible.

hibernate.c3p0.checkoutTimeout= El timeout en mili segundos para establecer la conexion con la base de datos. Si no se estable a conexion en ese timeout se lanzará una excepción.

Estás propiedades se agregan en la unidad de persistencia, dentro del archivo persistence.xml o también se pueden agregar mediante código fuente.

Crear servicios REST en Java en 10 minutos

Esta es una guía practica para crear un par de servicios RESTful, si deseas conocer los conceptos teóricos de este estilo de arquitectura te recomiendo leer los siguientes enlaces.

API Rest ¿Que es? y sus ventajas

Aspectos básicos de RESTful

Introduccion a RESTful

Por allá en el 2013 tuve un tímido acercamiento a la plataforma Java EE, todavía era una plataforma compleja. Para implementar unos servicios REST era necesario implementar interfaces, extender clases abstractas y configurar archivos XML. La plataforma ha evolucionado con el tiempo para bien, haciendo más facil el desarrollo de los servicios REST gracias a las anotaciones las cuales reemplazan las configuraciones de archivos XML. Gracias a estas mejoras podemos crear un par de servicios REST en 10 minutos o menos. Vamos a por ello!!

Requerimientos

Java 8

Wildfly 12

Netbeans 8.2 con Maven y soporte para Java EE

Presentación de los servicios a crear

Vamos a crear dos servicios, uno para persistir la información de una persona y otro para consultar la información de una persona. En ambos servicios usaremos JSon para representar los datos de una persona.

1.- Crear el proyecto web demo-rest

Nuevo Projecto → Maven → Web Application

En project name ingresar demo-rest

En package ingresar demo.rest

2.- Creamos la clase Persona para encapsular los datos de un objeto persona

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package demo.rest.domain; import java.io.Serializable; /** * * @author Roberto Lopez */ public class Persona implements Serializable { private String name; private String lastname; private int age; public Persona(){ name = ""; lastname = ""; age = 0; } /** * @return the name */ public String getName() { return name; } /** * @param name the name to set */ public void setName(String name) { this.name = name; } /** * @return the lastname */ public String getLastname() { return lastname; } /** * @param lastname the lastname to set */ public void setLastname(String lastname) { this.lastname = lastname; } /** * @return the age */ public int getAge() { return age; } /** * @param age the age to set */ public void setAge(int age) { this.age = age; } @Override public String toString(){ return "[name=" + name + ", lastname=" + lastname+ "]"; } }

1. La clase Persona implementa a la interface Serializable
2. La clase Persona tiene un constructor sin parametros

3.- Creamos la clase de los servicios POST y GET para el recurso Persona

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package demo.rest.domain; import java.net.URI; import java.util.HashMap; import java.util.Map; import javax.ws.rs.Consumes; import javax.ws.rs.GET; import javax.ws.rs.POST; import javax.ws.rs.Path; import javax.ws.rs.PathParam; import javax.ws.rs.Produces; import javax.ws.rs.core.Context; import javax.ws.rs.core.MediaType; import javax.ws.rs.core.Response; import javax.ws.rs.core.UriInfo; /** * * @author Roberto Lopez */ @Path("/persona") public class PersonaRestService { private static final Map<Integer, Persona> personasMap = new HashMap<>(); @Context private UriInfo uriInfo; public PersonaRestService(){ System.out.println("creando una instancia de PersonaRestService"); } @POST @Consumes(MediaType.APPLICATION_JSON) public Response addPersona(Persona persona) { System.out.println("addPersona(" + persona +")"); Integer id = (personasMap.size() + 1); personasMap.put(id, persona); URI uri = uriInfo.getAbsolutePathBuilder().path(id.toString()).build(); return Response.created(uri).build(); } @GET @Path("/{id}") @Produces(MediaType.APPLICATION_JSON) public Persona getPersona(@PathParam("id") Integer id){ if(!personasMap.containsKey(id)){ return null; } return personasMap.get(id); } }

Como podrás observar, esta es una clase común y corriente pero que tiene algunas anotaciones propias para el soporte de REST javax.ws.rs.*, las cuales serán reconocidas por el servidor de aplicaciones para finalmente exponer el servicio, analicemos para que esta cada una de ellas.

La anotación @Path indica la URL en la cual responderá este servicio, cabe mencionar que esta anotación se puede poner a nivel de clase y método, en este caso, al estar a nivel de clase, afecta a todos los servicios que definamos.

La anotación @Context permite inyectar un objeto de la clase UriInfo
Las anotaciones @Consumes y @Produces son para indicar que tipo de mensaje esperamos como entrada (consumes) y que tipo de mensaje vamos a responder (produces). En este caso, estamos indicando que esperamos JSON como entrada y que vamos a responder igualmente con JSON. La plataforma REST se encargar de parsear el mensaje JSon a objeto y viceversa.

La anotación @POST indica que nuestro método addPersona va a procesar las peticiones POST y la anotación @GET inicia que nuestro método getPersona va a procesar las peticiones GET.
El método getPersona devuelve la información de una persona en formato JSon
La anotación @Path("/{id}") y @PathParam("id") están relacionadas, nos permite obtener el id de la URL como un parámetro para nuestro método getPersona

4.- Extendemos la clase Abstracta ApplicationInfo

/* * To change this license header, choose License Headers in Project Properties. * To change this template file, choose Tools | Templates * and open the template in the editor. */ package demo.rest.domain; import java.util.Set; import javax.ws.rs.core.Application; /** * * @author Roberto Lopez */ @javax.ws.rs.ApplicationPath("rest") public class ApplicationConfig extends Application { @Override public Set<Class<?>> getClasses() { Set<Class<?>> resources = new java.util.HashSet<>(); resources.add(demo.rest.domain.PersonaRestService.class); return resources; } }

Debemos extender la clase javax.ws.rs.core.Application para registrar nuestra clase que implementa nuestros servicios REST.
Observar que esta clase también tiene la anotación @javax.ws.rs.ApplicationPath("rest") donde rest formará parte de la URL http://localhost:8080/demo-rest-1.0-SNAPSHOT/rest/persona de nuestro servicio.

5.- Clean and Build
Hacemos un Clean Build y Ejecutamos. Netbeans se encarga de desplegar nuestra aplicación web e iniciar el servidor WildFly

6.- Probar los servicios
Para probar nuestros servicios yo utilizo RestClient https://github.com/wiztools/rest-client/releases la versión GUI, restclient-ui-fat-3.7.1.jar
Las URL de nuestro servicio es http://localhost:8080/demo-rest-1.0-SNAPSHOT/rest/persona/ el cual se construye a partir de http://localhost:8080/{nombre_aplicacion}/rest/persona/

Observar que he seleccionado String body como tipo de contenido y application/json como formato y UTF-8 como codificación.

Puedes descargar el código fuente desde mi repositorio en GitHub 

Parseando un archivo XML con SAX Parser

Parseando un archivo XML usando SAX Parser

SAX, también conocido como una API simple para XML, es usado para parsear (del archivo xml a objetos) documentos XML.
En este tutorial, vamos a aprender lo que SAX es, por qué, cuando y como debería de usarlo.

SAX es un API usado para parsear documentos XML. Está basado en eventos generados mientras va leyendo el documento. Metodos Callback reciben estos eventos. Una clase manejadora contiene estos metodos Callbacks.
El API es eficiente porque los eventos son desechados después de que los metodos Callbacks los han recibido y procesado. Por lo tanto, SAX es eficiente con el manejo de memoria, a diferencia de DOM, por ejemplo.

SAX vs DOM
DOM mantiene un Modelo de Objetos para el Documento. El parser DOM no trabaja sobre eventos. En realidad, carga todo el documento XML en memoria. SAX es más eficiente en el manejo de la memoria que DOM.
DOM tiene la ventaja de facilitar el realizar operaciones en todo el documento una vez que el documento ha sido cargado en memoria.

En el ejemplo vamos a parsear un archivo xml que tiene una lista de Clientes, los clientes tienen los atributos nombre y teléfono, aquí el xml.
Nota: El archivo xml lo debes colocar en la raíz de tu proyecto
<?xml version="1.0" encoding="UTF-8"?> <!-- To change this license header, choose License Headers in Project Properties. To change this template file, choose Tools | Templates and open the template in the editor. --> <clientes> <cliente> <nombre>Juan Pablo</nombre> <telefono>99123445</telefono> </cliente> <cliente> <nombre>Antonia de las Flores</nombre> <telefono>272727</telefono> </cliente> <cliente> <nombre>Andres Garcia</nombre> <telefono>88888823423</telefono> </cliente> </clientes>

Y aquí tienes la clase

package com.marcosroberto.sax; import org.xml.sax.Attributes; import org.xml.sax.SAXException; import org.xml.sax.helpers.DefaultHandler; import javax.xml.parsers.ParserConfigurationException; import javax.xml.parsers.SAXParser; import javax.xml.parsers.SAXParserFactory; import java.io.IOException; import java.util.ArrayList; import java.util.List; public class SaxParserMain { public static void main(String[] args) throws ParserConfigurationException, SAXException, IOException { SAXParserFactory factory = SAXParserFactory.newInstance(); SAXParser saxParser = factory.newSAXParser(); ClientesHandler clientesHandler = new ClientesHandler(); saxParser.parse("clientes.xml", clientesHandler); System.out.println(clientesHandler.getClientes()); } public static class ClientesHandler extends DefaultHandler { private static final String CLIENTES = "clientes"; private static final String CLIENTE = "cliente"; private static final String NOMBRE = "nombre"; private static final String TELEFONO = "telefono"; private static List<cliente> clientes; private String valorElemento; public List<cliente> getClientes(){ return clientes; } @Override public void characters(char[] ch, int start, int length) throws SAXException { valorElemento = new String(ch, start, length); } @Override public void startDocument() throws SAXException { clientes = new ArrayList<>(); } @Override public void startElement(String uri, String localName, String qName, Attributes attributes) throws SAXException { switch (qName) { case CLIENTES: //no hacer nada break; case CLIENTE: clientes.add(new Cliente()); } } @Override public void endElement(String uri, String localName, String qName) throws SAXException { switch (qName) { case NOMBRE: ultimoCliente().setNombre(valorElemento); break; case TELEFONO: ultimoCliente().setTelefono(valorElemento); break; } } private Cliente ultimoCliente() { int latestArticleIndex = clientes.size() - 1; return clientes.get(latestArticleIndex); } } public static class Cliente { private String nombre; private String telefono; /** * @return the nombre */ public String getNombre() { return nombre; } /** * @param nombre the nombre to set */ public void setNombre(String nombre) { this.nombre = nombre; } /** * @return the telefono */ public String getTelefono() { return telefono; } /** * @param telefono the telefono to set */ public void setTelefono(String telefono) { this.telefono = telefono; } @Override public String toString(){ return nombre + " - " + telefono; } } }

SAX Parser lee el archivo XML de arriba hacía abajo, de izquierda a derecha y dispara los siguientes eventos:

- Inicio del Documento
- Inicio de un Elemento
- Fin de un Elemento
- Fin del Documento

El protocolo HTTP

¿Por qué debo conocer el protocolo el HTTP?

En Java es muy común usar la tecnología Servlets y RESTful para crear aplicaciones Cliente-Servidor, estas tecnologías usan el protocolo HTTP, para nosotros es transparente y podríamos pasar por alto este protocolo. Sin embargo, tener conocimientos del protocolo HTTP no está de más, y si eres curioso como yo, estarás deseoso de saber como funciona este protocolo.

El protocolo HTTP (Hypertext Transfer Protocol) es un estandard que define como un cliente web se comunica con un servidor y como la información es transferida desde el servidor hacía el cliente. Aunque HTTP es usualmente usado para transferir documentos HTML e imágenes embebidos en el documento HTML, HTTP es agnóstico al formato de los datos. HTTP puede ser usado para transferir imágenes, documentos Word, programas .exe, o cualquier cosa que pueda ser representado en bytes. Para escribir programas que usen HTTP, tu necesitas entender HTPP a un nivel de profundidad mucho mayor que el de un diseñador de paginas web. Escribiré una serie de entradas con el fin de mostrarte lo que pasa detrás del telón cuando tu ingresas un dirección web en la barra de tu navegador web.

HTTP es el protocolo estandard para la comunicación entre navegadores web y servidores web. HTTP especifica como un cliente y un servidor establecen una conexión, como el cliente solicita datos al servidor, como el servidor responde a esta petición, y finalmente, como la conexión es cerrada. 

¿Cómo ser el mejor programador?

Llevo casi 10 años en esta industria, con altibajos, por momentos siento que soy buen programador pero los retos nunca terminan. Presentas una prueba por aquí otra por allá y en algunas te rechazan, entonces te vuelves a preguntar, ¿Qué tengo que hacer para ser un gran programador?, ¿Cómo se que lo estoy haciendo bien?

La mayoría de los que llevamos la programación en la sangre tenemos esa ansiedad por ser cada día mejores programadores, resolver problemas complejos, hacer maravillas, magia. Y hay que sobrellevar esta ansiedad porque si no terminará por consumirte. Por esta razón he creado una guía para ayudarte en este proceso de mejora.

Voy a darte una serie de consejos para que te conviertas en el mejor programador, desde luego, es pre condición que te guste la programación, que sientes pasión por ella  y que el desarrollo de software  sea tu camino.

1.- Empieza a programar desde muy joven.

Me hubiese encantado haber conocido esta ciencia cuando era niño, desde los 8-10 años. Las ciencias de la computación es un área muy extensa porque se apoya en otras áreas, como las matemáticas, física, lógica, teoría de conjuntos etc,. Por ello, insisto, si puedes empezar a programar cuando antes mejor.

2.- Encuentra un mentor

Un mentor te ayudará a estar motivado, te compartirá su experiencia, te ayudará a reducir años de aprendizaje. Hay mucho conocimiento que uno aprende a base de experimentar, analizar, observar y prueba/error. Pero experimentar consume mucho tiempo, por eso es mejor contar con un buen mentor que te ayude en el desarrollo de tu carrera.

4.- Domina el área de Físico-Matemático

La matemáticas y física te ayudan a desarrollar el pensamiento abstracto, el razonamiento y capacidad de solucionar problemas. Por ello, aprovecha estos cursos, no los desestimes, álgebra, trigonométrica, teoría de conjuntos, probabilidad, calculo integral, calculo diferencial y física.

5.- Domina las estructuras de datos

Tienes que dominar las estructuras de datos, arreglos, listas, colas, pilas, arboles, grafos.

6.- Algoritmos

Trata de conocer los algoritmos más famosos, algunos algoritmos son constantes, como búsqueda y ordenamiento. Pero año con año salen nuevos algoritmos, otros se mejoran y así. En Internet existen muchos algoritmos que puedes estudiar. O porque no, diseñar tus propios algoritmos. La otra habilidad que debes desarrollar es la de traducir la solución de un problema en un algoritmo. Hay que gente muy inteligente que logra encontrar la mejor solución a un problema, pero para programar la solución hay que definir el algoritmo. Si no eres muy inteligente para resolver problemas pero se te da bien definir el algoritmo, ahí tendrás un campo de trabajo.

7.- Desarrollar algunas habilidades

Para ser el mejor programador debes desarrollar las siguientes habilidades: observación, intuición.

8.- Lógica, Teoría de conjuntos, sucesiones y series

9.- Ingles

Los mejores artículos, tesis, e investigaciones relacionadas con las ciencias de la computación se encuentran en ingles. Por ello debes aprender Ingles.

10.- Practicar, practicar y practicar

Aprovechar el opensource, descarga código fuente, lee código fuente, debugea(depura) código fuente. En Internet hay muchas paginas donde puedes buscar problemas a resolver, practica mucho.,

Integrar Bootstrap en aplicaciones JSF 2.2

Después de meses de investigar, practicar e involucrarme en el paraguas de la tecnología Java EE, me he encontrado con la necesidad de integrar el framework Bootstrap. Bootstrap es un framework para la parte front end de una aplicación web, contiene elementos como menús, formularios, barras de navegación, y muchos otros componentes incluyendo la posibilidad de usar plantillas.

Mi técnica de auto aprendizaje consiste en investigar un ejemplo, reproducirlo y luego estudiar en detalle su funcionamiento, sus reglas y principios. En el caso de Bootstrap y en la mayoría de la tecnología Java EE, hay que tener mucho olfato e intuición porque rara vez los ejemplos funcionan. Esto se debe principalmente a que lo rápido que evolucionan las tecnologías, por ello la importancia de tener conocimientos sólidos de la tecnología Java EE.

En esta entrada voy a compartirles lo que a mi me ha funcionado para poder integrar Bootstrap en un proyecto Java EE para Wildfly 12, Wildfly 12 soporta la versión 2.2 de Java Server Faces. Encontré dos formas de hacerlo, les compartiré ambas.

Pre Requisitos

Java 8

Wildfly 12

Netbeans 8.2 con soporte para JEE

Bootstrap 3.4.1

Pasos para integración, primera opción

1.- Crear un proyecto Maven -> Web Application, llamado test-bootstrap

2.- Descargar Bootstrap 3.4.1  https://getbootstrap.com/docs/3.4/

3.- En el proyecto test-bootstrap. Crear un directorio resources dentro de webapp

4.- Dentro de resources crear un directorio llamado bootstrap

5.- Descomprimir la versión descargada de bootstrap en el paso 3.

6.- Copiar las carpetas css, fonts y js a bootstrap

7.- Renombrar index.html por index.xhtml y copia lo siguiente

<?xml version='1.0' encoding='UTF-8' ?> <!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Transitional//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-transitional.dtd"> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://xmlns.jcp.org/jsf/html"> <h:head> <meta charset="utf-8"/> <meta http-equiv="X-UA-Compatible" content="IE=edge"/> <meta name="viewport" content="width=device-width, initial-scale=1"/> <!-- The above 3 meta tags *must* come first in the head; any other head content must come *after* these tags --> <meta name="description" content=""/> <meta name="author" content=""/> <!-- Bootstrap core CSS --> <h:outputScript name="bootstrap/js/bootstrap.js" /> <h:outputScript name="bootstrap/js/bootstrap.min.js"/> <h:outputStylesheet name="bootstrap/css/bootstrap.css"/> <script src="https://ajax.googleapis.com/ajax/libs/jquery/1.11.0/jquery.min.js" /> <title>Hello JSF Bootstrap</title> <!-- Custom styles for this template --> <!--<h:outputStylesheet library="css" name="starter-template.css"/>--> </h:head> <h:body> <nav class="navbar navbar-inverse navbar-fixed-top"> <div class="container"> <div class="navbar-header"> <button type="button" class="navbar-toggle collapsed" data-toggle="collapse" data-target="#navbar" aria-expanded="false" aria-controls="navbar"> <span class="sr-only">Toggle navigation</span> <span class="icon-bar"></span> <span class="icon-bar"></span> <span class="icon-bar"></span> </button> <a class="navbar-brand" href="#">Project name</a> </div> <div id="navbar" class="collapse navbar-collapse"> <ul class="nav navbar-nav"> <li class="active"><a href="#">Home</a></li> <li><a href="#about">About</a></li> <li><a href="#contact">Contact</a></li> </ul> </div> <!--/.nav-collapse --> </div> </nav> <div class="container"> <div class="starter-template"> <h1> Bootstrap starter template</h1> <p class="lead"> Use this document as a way to quickly start any new project.<br/> All you get is this text and a mostly barebones HTML document.</p> <button type="button" class="btn btn-default btn-lg"> <span class="glyphicon glyphicon-star" aria-hidden="true"></span> Star </button> </div> </div> </h:body> </html>

Para integrar Bootstrap solo hay que agregar los recursos css y js a nuestros componentes xhtml.

<!-- Bootstrap core CSS -->
  <h:outputScript name="bootstrap/js/bootstrap.js" />
  <h:outputStylesheet name="bootstrap/css/bootstrap.css"/>

Estuve un tiempo confundido con los recursos css y js, se supone que la ruta de estos recursos, en relación al directorio del proyecto es 'recursos/bootstrap/js/bootstrap.js' y 'recursos/bootstrap/css/bootstrap.css'. Sin embargo, debemos verlo como un recurso de java, como si el directorio resources estuviera en nuestro classpath. Hay variantes sobre como leer y cargar los recursos css y js. Esta es la forma que a mi me funciona.

8.- También deberás editar el archivo web.xml, debemos agregar lo siguiente para que el servlet pueda procesar los documentos xhtml

<!-- Map these files with JSF --> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.xhtml</url-pattern> </servlet-mapping>

9.- Ejecutar la aplicación, debes algo similar a mi pagina.

Pasos para integración, segunda opción

La segunda opción consiste en tener los arhicos css, js de Bootstrap en un jar y agregarlo como una dependencia mas de nuestro proyecto.

1.- Seguimos  todos los pasos anteriores

2.- Editamos nuestro archivo pom.xml y en la sección de dependencias agregamos lo siguiente
<!--UI--> <dependency> <groupid>org.webjars</groupId> <artifactid>bootstrap</artifactId> <version>3.4.1</version> </dependency>

3.- Editamos nuestro archivo index.xhtml, especificamente la sección donde cargamos los recursos css y js de Bootstrap

<!--UI--> <!-- Bootstrap core CSS --> <h:outputStylesheet library="webjars" name="bootstrap/3.4.1/css/bootstrap.css"/> <h:outputScript library="webjars" name="bootstrap/3.4.1/js/bootstrap.js"/>

He agregado el atributo library y el name lo obtuve desde la pagina de webjars, pero el name lo podemos construir analizando la estructura del jar bootstrap webjar.

Con esta opción podemos borrar el directorio resources

Referencia

https://codeday.me/es/qa/20190123/110785.html

https://www.webjars.org/

Curso de Java Server Faces

Este año me he metido de fondo en el desarrollo de aplicaciones Web, usando las tecnologías de Java EE. He investigado y practicado mucho, y para mi practica profesional he desarrollado una aplicación Web.

No quiero que todo el esfuerzo que he realizado se desaproveche, lograr mi proyecto terminal fue todo un reto por desconocer la tecnología Java EE, así que estaré documentando todo lo aprendido en este curso de Java Server Faces. Disfrútalo.

¿Como subir una aplicacion Java EE a un servidor gratuito?

En la Universidad para mi proyecto de practica me han pedido subir mi prototipo a un servidor en Internet. No tenía idea de como hacerlo, el proceso me tomo al menos un día. Como siempre, me gusta documentar estos procesos que en un principio parecen complicados, documentación que me sirve para reforzar lo aprendido y al mismo tiempo que les sea útil al resto.

He descartado opciones como Google Cloud y Amazon Cloud, ya que mis cuentas de pruebas gratuitas están expiradas. La opción mas practica que encontré fue Servnet Telecomunicaciones  https://app.jl.serv.net.mx/

Consejos para ser un mejor programador

En mi trayecto como desarrollador de software he ido mejorando, aprendiendo de mis errores, aprendiendo de otros programadores. Cuando vivo una experiencia que me marca, lo anoto para después repasarlo. Siempre con el espíritu de crecer profesionalmente.

Tengo tantas ideas, principios y hábitos, algunos en mi mente, otros escrito en alguna hoja guardada entre las paginas de algún libro. En esta entrada pretendo ir organizando estas ideas para compartirlas, recibir retro alimentación o consejos adicionales.

Esta entrada complementa a la entrada ¿Como ser el mejor programador?

1.- Aprende a leer la documentación

Si eres programador del lenguaje Java, generalmente las clases de las APIs más usadas están documentadas en Javadoc, Javadoc es un estandard de Java para documentar. Lo mas relevante de Javadoc es comprender como usar una clase. Cada método tiene una breve descripción, los parámetros que recibe, el objeto que retorna, las posibles excepciones y las reglas más relevantes de uso. Muchas veces usamos una clase sin leer su documentación, violamos algunas reglas de uso y esto genera errores en tiempo de ejecución. Corregir los errores en tiempo de ejecución es muy costoso por eso es mejor invertir un poco de tiempo en leer la documentación de las clases.

2.- Conoce tu herramienta

¿Netbeans o Eclipse? No importa cual sea tu IDE favorito, invierte tiempo en conocer tu IDE. Siempre pregúntate ¿Como puedo optimizar esta tarea?

3.- TDD y depuración de código

Aplica TDD cuando consideres necesario y depura tu código fuente. Aplicar TDD me permite recibir retroalimentación de como trabajaría mi clase en tiempo de ejecución, que tan fácil y cómodo será su uso o integración y validar que la clase o clases cumplan con la funcionalidad esperada. Mas sobre TDD en esta entrada Usar TDD con Criterio

4.- Enfoque, que tu mente esté en el presente.

Es común programar en automático, muchas veces no estamos enfocados al 100% en el código que estamos escribiendo. ¿Te imaginas lo que pasaría si un cirujano está distraído mientras realiza una operación? Bueno... pues hay similitud con nuestro trabajo, una condición o validación errónea puede llevar a que nuestro sistema tenga comportamientos no esperados. (complementar con el punto anterior)

5.- Prudencia y Comunicación

Cuando modificamos código existente debemos tener mucho cuidado con los cambios que introducimos, si dudamos de los cambios que deseamos aplicar es mejor consultar con el resto del equipo. No hay que guardarnos nada, conocer la opinión de otros nos ayuda a corregir o justificar nuestras decisiones.

6.- Buscar la solución más simple

Resolver un problema es un arte, es muy buena practica tener más de una solución y buscar la solución más simple. No porque sea la más simple será la menos eficiente, de hecho, encontrar la solución más simple requiere ingenio, destreza y esfuerzo mental. El tiempo usado en encontrar la solución más simple es una inversión, la solución será menos propensa a errores, fácil de modificar y fácil de depurar.

7.- Pedir Ayuda y saber pedir ayuda
Trabajamos en equipo, tenemos compañeros, apoyémonos en ellos. Muchas veces no preguntamos por no quedar como tontos y esto lo único que hace es afectar nuestra paz mental. Nadie debería juzgarte o criticarte por preguntar. Sin embargo, debes saber pedir ayuda, ordena tus ideas, usa herramientas de comunicación para expresar tus dudas, herramientas como diagramas, dibujos, tablas etc,. Debes ayudar a que los demás comprendan tus dudas para que así puedan ayudarte. Tampoco es que los demás sean más inteligentes o quizás... muchas veces es porque tienen más experiencia, llevan mas tiempo en este arte del desarrollo de software y tu debes aprovechar estos conocimientos.

8.- No Re Inventes la Rueda, Re usa código

Está bien que para practicar programes cosas 

El fenomeno de la Tecnologia Java

Hablar de la Tecnología Java es tan común hoy día, pero ¿Que es exactamente la tecnología Java?, hay muchos conceptos y subtecnologías involucradas que muchos se confunden. He decidido escribir una serie de entradas para aquellos novatos que recién se están incorporando al mundo Java.

En esta entrada trataré de explicar como la tecnología Java se compone de un lenguaje de programación mas una plataforma.

La tecnología Java es tanto un lenguaje de programación como una plataforma.

El lenguaje de programación Java

El lenguaje de programación Java es un lenguaje de alto nivel, puede ser descrito por las siguientes palabras claves:

• Simple
• Orientado a objetos
• Distribuido
• Concurrente
• Dinámico
• Portable
• Alto Redimiendo
• Robusto
• Seguro

Cada uno de estos conceptos se explica en The Java Language Environment, un informe redactado por James Gosling y Henry McGilton y que discutiremos más tarde.

En el lenguaje de programación Java, todo el código fuente es escrito en archivos de texto plano con extensión .java. Luego estos archivos son compilados en archivos con extensión .class por el compilador javac. Un archivo .class no contiene código nativo para el procesador, en su lugar contiene bytecodes - el lenguaje de la maquina virtual de Java (Java VM). Entonces el comando de java puede ejecutar tu aplicación en una instancia de la Maquina Virtual de Java.

Una vista general del proceso de desarrollo de software en Java

La maquina Virtual de Java esta disponible en diferentes sistemas operativos, los mismos archivos .class pueden ser ejecutados en Microsoft Windows, Solaris, Linux, o Mac OS.

Existen varias implementaciones de la Maquina Virtual, Oracle proporciona una, conocida como Java SE HotSpot, esta maquina ejecuta algunos pasos adicionales en tiempo de ejecución para darle a la aplicación mayor rendimiento. Esto incluye varias tareas como encontrar cuellos de botella que afecten el rendimiento y recompilar a código fuente nativo aquellas secciones de código usado con frecuencia.

Por medio de las maquinas virtuales, la misma aplicación puede ser ejecutada en diferentes plataformas.

La plataforma Java

Una plataforma es el entorno hardware o software en el que se ejecuta un programa. Ya hemos mencionado algunas de las plataformas más populares como Microsoft Windows, Linux, Solaris OS y Mac OS. Se puede describir a la mayoría de las plataformas como una combinación del sistema operativo y el hardware subyacente. La plataforma Java difiere de la mayoría de las demás en que es una plataforma solo-software que se ejecuta encima de otras basadas en hardware.

La plataforma Java tiene dos componentes:

• La Máquina Virtual Java
• La Interfaz de Programación de Aplicaciones (API)

Ya hemos presentado a la máquina virtual Java; es la base de la plataforma Java y ha sido portada a varias plataformas basadas en hardware.

El API es una gran colección de componente de software listos para usar que proporcionan muchas funcionalidades útiles. Está agrupada en bibliotecas de clases relacionadas e interfaces; estas bibliotecas se conocen como paquetes. En la siguiente sección, ¿Qué puede hacer la tecnología Java? se resaltan algunas capacidades proporcionadas por el API.

El API y la máquina virtual Java aíslan al programa del hardware subyacente.

Al ser un entorno independiente de la plataforma, la plataforma Java puede ser un poco más lenta que el código nativo. Sin embargo, los avances en las tecnologías de los compiladores y las máquinas virtuales están acercando el rendimiento al del código nativo sin amenazar la portabilidad.

¿Qué puede hacer la tecnología Java?

El lenguaje de propósito general y alto nivel Java es una potente plataforma de software. Todas las implementaciones completas de la plataforma Java le proporcionan las siguientes características:

Herramientas de desarrollo: Las herramientas de desarrollo proporcionan todo lo que necesitará para compilar, ejecutar, monitorizar, depurar y documentar sus aplicaciones. Como desarrollador novel las principales herramientas que usará son el compilador javac, el lanzador java, y la herramienta de documentación javadoc.

Interfaz de programación de aplicaciones (API): El API proporciona la funcionalidad esencial del lenguaje de programación Java. Ofrece un amplio conjunto de clases listas para usar en sus propias aplicaciones. Abarca desde objetos básicos hasta el trabajo en red y la seguridad, la generación de XML y acceso a bases de datos y más. El núcleo del API es muy grande; consulte la documentación del Java SE Development Kit 6 (JDKTM 6) para obtener una vista global de lo que contiene.

Tecnologías de distribución: El software del JDK proporciona mecanismos estándar, como con el software Java Web Start software y Java Plug-In para la distribución de sus aplicaciones a los usuarios finales.

Conjuntos de herramientas de interfaz gráfica: Los conjuntos de herramientas (toolkits) Swing y Java 2D aportan la posibilidad de crear sofisticadas interfaces gráficas de usuario (GUIs).

Bibliotecas de integración: Las bibliotecas de integración como las APIs Java IDL, JDBC, «Java Naming and Directory Interface» (JNDI), Java RMI y «Java Remote Method Invocation over Internet Inter-ORB Protocol Technology» (Java RMI-IIOP Technology) proporcionan el acceso a bases de datos y la manipulación de objetos remotos.

¿Cómo cambiará la tecnología Java mi vida?

No podemos prometerle fama, fortuna, ni siquiera un trabajo si aprende el lenguaje de programación Java. Aún así, es probable que mejorará sus programas y requiere menos esfuerzo que otros lenguajes. Creemos que la tecnología Java le ayudará a hacer lo siguiente:

Empezar rápidamente: Aunque el lenguaje de programación Java es un potente lenguaje orientado a objetos, es fácil de aprender, especialmente para programadores que ya estén familiarizados con C o C++.

Escribir menos código: Las comparaciones de métrica de programas (número de clases, número de métodos, etc.) indican que un programa escrito en el lenguaje de programación Java puede ser cuatro veces más pequeño que el mismo programa escrito en C++.

Escribir mejor código: El lenguaje de programación Java fomenta las buenas prácticas de programación y la recolección de basura automática le ayuda a evitar fugas de memoria. Su orientación a objetos, su arquitectura de componentes JavaBeans y su API extensa y fácilmente extensible le permiten reutilizar código existente y probado y generar menos erratas.

Desarrollar programas más rápidamente: El lenguaje de programación Java es más simple que C++ y, por esto mismo, su tiempo de desarrollo puede llegar a reducirse a la mitad. Sus programas también necesitarán menos líneas de código.

Evitar dependencia de la plataforma: Puede mantener su programa portable evitando el uso de bibliotecas escritas en otros lenguajes.

Escribir una vez, ejecutar en cualquier lugar: Puesto que las aplicaciones escritas en el lenguaje de programación Java se compilan hacia bytecodes independientes de la máquina, éstas se ejecutan en cualquier plataforma Java con consistencia.

Distribuir software más fácilmente: Con el software Java Web Start, los usuarios podrán lanzar su aplicación con una sola pulsación del ratón. Una comprobación automática de versión asegurará que los usuarios siempre estén al día con la última versión de su software. Si hay disponible una actualización el software Java Web Start automáticamente actualizará su instalación.

La Plataforma Java Empresarial

He notado que existe mucha confusión, dudas e inquietudes acerca de la Plataforma Java Empresarial, la plataforma es muy extensa y algunos conceptos pueden llegar a confundir. Por ello decidí escribir esta entrada, espero poder aclarar todas las dudas.

Los desarrolladores de hoy reconocen cada vez más la necesidad de contar con aplicaciones distribuidas, transaccionales y portables que  aprovechen la velocidad, seguridad, y confiabilidad de la tecnología del lado del servidor.

Las aplicaciones empresariales proporcionan la lógica de negocio para una empresa. Estas aplicaciones son gestionadas de forma centralizada y, a menudo interactuan con otras aplicaciones empresariales.

En el mundo de las tecnologías de información, las aplicaciones deben diseñarse, construirse y entregarse con bajo presupuesto, con mayor velocidad y con menos recursos.

Con la Plataforma Java Empresarial (Java EE), el desarrollo de aplicaciones empresariales nunca había sido mas fácil o mas rápido. El objetivo de la plataforma Java EE es proporcionar a los desarrolladores un conjunto de APIs muy potentes, permitiendo reducir el tiempo de desarrollo, la complejidad de la aplicación y mejorando el rendimiento de la aplicación.

La plataforma Java EE se desarrolla a través de la Java Community Process (JCP) que es una comunidad responsable de todas las tecnologías (APIs) que forman la plataforma Java EE. Dentro de esta comunidad existen grupos de expertos que crean especificaciones para alguna tecnología en particular. A estás especificaciones se les conoce como Solicitud de Especificación de Java (JSR)

Es así como tenemos una especificación para cada versión de cada una de las Tecnologías (APIs) que conforman la plataforma Java EE.

Una Solicitud de Especificación de Java es es un documento formal propuesto para definir la funcionalidad y uso de la tecnología propuesta. Es decir, las clases, métodos, ciclos de vida, secuencias y como estás clases interactuan entre si. Un individuo o una organización puede convertirse en miembro de la Java Community Process (JCP) y puede desarrollar su código según las especificaciones mencionadas en JSR. La implementacion desarrollada de la especificación será revisada por los miembros del JCP y aprobarán o rechazarán. Generalmente, ademas del documento, la especificación tendrá un conjunto de interfaces java, las cuales deben ser finalmente implementadas por alguna organización interesada.

Por ejemplo, la API JPA (Java Persistence API), la especificación entrega un documento y el api que se componen de clases, interfaces, enums, y archivos xml de configuracion. Sin embargo, esta API por si sola no es útil. Tiene utilidad cuando se tiene una implementación, por ejemplo la empresa Red Hat tiene una implementación de JPA llamada Hibernate. Y así como Hibernate, existen otras implementaciones de JPA.

La gran ventaja de trabajar con especificaciones es tu puedes fácilmente cambiar de implementación y tu programa no debería requerir ningún cambio, para tu programa la implementación que estés usando es transparente.

Ahora si, vamos a ver de forma resumida cada una de las tecnologías o especificaciones que son parte de la plataforma Java EE.

Desafiando a la plataforma JEE

Son alrededor de las 23:00 horas, he tenido una día agotador, actualmente me encuentro desarrollando una API RESTFul. Para ello estoy usando JAX-RS, EJB, CDI,  JPA y JAXB. Ha sido desafiante porque las cosas no me salen a la primera, o me funciona pero a medida que voy incorporando más componentes deja de funcionar. La complejidad de Java EE está en la integración, hay muchos componentes involucrados y cada uno de ellos cuentan con reglas especificas que debemos conocer para asegurar el buen funcionamiento.

Mi estrategia ante una nueva plataforma o tecnología, es empezar paso a paso, si algo dejó de funcionar, volver atrás, observar mucho los logs, poner atención a cada detalle, como dice la frase "el diablo está en los detalles". Hay que ser muy astuto, tener olfato, tener colmillo, usar el sentido común, la lógica, la intuición. Si no, la frustración te consumirá.

Pero bueno, paso a paso estoy logrando los objetivos, así que... ahora sí voy enserio con JEE

Tutorial Basico PrimeFaces

Esta guía contiene los siguientes puntos

• ¿Que es PrimeFaces?
• Prerrequisitos
• Crear el proyecto en Netbeans
• Agregar la dependencia PrimeFaces a nuestro archivo pom.xml
• Crear nuestra página index.xhtml
• Agregar nuestro descriptor de despliege

¿Que es PrimeFaces?

PrimeFaces es una suite de componentes gráficos (botones, menús, listas, listas desplegables, tablas, paneles, dialogos y otros) para crear interfaces gráficas de usuarios para aplicaciones web. Prime Faces es una extensión de JSF(Java Server Faces). He usado esta suite para desarrollar aplicaciones JEE, existe una extensa documentación pero solo en ingles, es por ello que me nació la iniciativa de escribir un guía básica, la verdad es que PrimeFaces no es muy complejo, si has trabajado con JSF te adaptarás muy rapido.

Algunas características de PrimeFaces

• Se compone de un amplio catalogo de componentes, editores Html, dialogos, cuadros de textos que se autocompletan, graficas y mucho más.
• Se basa en APIs de Ajax y en el estandard JSF
• Ligero, un solo jar, no requiere dependencias y cero configuraciones
• Cuenta con un kit para desarrollo mobile
• Cuenta con 35 temas y herramienta para diseñar mas temas
• Extensa documentación pero solo en ingles
• Tiene una comunidad grande y activa
• Desarrollado con pasión, de desarrolladores de aplicaciones para desarrolladores de aplicaciones.

En esta guía básica solo mostraremos un popup con el mensaje "Hola Mundo desde PrimeFaces"

Prerrequisitos
Java JDK 6 o Java JDK 7
JBoss AS 7.1.1 Final
Netbeans 8.1 con Maven y Soporte para Java Web y JEE

Si tienes dudas con la instalación y configuración de JBoss, te recomiendo revisar mi entrada anterior Instalar jbossas7 en windows

JBoss AS 7, viene con Mojarra, el cual es una implementación de Java Server Faces versión 2.0

1.- Crear el proyecto en Netbeans
Crearemos un proyecto en Netbeans, File, New Project. En categories seleccionamos Maven y en projects seleccionamos Web Application, Next.

Ingresamos los siguientes datos, Next.

Seleccionamos el servidor JBoss as 7, Finish.

2.- Agregar la dependencia PrimeFaces a nuestro archivo pom.xml
Vamos a usar la version 5.3 de PrimeFaces, lo podemos hacer de dos formas, la primera es editando  el archivo pom.xml y agregar el siguiente extracto de xml

        <dependency>
            <groupId>org.primefaces</groupId>
            <artifactId>primefaces</artifactId>
            <version>5.3</version>
        </dependency>

La segunda opción es agregarlo de forma gráfica, en el navegador del proyecto, seleccionar Dependencies, click derecho Add Dependency

Add

3.- Crear nuestra página index.xhtml
En el navegador del proyecto, seleccionamos el directorio Web Pages, click derecho, New,  Other, en Categories seleccionamos Web y en Files Type seleccionamos XHTML, Next.
En el siguiente Dialogo, ingresar el nombre index

Editamos la página, lo más relevante de nuestra página

El namespace de primefaces
xmlns:p="http://primefaces.org/ui"

El tag contenedor de Java Faces
<f:view contentType="text/html">

El resto son los componentes gráficos, aquí tienes la página completa.

<?xml version="1.0" encoding="UTF-8"?> <!DOCTYPE html> <html xmlns="http://www.w3.org/1999/xhtml" xmlns:h="http://java.sun.com/jsf/html" xmlns:f="http://java.sun.com/jsf/core" xmlns:p="http://primefaces.org/ui"> <f:view contentType="text/html"> <h:head> <title>PrimeFaces Demo</title> </h:head> <body> <h2> PrimeFaces Demo</h2> <h:form> <h:panelGrid columns="1" cellpadding="5"> <p:commandButton value="Abrir Dialogo" type="button" onclick="PF('dlg1').show();" /> </h:panelGrid> <p:dialog header="Basic Dialog" widgetVar="dlg1" minHeight="40"> <h:outputText value="Hola Mundo desde PrimeFaces!" /> </p:dialog> </h:form> </body> </f:view> </html>

4.- Agregar nuestro descriptor de despliege
En el navegador de proyecto, seleccionamos el directorio Web Pages, click derecho, New, Other, en Categories seleccionamos Web y en Files Type seleccionamos Standard Deployment Descriptor (web.xml)

<?xml version="1.0" encoding="UTF-8"?> <web-app xmlns="http://java.sun.com/xml/ns/javaee" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd" version="3.0"> <servlet> <servlet-name>Faces Servlet</servlet-name> <servlet-class>javax.faces.webapp.FacesServlet</servlet-class> <load-on-startup>1</load-on-startup> </servlet> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.jsf</url-pattern> </servlet-mapping> <servlet-mapping> <servlet-name>Faces Servlet</servlet-name> <url-pattern>*.xhtml</url-pattern> </servlet-mapping> <context-param> <param-name>javax.faces.PROJECT_STAGE</param-name> <param-value>Development</param-value> </context-param> <session-config> <session-timeout>60</session-timeout> </session-config> <welcome-file-list> <welcome-file>index.xhtml</welcome-file> </welcome-file-list> </web-app>

Algunos tutoriales te dirán que debes tener el archivo de configuración faces-config.xml, para este ejemplo simple no es necesario.

Aquí puedes descargar el proyecto para Netbeans

Ejecutar
Siempre recomiendo primero hacer un Clean and Build y luego Run, la aplicación se desplegará en el navegador por defecto.

Conclusión

Java Server Faces ha evolucionado mucho, ahora es más simple sin tantos archivos de configuraciones como lo era en un inicio. PrimeFaces es una suite de componentes enriquecidos, facil de usar y que no requiere de dependencias ni configuraciones.

Referencia
https://www.primefaces.org/documentation/

NetBeans IDE tiene y hace uso de un cache

Era un día cualquiera de trabajo, modifiqué mis clases correspondientes y ejecute el proyecto, algo andaba mal, la funcionalidad no reflejaba los cambios, vuelvo a revisar las modificaciones, compilo las clases y ejecuto de nuevo. Nada, todo seguía igual, probé borrando el directorio dist del proyecto para que se compilara de nuevo. Vuelvo a ejecutar y nada, la funcionalidad no reflejaba los cambios. Me puse a investigar y encontré que NetBeans tiene un caché, NetBeans guarda el resultado de las compilaciones en este caché y lo usa para resolver enlaces entre componentes, también en este caché se guarda el resultado del escaneo del classpath. Cuando el caché está corrupto NetBeans no puede resolver correctamente la localización de las clases. Un caché corrupto también causa errores de compilación relacionados con librerías. Y es así como a veces NetBeans se comporta de forma extraña, "se marea" como decimos aquí, es por ello que se recomienda borrar el cache cuando estos problemas ocurran.

¿Como borrar el cache de Netbeans?

Las siguientes instrucciones son válidas para Netbeans 7.2 y  superior

1. Localiza el directorio de cache, ir a Ayuda, y luego en Acerca De

2. Cerrar Netbeans
3. Renombrar el directorio cache
4. Iniciar Netbeans
5. Una vez que inicie, se habrá creado un nuevo directorio de cache
6. Después que Netbeans haya iniciado de forma exitosa, borrar el directorio renombrado

Deployar Petstore en Java EE 6 con JBoss AS 7 mas Netbeans 8.1

Sun llegó a crear una aplicación web llamada Java Petstore, esta aplicación fue diseñada para mostrar como la tecnología J2EE(Java Enterprise Edition 2) podía ser empleada para desarrollar una aplicación web eCommerce. Sí, el objetivo de Petstore es vender mascotas en linea.

La aplicación Petstore llegó a ser tan popular, pero en esos tiempos, la versión J2EE era muy compleja, muchos archivos de configuración, muchas interfaces por implementar y usaba muchos patrones de diseños que hoy están obsoletos.

En 2013 cuando quise aprender Java JEE 5 encontré una adaptación de la aplicación Petstore para Java EE 5, YAPS Petstore, desarrollado por un arquitecto Francés de nombre Antonio Goncalves, traté de estudiar el código de la aplicación pero habían tantas tecnologías involucradas y lo complejo que eran termino por decantarme.

Este año retomé mi curso de Java EE 6, y buscando libros me entero que Antonio Goncalves ha escrito varios libros entre ellos uno para Java EE 6, y como era de suponer, ha realizado una actualización de la aplicación Petstore, en donde podemos observar el uso de nuevos patrones y APIs. Las tecnologías incluidas en la aplicación YAPS Petstore son: CDI, EJB Lite, REST interface, Bean Validation.

El objetivo de esta aplicación es:

• Usar Java EE 6 y sólo Java EE: Ningún framework externo o dependencia, incluso usa la API java.util.logging
• Mantenerlo simple: Ningún algoritmo de negocio complejo, aun así usa la mayoría de las APIs de Java EE 6, el punto es llevar la tecnología Java EE 6 en una aplicación web eCommerce.

Prerrequisitos
Java EE 6 o Java EE 7
JBoss AS 7.1.1 Final
Netbeans 8.1

Si tienes dudas con la instalación y configuración de JBoss, te recomiendo revisar mi entrada anterior

http://marcosrobertos.blogspot.com/2017/08/instalar-jboss-as-7-en-windows.html

Obteniendo y configurando el proyecto

Lo primero que haremos es obtener el código fuente desde github, lo podemos clonar o descargar, yo preferí clonarlo.

https://github.com/agoncal/agoncal-application-petstore-ee6

Abrimos el IDE Netbeans y abrimos el proyecto

Agregamos el servidor JBoss AS 7 a los servidores de Netbeans

Configurando el Data Source con MySQL

Lo primero es crear la base de datos en MySQL, yo he creado la base de datos con el nombre agoncal_petstore

Luego debemos configurar nuestro datasource en el archivo standalone.xml de JBoss,  localizado en  $JBOSS_HOME\standalone\configuration

Para definir un DataSource agregar el siguiente fragmento de xml

                
   <datasource jndi-name="java:jboss/datasources/PetStoreDS" pool-name="PetStoreDS">
      <connection-url>jdbc:mysql://localhost:3306/agoncal_petstore</connection-url>
      <driver>mysql</driver>
            <security>
               <user-name>root</user-name>
               <password>XXXXXXXXX</password>
            </security>
   </datasource>

Configurando el archivo persistence.xml
La aplicación YAPS Petstore viene configurado para una base de datos Derby, modificaremos nuestra configuración que se encuentra en el archivo persistence.xml
Agregar la siguiente linea

<jta-data-source>java:jboss/datasources/PetStoreDS</jta-data-source>

Comentamos las lineas

<!--<jta-data-source>java:global/jdbc/applicationPetstoreDS</jta-data-source> -->

<!--<property name="hibernate.dialect" value="org.hibernate.dialect.DerbyTenSevenDialect"/>-->

Nota: Guarda los cambios

Por último, editar la clase org.agoncal.application.petstore.service.DBPopulator y comentar la definición del DataSource

//@DataSourceDefinition(
//        className = "org.apache.derby.jdbc.EmbeddedDataSource",
//        name = "java:global/jdbc/applicationPetstoreDS",
//        user = "app",
//        password = "app",
//        databaseName = "applicationPetstoreDB",
//        properties = {"connectionAttributes=;create=true"}
//)


Ahora sí, ejecutamos el proyecto (Run), nos pedirá elegir el servidor.