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...

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 

Maven Guia para instalar dependencias en el repositorio local de Maven

Cualquier jar que necesitemos en nuestro proyecto java construido y gestionado con Maven, será considerado como una dependencia. Estas dependencias no siempre se encontrarán en el Repositorio remoto de Maven. Algunas dependencias serán de terceros, que si bien fueron construidos con Maven, estás no se encontrarán en el repositorio Remoto. Peor aun, algunos jars ni siquiera serán construidos con Maven, ya que muchas empresas aun usan Ant, o puede que el jar sea de un proyecto legacy que fue desarrollado cuando no existía Maven.

Ya viví esta situación en la empresa, estoy iniciando un nuevo proyecto web, y para mayor comodidad estoy usando Maven para la construcción y gestión del proyecto, este proyecto usará otros proyectos desarrollados en la empresa. Proyectos que son gestionados con Ant y que por esta razón no siguen el estándar de Maven, es decir, no tienen un archivo POM, no se encuentran en un Repositorio Maven, ni local ni remoto. Y es así como surge la pregunta, como agrego estos jars a la lista de dependencias en mi POM.

Pues me puse a investigar y aquí les comparto una guía, vamos abordar los distintos escenarios. Esta guía esta probada para Windows.

1.- Instalar un jar como dependencia en el Repositorio local Maven

Desde luego, estoy asumiendo que tienes Maven instalado y configurado correctamente. Si no, te sugiero leer la entrada Instalar Maven

Abrimos una consola de comandos en Windows y vamos hasta el directorio donde se encuentra nuestro jar.

Ejecutamos lo siguiente

mvn install:install-file -Dfile="nombre-jar.jar" -DgroupId=com.macrob.proyecto -DartifactId=nombre-proyecto -Dversion=1.0 -Dpackaging=jar

Donde nombre-jar será el nombre del jar a instalar, y el resto de atributos son los atributos conocidos de una dependencia Maven.

Después de ejecutar este comando, si vamos nuestro directorio .m2 dentro del directorio de nuestro usuario Windows, y luego entramos a repository, y siguiendo la ruta según el groupId, vamos a ver que tenemos instalado nuestro jar junto con el archivo pom.xml y otros archivos metadatos.

Ahora sí, ya podemos agregar esta dependencia al proyecto que lo requiera, usaremos los datos (groupId, artifactId, version y packaging) usados en la instalación de la dependencia.

Continuara...

Guia Rapida de Maven

Esta es una guía practica de iniciación para Maven, aprenderemos lo esencial de Maven para empezar a usarlo cuando antes, está guía no pretende profundizar en todas las funcionalidades de Maven, solo veremos lo esencial.

¿Que es Maven?

El ciclo de vida de construcción en Maven

Repositorios Maven

El archivo pom.xml de Maven

Dependencias en Maven

Plugins en Maven

Estructura de un proyecto Maven

Agregando directorios al classpath

Maven Instalar dependencias localmente

1. El ciclo de vida de construccion en Maven

Maven usa el concepto build lifecycle, este concepto indica que el proceso de construcción y distribución de un artefacto(proyecto) está claramente definido.

Para la persona que necesita construir un proyecto, esto significa que solo se requiere aprender unos cuantos comandos para construir cualquier proyecto Maven. Maven define una serie de convenciones y reglas. Desde la estructura de un proyecto hasta los pasos de construcción. Maven las define para que podamos construir nuestro proyecto con el minimo de configuraciones y de forma facil.

Maven viene integrado con tres lifecycles: default, clean y site. El lifecycle default maneja el despliegue de tu proyecto, el lifecycle clean maneja limpiezas del proyecto mientras que el lifecycle site maneja la creación de los sitios de documentación de tu proyecto.

Cada uno de estos lifecycle está compuesto por una lista de build phases, un buid phase se define como una etapa en el lifecycle.

Por mencionar los más importantes, el lifecycle default comprende las siguientes build phases:

• validate - Valida que el proyecto esta correcto y toda la información requerida está disponible
• compile - Compila el codigo fuente del proyecto.
• test - Prueba el codigo fuente compilado usando un framework de testing unitario.
• package - Toma el código fuente compilado y lo empaqueta dentro de un formato distribuible, tal com JAR o WAR.
• verify - Ejecuta algunas verificaciones sobre los resultados de pruebas de integración para asegurar que pasen los criterios de calidad.
• install - Instala el package (jar) en el repositorio local, para que sea usado como dependencia en otros proyectos localmente.
• deploy - Se realiza en el ambiente de producción, copia el package final al repositorio remoto para ser compartido con otros desarrolladores y proyectos.

Estas phases son ejecutadas secuencialmente y en el orden mencionado.

En un ambiente de desarrollo, si queremos instalar nuestro artefacto en el repositorio local ejecutaremos el siguiente comando:

mvn install

Este comando ejecuta cada una de las phases del lifecycle default en el orden (validate, compile, test, package, etc,.), hasta ejecutar la phase install. Es decir, solo necesitas llamar a la ultima phase que necesitas.

2.- Repositorios Maven
Un repositorio es el lugar donde los artefactos (jar, war, ear) construidos son almacenados. Hay dos tipos de repositorios, local y remoto. Los repositorios locales están en el directorio del usuario del sistema, más especifico, en Windows la ruta por defecto es "C:\Users\{usuario}\.m2\repository". En este directorio se almacena una copia de todos los archivos que son usados en nuestro proyecto como dependencias. El repositorio remoto se encuentra en un servidor remoto conectado a la red Internet, este es gestionado por un tercero. El repositorio remoto mas conocido es el del propio maven. La URL del repositorio central de Maven se encuenta en http://www.mvnrepository.com, pos si quieres curiosear un rato.

3.- El archivo pom.xml de Maven
Este archivo es el equivalente al archivo build.xml de ANT. El archivo pom.xml de Maven contiene las configuraciones para construir y gestionar un proyecto. Basicamente aquí se definen las propiedades del proyecto, las dependencias del proyecto(librerias jars de terceros o propios) y los plugins de maven a ejecutar.

Un pom debe tener al menos la siguiente información

• modelVersion
• groupId
• artifactId
• version

Aquí un ejemplo sencillo de un archivo pom.xml

<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> <modelversion>4.0.0</modelVersion> <groupid>com.macrob</groupId> <artifactid>java-ee-course</artifactId> <version>1.0-SNAPSHOT</version> <packaging>war</packaging> <name>java-ee-course</name> <properties> </properties> <dependencies> </dependencies> <build> <plugins> </plugins> </build> </project>

Generalmente no vas a crear este archivo desde cero, para eso maven te proporciona artefactos (plantillas), tu trabajo se enfocará en agregar las dependencias que necesites.

4.- Dependencias Maven
Dependencias son aquellas liberias (jars) externas que nuestro proyecto requiere, por ejemplo el famoso Log4J, libreria para escribir registros. Toda dependencia que nuestro proyecto requiera debe ser declarado en nuestro POM (pom.xml). Maven buscará estas dependencias en nuestro repositorio local, si no los encuentra entonces los descargará desde el repositorio remoto y los guardará en el repositorio local. Para agregar una dependencia tenemos un elemento disponible, el elemento dependency. Aquí un ejemplo las dependencias que tengo en mi proyecto.

<dependencies> <dependency> <groupid>log4j</groupId> <artifactid>log4j</artifactId> <version>1.2.17</version> <type>jar</type> </dependency> <dependency> <groupid>com.sun.faces</groupId> <artifactid>jsf-api</artifactId> <version>${jsf.version}</version> </dependency> <dependency> <groupid>com.sun.faces</groupId> <artifactid>jsf-impl</artifactId> <version>${jsf.version}</version> </dependency> <dependency> <groupid>org.primefaces</groupId> <artifactid>primefaces</artifactId> <version>5.2</version> <type>jar</type> </dependency> <!-- <dependency> <groupid>org.primefaces.themes</groupId> <artifactid>bluesky</artifactId> <version>1.0.10</version> </dependency> --> <dependency> <groupid>javax</groupId> <artifactid>javaee-web-api</artifactId> <version>6.0</version> <scope>provided</scope> </dependency> </dependencies>
Generalmente para agregar una dependencia lo primero será asegurarnos que se encuentra en el repositorio central de Maven, definirlo en el POM incluyendo el groupId, artifactId, version, type y scope. Lo que yo hago es buscar el artifactId en el repositorio centrar de Maven, copiar la porcion del xml y pegarlo en mi POM.
Por ejemplo para log4j

Los elementos groupId, artifactId y version, se entienden por si solos, te explico los otros dos elementos.

• type: El tipo de empaquetado que usa la dependencia, generalmente esto lo sabes por el tipo de extensión de la dependencia; jar, war o ear. No siempre el tipo corresponde a la extensión, pero si en su mayoria.
• scope: Este elemento se refiere al contexto del uso de la dependencia en relación con el classpath, es decir, se desea usar la dependencia en compilacion, en tiempo de ejecución o en testing. Hay cinco tipos de scope disponibles, pero las mas usadas son:
• compile: Es el scope usado por defecto, en caso de que no se especifique alguno.Dependencias con scope compile son agregados al classpath, es más, estás dependencias son propagadas a proyectos dependientes.
• runtime: Dependencias con scope runtime no son requeridas para la compilación, pero si para la ejecución.
• test: Dependencias con scope test no son requeridas para uso normal de la aplicacion, sólo están disponibles para la fase de pruebas y ejecución.

5.- Plugins en Maven
Todo proceso en Maven es realizado por plugins. Un plugin es mapeado y ejecutado como una phase. Una phase es mapeada a multiple objetivos. Estos objetivos son ejecutados por el plugin. Nosotros podemos invocar explicitamente un objetivo cuando ejecutamos Maven.
Un plugin muy usado es el plugin 'compiler', este plugin es el encargado de compilar el codigo fuente Java. El plugin compiler tiene dos objetivos, compiler:compiler y compiler:testCompile.
Usando el elemento configuration, podemos pasar parametros al plugin. Aquí podemos ver una poción de mi pom.xml que usa plugins.

<build> <plugins> <plugin> <groupid>org.apache.maven.plugins</groupId> <artifactid>maven-compiler-plugin</artifactId> <version>2.3.2</version> <configuration> <source>1.6</source> <target>1.6</target> <compilerarguments> <endorseddirs>${endorsed.dir}</endorseddirs> </compilerArguments> </configuration> </plugin> <plugin> <groupid>org.apache.maven.plugins</groupId> <artifactid>maven-war-plugin</artifactId> <version>2.1.1</version> <configuration> <failonmissingwebxml>false</failOnMissingWebXml> </configuration> </plugin> <plugin> <groupid>org.apache.maven.plugins</groupId> <artifactid>maven-dependency-plugin</artifactId> <version>2.1</version> <executions> <execution> <phase>validate</phase> <goals> <goal>copy</goal> </goals> <configuration> <outputdirectory>${endorsed.dir}</outputDirectory> <silent>true</silent> <artifactitems> <artifactitem> <groupid>javax</groupId> <artifactid>javaee-endorsed-api</artifactId> <version>6.0</version> <type>jar</type> </artifactItem> </artifactItems> </configuration> </execution> </executions> </plugin> </plugins> </build>

Para proyectos básicos no necesitas agregar explicitamente los plugins, mas adelante veremos los arquetipos, ellos se encargan de agregar los plugins necesarios.

6.- Estructura de un proyecto en Maven
Maven tiene bien definido una convención para la estructura de directorios de un proyecto. Si seguimos está convención no necesitaremos configuraciones adicionales para definir donde están localizados los elementos. Maven conoce donde se encruenta el código fuente, casos de pruebas, recursos, etc,. Para conocer un poco más veamos la estructura de un proyecto web.

Las carpetas más importantes son: src, resources, webapp, test, target.

De nuevo, para proyectos básicos no necesitas crear explicitamente el directorio, Maven o hace por tí

7.- Archetype en Maven

En Maven tenemos los 'Archetype' o arquetipos, los arquetipos son como plantillas para crear proyectos. Maven proporciona estas plantillas para iniciar un proyecto, usando arquetipos podemos iniciar rapidamente un proyecto Maven. Los arquetipos definen la estructura de directorios de nuestro proyecto, definen los plugins a usar, definen las dependencias. Más especifico, ademas de definir la estructura de directorios también definen un pom.xml.

8.- Creando nuestro primer proyecto en Maven

Ahora si, vamos a crear nuestro primer proyecto Maven, asumiendo que tienes Maven instalado correctamente. 

Lo primero que haremos será abrir una ventana de comandos, navegar hasta el directorio donde queremos crear el proyecto, luego ejecutar el siguiente comando:

mvn archetype:generate -DgroupId=com.macrob.sample -DartifactId=first-mavenapp -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

Donde

• -DgroupId: Es la combinacion de la organización y producto.
• -DartifactId: El nombre del artefacto, o el nombre del jar. Este nombre es también usado para nombrar el directorio raiz del proyecto.
• -DarchetypeArtifactId: El arquetipo a usar

 

Lo que hemos hecho es crear un proyecto vacío, un proyecto con una estructura de directorios definido, en donde podemos ir agregando clases, recursos, etc,. Ademas de la estructura de directorios, también tenemos un archivo pom.xml dentro del directorio raiz del proyecto creado,en el pom.xml podemos ir agregando dependencias. Este es un proyecto estandard, si necesitas un proyecto para una aplicación web, necesitas ejecutar un arquetipo para un proyecto web.

Para finalizar, vamos a crear el jar de nuestro proyecto, si lo unico que quiero es generar el jar, vamos a ejecutar el build phase package  

mvn package

Si entras al directorio target vas a ver un jar con el nombre first-mavenapp-1.0-SNAPSHOT.jar

Si necesitas instalar este artefacto en tu repositorio local, solo tienes que ejecutar el build phase install

mvn install

9. Agregando directorios al classpath de Java

Agregar directorios al classpath de Java es otra actividad escencial en Java, recuerda que los directorios que se agregan al classpath en su mayoría se necesitan en tiempo de ejecución.

<build> <resources> <resource> <directory>src/main/locales</directory> </resource> <resource> <directory>src/main/reports</directory> </resource> </resources> </build>

El directorio se agrega como un recurso dentro de la lista de cursos en la sección build. La ruta es relativa al archivo pom.xml

Referencia

https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

https://maven.apache.org/guides/getting-started/maven-in-five-minutes.html

Maven: Que es?

Introducción

Hace ya un par de meses que decidí estudiar la plataforma JEE, la mayoría de los tutoriales que hay en la web están basados en Maven, la mayoría de esos ejemplos no funcionan a la primera ya que los archivos de configuración de Maven pueden estar obsoletos, diferencias entre el ambiente,distinto IDE, diferentes versiones de los componentes, y así. Hay que tener conocimientos sólidos en Maven para adaptar los tutoriales a nuestro ambiente particular.

Es así que decidí estudiar Maven a profundidad, hay un buen número de tutoriales y referencias en la web en español, pero no encontré uno escrito a profundidad, que explique con lujo de detalle todos los conceptos. He obtenido un libro muy completo de Maven, está en ingles, trataré de traducirlo para tenerlo como guía y aprender todos los conceptos de Maven.

¿Qué es Maven?

La respuesta a esta pregunta depende de quien lo pregunte, la mayoría de los usuarios que usan Maven lo consideran cómo una "herramienta build": herramienta usada para compilar, empaquetar y distribuir módulos desde el código fuente. Ingenieros y gerentes de proyectos podrían referirse a Maven cómo algo más completo: una herramienta de gestión(administración) de proyectos. ¿Cual es la diferencia? Una herramienta build como Ant, está enfocado exclusivamente en pre procesar, compilar, empaquetar, probar y distribuir. Una herramienta de gestión de proyectos cómo Maven proporciona un amplio conjunto de características encontrados en una herramienta build, es decir, es una herramienta build y algo más. Además de ser una herramienta build, Maven también puede generar distintos tipos de reportes, generar sitios web, y facilitar la comunicación entre miembros de un equipo de desarrollo.

Una definición más formal de Apache Maven: Maven es una herramienta de gestión de proyectos, que incluye un pom (Project Object Model) el modelo de objetos del proyecto, un conjunto de estándares, un ciclo de vida del proyecto, un sistema de gestión de dependencias, y lógica para ejecutar plugins en las fases del ciclo de vida. Cuando tu usas Maven, tu describes tu proyecto usando un pom definido correctamente, después Maven aplicará lógica de forma transversal (profundidad máxima para cada objeto) al conjunto de plugins compartidos o personalizados. Más adelante veremos que son los plugins.

No dejes que te intimide el hecho de que Maven sea una herramienta de gestión de proyectos. Si sólo estabas buscando una herramienta build, Maven puede hacer el trabajo. De hecho. los primeros artículos de este libro cubrirán la mayoría de los casos de usos comunes: usando Maven para construir y distribuir tu proyecto.

Convención Sobre Configuración

Convención sobre Configuración, también conocido como CoC es un concepto simple que busca minimizar el número de decisiones que un desarrollador necesita hacer, ganando así en simplicidad pero no perdiendo flexibilidad por ello.

Frameworks populares como Ruby on Rails y EJB3 han comenzado a adquirir estos principios como respuesta a la complejidad de los frameworks, tal como es el caso de la especificación inicial EJB 2.1. Para ilustrar el concepto de Convención sobre Configuración, considere la persistencia en EJB3: todo lo que necesitas hacer para tener un bean persistente es agregar a tu clase la anotación @Entity. El framework asume que el nombre de la tabla y columnas están en base al nombre de la clase y sus atributos. Sin embargo tu puedes sobreescribir estos nombres en caso de ser necesario, pero en la mayoría de los casos encontrarás que usar el framework con sus configuraciones por defecto te permitirá una rápida ejecución del proyecto.

Maven incorpora este concepto proporcionando configuraciones y comportamientos por defecto para los projectos. Sin ninguna configuración, se asume que el código fuente estará en ${basedir}/src/main/java y se asume que los recursos estarán en ${basedir}/src/test, y se asume que un proyecto generará un archivo JAR. Maven asume que tu quieres el código byte compilado en ${basedir}/target/classes y entonces crear en ${basedir}/target un archivo JAR para distribuir. Mientras esto puede parecer trivial, considera el hecho de que en Ant se tiene que definir la ubicación de todos estos directorios. Ant no tiene idea de donde pueden estar el código fuente o los recursos en un proyecto. Tu tienes que proporcionar explicita mente esta información. La adopción del concepto Convención sobre configuración de Maven, va más allá de simple ubicaciones de directorios. Los plugins principales de Maven aplican un conjunto común de convenciones para compilar código fuente, empaquetar distribuciones, generar sitios web, y muchos otros procesos. Si tu sigues las convenciones, Maven requerirá esfuerzos mínimos, sólo coloca el código fuente en el directorio correcto y Maven se encargará del resto.

Un efecto secundario de usar sistemas que siguen el concepto de "Convención sobre Configuración" es que el usuario final puede sentir que está siendo forzado a usar un enfoque o metodología particular. Si bien es cierto que Maven tiene algunas opiniones bases que no deberían ser desafiadas, la mayoría de las características que vienen por defecto pueden ser personalizados. Por ejemplo, la ubicación  del código fuente de un proyecto y la ubicación de los recursos, estos pueden ser personalizados, los nombres de los archivos JAR también pueden ser personalizados, . Si no quieres seguir la convención, Maven te permitirá adaptar las características por defecto con tal de adaptarlos a tus requerimientos específicos.


Referencia:
Maven: The complete Reference, Sonatype, http://www.sonatype.org/nexus/resources/resources-book-links-and-downloads/