Proyecto JSF 2 utilizando MyFaces con Eclipse y Maven

JSF 2.2 con MyFaces utilizando Maven (Lectura - Guía de Trabajo)

Maven

No existe motivos para no utilizar maven o alguna otra herramienta similar como Ivy,Gradle, etc para la construcción de un proyecto en Java, elegimos Maven por ser el más popular.

Maven Referencia(Wikipedia)

Maven es una herramienta de software para la gestión y construcción de proyectos Java creada por Jason van Zyl, de Sonatype, en 2002. Es similar en funcionalidad a Apache Ant (y en menor medida a PEAR de PHP y CPAN de Perl), pero tiene un modelo de configuración de construcción más simple, basado en un formato XML. Estuvo integrado inicialmente dentro del proyecto Jakarta pero ahora ya es un proyecto de nivel superior de la Apache Software Foundation.

Maven utiliza un Project Object Model (POM) para describir el proyecto de software a construir, sus dependencias de otros módulos y componentes externos, y el orden de construcción de los elementos. Viene con objetivos predefinidos para realizar ciertas tareas claramente definidas, como la compilación del código y su empaquetado.

Una característica clave de Maven es que está listo para usar en red. El motor incluido en su núcleo puede dinámicamente descargar plugins de un repositorio, el mismo repositorio que provee acceso a muchas versiones de diferentes proyectos Open Source en Java, de Apache y otras organizaciones y desarrolladores. Este repositorio y su sucesor reorganizado, el repositorio Maven 2, pugnan por ser el mecanismo de facto de distribución de aplicaciones en Java, pero su adopción ha sido muy lenta. Maven provee soporte no sólo para obtener archivos de su repositorio, sino también para subir artefactos al repositorio al final de la construcción de la aplicación, dejándola al acceso de todos los usuarios. Una caché local de artefactos actúa como la primera fuente para sincronizar la salida de los proyectos a un sistema local.

Convención sobre configuración

La filosofía general de Maven es la estandarización de las construcciones generadas por seguir el principio de Convención sobre Configuración, a fin de utilizar existentes modelos en la producción de software. Esta estrategia necesariamente restringe ampliamente la variabilidad, lo que se refleja en la exhortación de Maven a adherirse a su modelo de proyecto.³ Mientras que Maven es adecuado para nuevos proyectos, los proyectos complejos ya existentes pueden ser simplemente no adaptables para que utilicen Maven. La falta de restricciones de la convención de capas del proyecto fue hecha de alguna manera más configurable con el lanzamiento de Maven 2.

Reutilización

Maven está construido alrededor de la idea de reutilización, y más específicamente, a la reutilización de la lógica de construcción. Como los proyectos generalmente se construyen en patrones similares, una elección lógica podría ser reutilizar los procesos de construcción. La principal idea es no reutilizar el código o funcionalidad (como Apache Ant), sino simplemente cambiar la configuración o también código escrito. Esa es la principal diferencia entre Apache Ant y Apache Maven: el primero es una librería de utilidades y funciones buenas y útiles, mientras que la otra es un framework configurable y altamente extensible.⁴

Aunque Maven es configurable, históricamente el proyecto Maven ha enfatizado seriamente que los usuarios deben adherirse a su concepto de un modelo de proyecto estándar tanto como sea posible.

Ciclo de vida

Las partes del ciclo de vida principal del proyecto Maven son:

1. compile: Genera los ficheros .class compilando los fuentes .java
2. test: Ejecuta los test automáticos de JUnit existentes, abortando el proceso si alguno de ellos falla.
3. package: Genera el fichero .jar con los .class compilados
4. install: Copia el fichero .jar a un directorio de nuestro ordenador donde maven deja todos los .jar. De esta forma esos .jar pueden utilizarse en otros proyectos maven en el mismo ordenador.
5. deploy: Copia el fichero .jar a un servidor remoto, poniéndolo disponible para cualquier proyecto maven con acceso a ese servidor remoto.

Cuando se ejecuta cualquiera de los comandos maven, por ejemplo, si ejecutamos mvn install, maven irá verificando todas las fases del ciclo de vida desde la primera hasta la del comando, ejecutando sólo aquellas que no se hayan ejecutado previamente.

También existen algunas metas que están fuera del ciclo de vida que pueden ser llamadas, pero Maven asume que estas metas no son parte del ciclo de vida por defecto (no tienen que ser siempre realizadas). Estas metas son:

1. clean: Elimina todos los .class y .jar generados. Después de este comando se puede comenzar un compilado desde cero.
2. assembly:assembly: Genera un fichero .zip con todo lo necesario para instalar nuestro programa java. Se debe configurar previamente en un fichero xml qué se debe incluir en ese zip.
3. site: Genera un sitio web con la información de nuestro proyecto. Dicha información debe escribirse en el fichero pom.xml y ficheros .apt separados.
4. site-deploy: Sube el sitio web al servidor que hayamos configurado.
5. etc.

Pero estas metas pueden ser añadidas al ciclo de vida a través del Project Object Model (POM).

Fuente: Wikipedia

Crear Proyecto Maven con Eclipse

Utilizaremos Eclipse EE como IDE para hacer el ejemplo de nuestro proyecto JSF

File -> New -> Project

Importar dependencias de JSF

JSF no forma parte del Developer KIT o API básico de instalación, para poder ligar y relacionar las clases e interfaces de JSF necesitamos las librerias de JSF, podemos descargar y relacionar las librerías al proyecto o utilizar MAVEN y de manera descriptiva agregar la dependencia.

MyFaces - Implementación de JSF

JSF es una especificación, y existen diferentes Implementaciones que cumplen con la especificación. Utilizaremos Apache MyFaces por ser una de las más populares

<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.roshka</groupId>
 <artifactId>tutorial.myfaces</artifactId>
 <version>1.0.0</version>
 <packaging>war</packaging>


 <dependencies>
  <dependency>
   <groupId>org.apache.myfaces.core</groupId>
   <artifactId>myfaces-api</artifactId>
   <version>2.2.0</version>
  </dependency>
  <dependency>
   <groupId>org.apache.myfaces.core</groupId>
   <artifactId>myfaces-impl</artifactId>
   <version>2.2.0</version>
  </dependency>
 </dependencies>
</project>

Importar depedencias de Servlet API

El API de Servlet tampoco forma parte del API Standard de JAVA y debemos agregar la dependencia para poder Compilar.

                <dependency>
   <groupId>org.apache.tomcat</groupId>
   <artifactId>tomcat-coyote</artifactId>
   <version>7.0.47</version>
   <!-- provided no empaqueta la libreria utilizará una provista por el contenedor -->
   <scope>provided</scope>
  </dependency>

Configurar Faces Servlet

Para agregar JSF a un proyecto JSF se agrega un Servlet que actuará como Controlador, el FacesServlet. Este Servlet se encargará de procesar el Request y preparar el Response adecuado, Invocará los métodos necesarios para ir paso a paso en cada Etapa o Fase del JSF (Como vimos en el Ciclo de Vida de JSF) y terminar siempre en la Fase 6 o Fase de Render. 

Invocará los métodos Setters y Getters de los Managed Bean necesarios y ejecutará los métodos actions que correspondan para el Request.

Una página o Interfáz JSF es expresada como XHTML o JSP y es procesada como Facelets.

El Servlet es configurado en el archivo web.xml dentro de la carpeta WEB-INF

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee"
 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>FacesServlet</servlet-name>
  <servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
 </servlet>

</web-app>

Configurar Faces Servlet Mapping

Una vez definido el Servlet es necesario configurar en la aplicación reglas que se utilizarán para que el Contenedor de Servlets pueda identificar si corresponde o no que el Faces Servlet procese un Request.

Para eso se configuran reglas de Mapeos típicamente los FacesServlet procesan /faces/* o *.jsf lo que implica que todos los Requests que tengan URIs que cumplan con ese patrón serán procesados por el Faces Servlet.

Además configuramos un parámetro adicional para notificar al Servlet que vamos a estar en un ambiente de Desarrollo.

<!-- procesar todos los URI que empiecen con /faces ejemplo /faces/index.xhtml -->
 <servlet-mapping>
  <servlet-name>FacesServlet</servlet-name>
  <url-pattern>/faces/*</url-pattern>
 </servlet-mapping>
 <!-- Parámetro adicional para informar que nuestro ambiente es de Desarrollo -->
 <!-- Importante quitar el parámetro cuándo se pase a Producción -->
 <context-param>
  <param-name>javax.faces.PROJECT_STAGE</param-name>
  <param-value>Development</param-value>
 </context-param>

Configurar Faces Config

Una vez configurado el Faces Servlet, éste necesita de alguna configuración adicional para poder funcionar. Esta configuración puede ser:

• Información de Locale (Localidad)
• Mensajes
• Managed Beans (Se pueden utilizar con anotaciones JAVA en lugar del XML)
• Registro de Validadores JSF
• Registro de Convertidores JSF
• Reglas de Navegación
• Resolvers *
• Manged Properties (Inyección de Propiedades de Beans)
• Kit Renderer  *

Esta configuración puede estar ubicada en el archivo faces-config.xml dentro de la carpeta WEB-INF

<?xml version="1.0"?>
<faces-config 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-facesconfig_2_0.xsd"
 version="2.0">
 <application>
  <locale-config>
   <!-- especificamos que nuestro formateo debe ser de Paraguay, 
    ej: separador de miles, Hora etc. -->
   <default-locale>es_PY</default-locale>
  </locale-config>
 </application>
</faces-config>

Crear nuestro Primer JSF

Una Interfáz JSF se define o expresa en una Página Facelets, similar a un JSP utilizando librerías de Etiquetas de JSF (Core, HTML y adicionales)

<?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://java.sun.com/jsf/html"
 xmlns:f="http://java.sun.com/jsf/core">

<h:head>
 <title>Welcome</title>
</h:head>

<h:body>
 <div class="container">
  <div class="row">
   <div class="col-md-6">
    <h:form styleClass="horizontal-form">
     <h:outputText value="#{miBean.mensaje}"></h:outputText>
     <h:commandButton value="Ejecutar" action="#{miBean.accion}"
      styleClass="btn btn-sm btn-primary" />
    </h:form>
   </div>
  </div>
 </div>
</h:body>
</html>

Crear nuestro Primer Managed Bean

Managed Bean son Componentes Java (Bean) que representan el Estado,  manejan los Eventos y tienen los métodos de Acción a ser ejecutados de una Interfaz JSF (Un Managed Bean puede manejar varias interfaces y una Interfaz puede utilizar varios Managed Beans)

Para eso necesitamos Crear una Clase Java y convertirla en Bean:

Un Bean es una Clase Java que debe tener un Constructor vacio () y sus propiedades pueden ser accedidas por métodos GET y sus propiedades pueden ser modificadas por métodos SET

En el ejemplo crearemos un Bean Simple con una propiedad y un método Acción para ser invocado

package com.roshka.tutorial.jsf;

import javax.faces.bean.ManagedBean;
import javax.faces.view.ViewScoped;

@ManagedBean
@ViewScoped
public class MiBean {
 // propiedad
 private String mensaje;

 // constructor vacio
 public MiBean() {
  // TODO Auto-generated constructor stub
 }

 // método GET para acceder
 public String getMensaje() {
  return mensaje;
 }

 // método SET para escribir
 public void setMensaje(String mensaje) {
  this.mensaje = mensaje;
 }

 // método a ser ejecutado en Fase 5
 public String accion() {
  mensaje = "Mostrar mensaje en Formulario JSF";
  return null;
 }

}

Hacer Despliegue en Contenedor de Servlets Tomcat

Integrar Tomcat en Eclipse

Buscamos la Pestaña de Servidores (Window -> Show View -> Server)

Despliegue de Proyecto en Eclipse

Click derecho en Tomcat para agregar proyectos al Servidor

Ya está adherido

Click derecho en Server Tomcar y le damos Start para arrancar

Si no hay ni un Problema vemos este mensaje

Probar nuestro Ejemplo

Abrimos el Browser de nuestra preferencia

y si tenemos un Tomcat configurado por Defecto abrira un proceso que escuchará en el Puerto 8080

entonces abriremos la aplicación con
http://localhost:8080/tutorial.myfaces/faces/mi-primer-jsf.xhtml

Al dar Click en Ejecutar Debemos ver el siguiente mensaje

Conclusión:

1) Creamos un Proyecto JSF con las Librerías necesarias
2) Configuramos un Proyecto con los archivos web.xml y faces-config.xml
3) Definimos un pequeño ejemplo de Interfaz JSF con un xhtml y un Managed Bean con una propiedad y un Método Accion
4) Desplegamos y Probamos la aplicación en el TOMCAT