viernes, 21 de marzo de 2014

Componentes JSF



Componentes JSF

Componentes JSF

En Publicaciones anteriorer hablamos del ciclo de vida del JSF,  como crear un proyecto JSF y como hacer un ejemplo "Hola Mundo" con JSF.
Ahora "complicaremos un poco" más esto. enriqueciendo y haciendo interfaces gráficas Web más completas.
La Interfaz JSF típicamente se realiza programando o armando un Archivo llamado facelets, (puede ser un xhtml o un jsp), Es un documento XML estructurado donde por medio de etiquetas se va armando el formulario. JSF nos ofrece un conjunto de etiquetas de UI agrupadas en Bibliotecas. Donde cada etiqueta tiene alguna de característica que podemos dividir en estos grupos:
  • Inputs (Campos de Entrada)
  • Outputs (Salida)
  • Commands (Botones, UI de ejecución de Comandos)
  • Get Requests (Botones, Enlaces de Petición)
  • Selections (Campos de Chequeo, Listbox, menu, radio)
  • Html Pages (Head, Body, Form, CSS, Script)
  • Layouts (Paneles)
  • Datatable (Tabla de Datos)
  • Error and Messages
En el XML de acuerdo a la interfaz que se quiere realizar a partir del elemento raíz, se van agregando elementos. se puede representar como un Árbol
Core JSF - Geary

Cada uno de estas etiquetas están asociadas por una Clase Java que a su vez extiende de otra Clase Java, un componente UI de JSF extiende de la Clase UIComponent.html

El Elemento Nodo Raíz tambien es UIComponent tiene Clase UIViewRoot.html

A excepción del Nodo raiz(Árbol de UI), todos los otros elementos tiene un UIComponent Padre, y pueden tener muchos nodos hijos de clase UIComponent.

Como vemos en la imágen podemos tener un nodo Formulario, necesario para hacer un formulario y este va ser representado por uno de Clase UIForm y a este nodo le enriquecemos con componentes de clase UICommand e UIInput o UIOutput

Los UICommand e UIInput o UIOutput son Componentes de UI muy genéricos y podemos utilizar otros más específicos como (podemos ver que UIInput extiende de UIOutput )
De acuerdo a nuestras necesidades vamos a ir viendo todos los componentes que podemos ir utilizando, hay mucho material en la Web, y Tablas de Referencia.



Más Adelante iremos viendo que es y como escribir Expresiones EL de JSF, por el momento nos enfocaremos en entender el Árbol de JSF.

No todas las etiquetas son componentes de UI existen etiquetas que se utiliza como auxiliar para un componente de UI
Referencia de Biblioteca de Etiquetas que no son UI Components


En el ciclo de Vida de JSF, la primera fase es la de Restore View. En esta fase se obtiene el HttpServletRequest y se lee toda las información de Petición, URI, Método, Parámetros, Información de Cabecera y  a partir de eso se recupera una instancia de un Objeto UIViewRoot. Si es la primera vez crea una instancia a partir del procesamiento del Facelets con su/s respectivos ManagedBean. Ese procesamiento genera un Arbol que tiene como raíz el UIViewRoot. Se procesa cada etiqueta y se genera un UIComponent con las etiquetas de UI y se completa la información necesaria a partir de las etiquetas de la Biblioteca Core u otras Etiquetas que no son de UI.

Cuando se utiliza un componente es importante ir conociendo las propiedades que uno puede utilizar, las más comunes que uno utiliza serían:

Para los componentes que implementan ValueHolder (UIOutput y todas las clases que extienden de ésta) es importante la propiedad "value" donde uno asocia por medio de un expresión JSF el valor que se va ligar value="#{bean.proX.subPropiedad}", que significa este componente tendrá como valor el valor de la propiedad "subPropiedad" del Bean que es propiedad "propX" del Managed Bean de nombre "Bean", Tambien tienen como propiedad converter, que es la Clase Converter que se encargará de mapear de Objeto a String, y String a Objeto a esa Propiedad.

Binding es una propiedad de los Tags de JSF que se utiliza para modificar propiedades del UIComponent asociando a una propiedad del ManagedBean.

Otra propiedad importante es "rendered" que significa que se mostrará si la expresión contenida retorna true (Verdadero), Todas los componentes (UIComponent) tienen propiedad rendered.

De acuerdo a la tabla de Referencia podemos ir por ejemplo a SelectOneRadio




Ejemplo (Form - Model)

package com.roshka.tutorial.jsf;

import java.util.Date;

public class Form {
 private String name;
 private Date birthdate;
 private Integer id;
 private FormaPago formaPago;
 private boolean premium = false;

 public String getName() {
  return name;
 }

 public void setName(String name) {
  this.name = name;
 }

 public Date getBirthdate() {
  return birthdate;
 }

 public void setBirthdate(Date birthdate) {
  this.birthdate = birthdate;
 }

 public Integer getId() {
  return id;
 }

 public void setId(Integer id) {
  this.id = id;
 }

 public FormaPago getFormaPago() {
  return formaPago;
 }

 public void setFormaPago(FormaPago formaPago) {
  this.formaPago = formaPago;
 }

 public boolean isPremium() {
  return premium;
 }

 public void setPremium(boolean premium) {
  this.premium = premium;
 }

}

Ejemplo (FormPago - Model)

package com.roshka.tutorial.jsf;

import java.io.Serializable;
import java.util.ArrayList;
import java.util.List;

public class FormaPago implements Serializable {
 private int id;
 private String label;

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

 public FormaPago(int id, String label) {
  super();
  this.id = id;
  this.label = label;
 }

 public int getId() {
  return id;
 }

 public void setId(int id) {
  this.id = id;
 }

 public String getLabel() {
  return label;
 }

 public void setLabel(String label) {
  this.label = label;
 }
 @Override
 public boolean equals(Object obj) {
  FormaPago formaPago = (FormaPago) obj;
  if (formaPago == null)
   return false;
  return this.getId()==formaPago.getId();
 }

 static List formasPago = null;

 static List getFormasPago() {
  if (formasPago != null)
   return formasPago;

  formasPago = new ArrayList();
  formasPago.add(new FormaPago(1, "Contado"));
  formasPago.add(new FormaPago(2, "Crédito"));
  return formasPago;
 }

}

Ejemplo (Controller - FormManagedBean)


package com.roshka.tutorial.jsf;

import java.util.List;

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


@ManagedBean(name = "formBean")
@ViewScoped
public class FormManagedBean {
 private String message = null;
 private boolean edit = true;
 private Form form;
 private List formaPagos = null;
 {
  formaPagos = FormaPago.getFormasPago();
  form = new Form();
 }

 public FormManagedBean() {
  // TODO Auto-generated constructor stub
 }
 //accion modificar cliente
 public String edit() {
  message = String.format("Modificar {%s} {%s} {%s} {%s}", form.getId(),
    form.getName(), form.getBirthdate(),
    (form.getFormaPago() != null ? form.getFormaPago().getLabel()
      : "- No se seleccionó Forma de Pago -"));
  edit = true;
  return null;
 }
 //accion guardar bean

 public void save() {
  message = String.format("Se guardó {%s} {%s} {%s} {%s}", form.getId(),
    form.getName(), form.getBirthdate(),
    (form.getFormaPago() != null ? form.getFormaPago().getLabel()
      : "- No se seleccionó Forma de Pago -"));
  edit = false;
 }

 public Form getForm() {
  return form;
 }

 public void setForm(Form form) {
  this.form = form;
 }

 public List getFormaPagos() {
  return formaPagos;
 }

 public void setFormaPagos(List formaPagos) {
  this.formaPagos = formaPagos;
 }

 public boolean isEdit() {
  return edit;
 }

 public void setEdit(boolean edit) {
  this.edit = edit;
 }

 public String getMessage() {
  return message;
 }

 public void setMessage(String message) {
  this.message = message;
 }

}


Ejemplo (Converter - FormaPagoConverter)

package com.roshka.tutorial.jsf;

import javax.faces.component.UIComponent;
import javax.faces.context.FacesContext;
import javax.faces.convert.Converter;
import javax.faces.convert.FacesConverter;

@FacesConverter(value = "com.roshka.CountryConverter")
public class FormaPagoConverter implements Converter {

 public Object getAsObject(FacesContext facesContext,
   UIComponent uiComponent, String source) {
  if (source == null || source.length() == 0)
   return null;
  String[] str = source.split("#");
  FormaPago fp = new FormaPago();
  fp.setId(Integer.parseInt(str[0]));
  fp.setLabel(str[1]);
  return fp;
 }

 public String getAsString(FacesContext facesContext,
   UIComponent uiComponent, Object source) {
  FormaPago fp = (FormaPago) source;
  if (fp != null)
   return fp.getId()+"#"+fp.getLabel();
  return "";

 }
}

Ejemplo (View - customer.xhtml)

<html xmlns:f="http://java.sun.com/jsf/core"
 xmlns:h="http://java.sun.com/jsf/html"
 xmlns="http://www.w3.org/1999/xhtml">

<h:head>
 <title>Pago</title>
</h:head>

<h:body>
 <div class="container">
  <div class="row">
   <div class="col-md-6">
    <h:form styleclass="horizontal-form">
     <h:outputText value="Mensaje: #{formBean.message}"></h:outputText>

     <h:outputText
      rendered="#{formBean.form.premium and !formBean.edit}"
      style="background: red; border: 1px solid red; color: white;"
      value="El Cliente es Premium"></h:outputText>
     <h:panelGrid columns="2" rendered="#{!formBean.edit}">
      <h:outputLabel value="ID de Cliente"></h:outputLabel>
      <h:outputText value="#{formBean.form.id}"></h:outputText>
      <h:outputLabel value="Nombre de Cliente"></h:outputLabel>
      <h:outputText value="#{formBean.form.name}"></h:outputText>
      <h:outputLabel value="Fecha de Nacimiento de Cliente"></h:outputLabel>
      <h:outputText value="#{formBean.form.birthdate}">
       <f:convertDateTime pattern="dd/MM/yyyy"></f:convertDateTime>
      </h:outputText>
      <h:commandLink action="#{formBean.edit}" value="Modificiar"></h:commandLink>
     </h:panelGrid>

     <h:panelGrid columns="2" rendered="#{formBean.edit}">
      <h:outputLabel value="Id de Pago"></h:outputLabel>
      <h:inputText value="#{formBean.form.id}"></h:inputText>

      <h:panelGroup>
       <h:outputLabel value="Nombre de Cliente"></h:outputLabel>
       <h:inputText value="#{formBean.form.name}"></h:inputText>
      </h:panelGroup>
      <h:panelGroup>
       <h:outputLabel value="Fecha de Nacimiento de Cliente"></h:outputLabel>
       <h:inputText value="#{formBean.form.birthdate}">
        <f:convertDateTime pattern="dd/MM/yyyy"></f:convertDateTime>
       </h:inputText>
      </h:panelGroup>
      <h:outputLabel value="Plan Premium"></h:outputLabel>
      <h:selectBooleanCheckbox value="#{formBean.form.premium}"></h:selectBooleanCheckbox>
      <h:outputLabel value="Forma de Pago"></h:outputLabel>
      
      <h:selectOneMenu value="#{formBean.form.formaPago}" converter="com.roshka.CountryConverter">
       <f:selectItem value="#{null}" itemLabel="--- Seleccione forma Pago"></f:selectItem>
       <f:selectItems value="#{formBean.formaPagos}" var="item" itemValue="#{item}" itemLabel="#{item.label}"></f:selectItems>
      
      </h:selectOneMenu>
      

      <h:commandButton action="#{formBean.save}"
       styleclass="btn btn-sm btn-primary" value="Ejecutar">

      </h:commandButton>
     </h:panelGrid>
    </h:form>
   </div>
  </div>
 </div>
</h:body>
</html>

Ejemplo












miércoles, 12 de marzo de 2014

Bibliotecas JSF - Core y HTML


Etiquetas de JSF

JSF provee en su API un conjunto estándar de Bibliotecas de Etiquetas, para enriquecer o alimentar nuestra interfaz: Podemos alimentar nuestra interfaz con Paneles, Campos de Entrada, Campos de Salida, Grilla de Datos, etc.
  • Core
  • Html
  • Composite
JSF provee en su API, para en caso que estas librerías no alcance la necesidad, desarrollar bibliotecas adicionales con sus respectivas etiquetas.

Referencia de Bibliotecas Core, Composite y HTML de JSF

Bibliografía http://www.jsftoolbox.com/

Biblioteca Core

Es una biblioteca que contiene típicamente componentes no visuales y auxiliares, ejemplo asociar un convertidor a un Componente de UIInput

Tag NameDescriptionSince
f:actionListenerThe ActionListener tag registers a javax.faces.event.ActionListener instance with the component.
f:ajaxJSF2 standardizes Asynchronous Javascript and XML (Ajax) functionality across JSF component libraries and introduces the f:ajax tag to provide Ajax capabilities in a standard way.JSF 2.0
f:attributeThe Attribute tag is a name/value pair that sets the value of a named attribute on the component associated with the enclosing tag.
f:convertDateTimeThe ConvertDateTime tag is useful for converting a date into a human-readable format and supports a range of formatting options.
f:convertNumberThe ConvertNumber tag registers a NumberConverter instance on the component associated with the enclosing tag.
f:converterThe Converter tag registers a Converter instance on the component associated with the enclosing tag.
f:event[ Documentation pending ]JSF 2.0
f:facetThe Facet tag registers a named facet on the component associated with the enclosing tag.
f:loadBundleThe LoadBundle tag loads a resource bundle for the Locale of the current view and stores it as a Map in request scope.
f:metadata[ Documentation pending ]JSF 2.0
f:paramThe Param tag sets a parameter for the component associated with the enclosing tag.
f:phaseListener[ Documentation pending ]JSF 2.0
f:selectItemThe SelectItem tag adds a child UISelectItem component to the component associated with the enclosing tag.
f:selectItemsThe SelectItems tag adds a child UISelectItems component to the component associated with enclosing tag.
f:setPropertyActionListener[ Documentation pending ]
f:subviewThe Subview tag creates a naming container (a container component with a unique identifier) that contains all JavaServer Faces core and custom tags on a nested page via "jsp:include" or any tag that dynamically includes another page from the same web application, such as JSTL's "c:import". The subview tag wraps JSF components contained in an included JSP or Facelets page that allows nested views.
f:validateBean[ Documentation pending ]JSF 2.0
f:validateDoubleRangeThe ValidateDoubleRange tag registers a DoubleRangeValidator instance on the component associated with the enclosing tag.
f:validateLengthThe ValidateLength tag registers a LengthValidator instance on the component associated with the enclosing tag.
f:validateLongRangeThe ValidateLongRange tag registers a LongRangeValidator instance on the component associated with the enclosing tag.
f:validateRegex[ Documentation pending ]JSF 2.0
f:validateRequired[ Documentation pending ]JSF 2.0
f:validatorThe Validator tag registers a named Validator instance on the component associated with the enclosing tag.
f:valueChangeListenerThe ValueChangeListener tag registers a ValueChangeListener instance on the component associated with the enclosing tag.
f:verbatimThe Verbatim tag creates an output component as a child of the component associated with the enclosing tag.
f:viewThe View tag is the container for all JavaServer Faces component tags used on a page.
f:viewParam[ Documentation pending ]

Biblioteca HTML

Son los Componentes de Presentación, son utilizados para dar forma a la interfaz JSF

JSF HTML Tag Library

This tag library contains JavaServer Faces component tags for all UIComponent + HTML RenderKit Renderer combinations defined in the JavaServer Faces Specification.

Tag NameDescriptionSince
h:bodyThis tag renders an HTML body element.JSF 2.0
h:button[ Documentation pending ]JSF 2.0
h:columnThe column tag renders a single column of data within a data table component.
h:commandButtonThe commandButton tag renders an HTML submit button that can be associated with a backing bean or ActionListener class for event handling purposes.
h:commandLinkThe commandLink tag renders an HTML anchor tag that behaves like a form submit button and that can be associated with a backing bean or ActionListener class for event handling purposes.
h:dataTableThe dataTable tag renders an HTML4 compliant table element that can be associated with a backing bean to obtain its data as well as for event handling purposes.
h:formThe form tag renders an HTML form element.
h:graphicImageThe graphicImage tag renders an HTML image tag.
h:headThis tag renders an HTML head element.JSF 2.0
h:inputHiddenThe inputHidden tag renders an HTML input element of the type "hidden".
h:inputSecretThe inputSecret tag renders an HTML input element of the type "password".
h:inputTextThe inputText tag renders an HTML input element of the type "text".
h:inputTextareaThe inputTextarea tag renders an HTML "textarea" element.
h:link[ Documentation pending ]JSF 2.0
h:messageThe message tag renders a message for a specific component.
h:messagesThe messages tag renders all Faces messages for the current view.
h:outputFormatThe outputFormat tag renders parameterized text and allows you to customize the appearance of this text using CSS styles.
h:outputLabelThe outputLabel tag renders an HTML "label" element.
h:outputLinkThe outputLink tag renders an HTML anchor tag with an "href" attribute.
h:outputScript[ Documentation pending ]JSF 2.0
h:outputStylesheet[ Documentation pending ]JSF 2.0
h:outputTextThe outputText tag renders basic text on your JSF page.
h:panelGridThe h:panelGrid tag renders an HTML4 compliant table element.
h:panelGroupThe panelGroup tag is a container component that renders its child components.
h:selectBooleanCheckboxThe SelectBooleanCheckbox tag renders an HTML input element of the type "checkbox".
h:selectManyCheckboxThe SelectManyCheckbox tag renders a list of HTML checkboxes.
h:selectManyListboxThe SelectManyListbox tag renders an HTML "select" list of any size with the "multiple" attribute present.
h:selectManyMenuThe SelectManyMenu tag renders an HTML "select" element with the "multiple" attribute present and the "size" attribute set to 1.
h:selectOneListboxThe SelectOneListbox tag renders an HTML "select" element of any size without the "multiple" attribute.
h:selectOneMenuThe SelectOneMenu tag renders an HTML "select" element with a "size" of 1 without the "multiple" attribute.
h:selectOneRadioThe SelectOneRadio tag renders a table of HTML "input" elements of the type "radio".

Composite (JSF 2)

Es la nueva Biblioteca de Composición de Interfaces.

Tag NameDescriptionSince
composite:actionSource[ Documentation pending ]
composite:attribute[ Documentation pending ]
composite:editableValueHolder[ Documentation pending ]
composite:extension[ Documentation pending ]
composite:facet[ Documentation pending ]
composite:implementation[ Documentation pending ]
composite:insertChildren[ Documentation pending ]
composite:insertFacet[ Documentation pending ]
composite:interface[ Documentation pending ]
composite:renderFacet[ Documentation pending ]
composite:valueHolder[ Documentation pending ]

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


viernes, 21 de febrero de 2014

Introducción a JSF

JSF - Introducción

Objetivo

Comprender los diferentes conceptos y ciclo de vida de JSF 2, Utilizar componentes JSF para Desarrollar una Aplicación Java Web con JSF.

Materiales

Requisitos

  • Java
  • Conocimientos de HTML, CSS, XML, javascript
  • Java Web - Servlets, Filtros, Listener y JSP

Instalación

  • Java SDK
  • Eclipse
  • Maven
  • Apache Tomcat 7

Definiciones Básicas (Wikipedia)


JavaServer Faces (JSF) es una tecnología y framework que cumple con el patrón MVC (Model View Controller) para aplicaciones Java basadas en web que simplifica el desarrollo de interfaces de usuario en aplicaciones Java EEJSF usa JavaServer Pages (JSP) como la tecnología que permite hacer el despliegue de las páginas, pero también se puede acomodar a otras tecnologías.

JSF Servlet

JSF es un Framework que tiene como punto de entrada en una aplicación Web Java un Servlet, cuándo se quiere utilizar JSF se necesita registrar el Servlet que está definido en el API de JSF.



JSF Servlet Mapping

Como vimos en cursos anteriores de Java Web, Para que un servlet pueda ser accedido es necesario un mapeo de tipo URL -> Servlet











Con esta Regla se define que todo URL que cumple con el patrón /faces/* será procesado por el Servlet de nombre FacesServlet que es de clase javax.faces.webapp.FacesServlet .

Fases del JSF

EL Servlet tiene como tarea el control y la organización del Request. y lo realiza en diferentes fases donde las fases se componen de:

1) Restore View 

Se crea o restaura el árbol de componentes (la vista) en memoria. Cuando la vista se crea por primera vez, se almacena en un contenedor padre conocido como FacesContext y se crea el UIViewRoot, y se pasa directamente a la última fase (Render Response), ya que la petición no tendrá valores que estudiar. Todas las operaciones realizadas en el FacesContext utilizan un hilo por petición de usuario, así que no hay que preocuparse porque múltiples peticiones de usuarios puedan "liarla". 

2) Apply Request Values

Se itera sobre los componentes del árbol, comprobando qué valor de la petición pertenece a qué componente, y los van guardando. Estos valores almacenados se llaman 'valores locales'. 

3) Process Validations

Se realizan las validaciones y conversiones necesarias de los valores locales. Si ocurre algún error en esta fase, se pasa a la fase Render Response, mostrándole al usuario otra vez la página actual y dándole así una nueva oportunidad para que pueda introducir los datos correctos. 

4) Update Model Values

Se modifican los valores de los beans asociados a los componentes de la vista con los valores locales. Ej. #{userBean.name} 

5) Invoke Application

Se invoca el método asociado al action del botón o link que pinchó el usuario (Ej. #{userBean.addUser}), y que hizo que se activara el ciclo de vida de la petición. Estos métodos devuelven un String que le indica al gestor de navegación qué página tiene que devolverle al usuario. 

6) Render Response

El servidor devuelve la página de respuesta al navegador del usuario y guarda el estado actual de la vista para poder restaurarla en una petición posterior. Si añadimos a un botón o a un link el atributo immediate a true, se saltará la fase de validación. Por ejemplo, si tenemos un botón "Volver", normalmente no querremos que valide los valores que hay introducidos sino que nos devuelva diréctamente a la página anterior


Ciclo de Vida de JSF



Componentes

  • Managed Bean
  • Propiedades
  • Acciones y Acciones "Listener"
  • Componentes UI
  • Validadores 
  • Convertidores

Managed Bean


Son Componentes o Clases JAVA que encapsulan información acerca del negocio, Pueden Representar un Formulario, un Estado el arquitecto o programador le puede dar el significado que sea necesario.

Model Bean

Son Beans que representan la lógica de Negocio, idealmente no se recomienda mezclar pero se pueden utilizar los Model Bean como propiedades de un Managed Bean


Propiedades

Las Propiedades de un Managed Bean son propiedades o Atributos de una Clase Java (que a su vez es un managed Bean) que representan Componentes de un Formulario o Estado de un Formulario, el Programador debe agregar a su managed Bean las propiedades necesarias para solucionar o resolver una situación.


Como se puede observar en la imágen las propiedades son atributos de una clase JAVA y deben tener sus métodos getters y setters para poder ser accedidos por el JSF (vía Reflection)

Acciones


Son métodos Java que representan y son ejecutados para el procesamiento o acción programática, siempre debe ser como consecuencia de un evento, Click de Botón, etc.

Componentes UI

Son Elementos típicamente un TAG JSP, TAG XHTML que al ser procesado genera HTML o Código de Presentación (XML,JSON, etc), Tienen la responsabilidad de imprimir código en Pantalla y leer el valor al momento de enviarse el Formulario al Servidor. * Pueden ser componentes de Estado y no se muestra nada en pantalla.


En el ejemplo se puede ver un componente de Entrada de Texto (h:inputText), que tiene anidado otro componente que no se visualiza (f:convertDateTime) pero sirve para darle información al Input para definir el Formato (dd/MM/yyyy).

Validadores


Son Componentes hechos en Java y definidos en el JSF que se utilizan para Validar el Valor de un  UIComponent de acuerdo al diagrama de Fases del JSF se puede ver que son ejecutados en la Fase 3 y en caso de no ser validado provee el mensaje adecuado para imprimir en pantalla.


Convertidores


Son utilizados para Convertir Objetos JAVA en Texto y para Convertir Text en Objetos Java


En el ejemplo, se utiliza para convertir a un Objeto de clase Country.

Descargar los Ejemplos

Descargar