JavaServer Faces

JavaServer Faces es una tecnologa que fue diseada para simplificar la construccin de
interface de usuario para aplicaciones Web Java, uno de los puntos clave fue el apoyo de
las herramientas creadas para este tipo de aplicaciones, JSF tiene el apoyo de IDEs tales
como eclipse, Netbeans, myEclipse, Oracle web, entre muchos otros ms, adems cuenta
con un fuerte apoyo de servidores de aplicaciones java con el objetivo de soportar y
desplegar las aplicaciones creadas en JavaServer Faces.

JavaServer Faces es el marco de aplicaciones web estndar para el desarrollo de

aplicaciones empresariales java.
Al ser un estndar de java, esta teologa cuenta con un apoyo muy fuerte de la
industria de java, esta tecnologa ha crecido bastante su uso a nivel mundial.
Se cuenta con un fuerte apoyo de IDEs de Java, as como servidores de
aplicaciones para su despliegue.

Caractersticas de JavaServer Faces

El framework de JSF implementa el patrn de diseo MVC proporcionando un
enfoque orientado a eventos.
Debido al nmero de componentes listos para utilizarse JSF agiliza el desarrollo de
aplicaciones Web para Java (RAD).
JSF provee un API para crear componentes HTML complejos, incluyendo de manera
embebida dentro del componente, tecnologa como JavaScript, CSS y HTML
Integrado, esto permite crear componentes reutilizables.
Render-Kit. Los componentes pueden desplegarse no solamente en navegadores
WEB sino tambin en dispositivos mviles u otro tipo de clientes.

Permite crear ms fcilmente nuevos componentes por lo que existen varios

frameworks que extienden el poder JSF incluyendo por ejemplo AJAX.
Las vistas en JSF pueden mostrase en distintos idiomas.
Caractersticas de JSF 2.0
Manejo de condiciones por default ms inteligentes, esto aplica en casos de
navegacin simples los cuales ya no se requiere integrarlos al archivo de
configuracin faces-config como era necesario en la versin 1.0
Manejo de anotaciones para varias configuraciones de este framework, esto
simplifica en gran medida, el agregar un managed bean a nuestra aplicacin web,
evitando con ello la declaracin en el archivo faces-config.
Tambin se incluy un soporte nativo para AJAX, la tecnologa de AJAX ya es parte
del ciclo de vida de JSF por lo que procesar peticiones asncronas es ms rpido
que en la versin 1.0.
A diferencia de la versin 1.0, en la versin 2.0 ya tenemos soporte por default
para el uso de la tecnologa de Facelets, la tecnologa de Facelets toma en cuenta
el ciclo de vida de JSF a diferencia de los JSPs, por ello los JSPs quedaron en
desuso y quedo como tecnologa principal el uso de los Facelets.
Arquitectura JavaServer Faces
En primera instancia tenemos la capa del cliente, en la cual vamos a estar visualizando el
resultado de nuestra aplicacin de JSF, el cliente lo que va a visualizar es tecnologa de
HTML, hojas de estilo y JavaScript.
Una vez que el cliente empieza a interactuar con nuestra aplicacin, tenemos
posteriormente la Capa Web (JSF) en esta Capa, es donde precisamente trabaja nuestro

Framework de JSF. El cual se compone de Managed Bean (Controlador), Facelet/JSP Tags

(Vista), JavaBean (Modelo). Como podemos ver, es un modelo MVC.
Posteriormente tenemos nuestra capa de negocio, estas clases de negocio podemos
implementarlas utilizando clases nativas de Java, podemos tambin utilizar EJBs, o
tambin podemos utilizar Spring como parte de la capa de Negocio.
Posteriormente para recuperar informacin de una base de datos, tenemos la Capa de
Datos, aqu tenemos los objetos de Entidad, los cuales pueden ser trabajados con
tecnologas como JPA o Hibernate.
Finalmente tenemos la comunicacin con la BD y comienza de vuelta la respuesta hacia
el cliente.

Patrn de diseo MVC con JSF

JSF es un framework de aplicaciones Web que implementa el patrn de diseo MVC, con
una clara separacin de responsabilidades.
El Modelo contiene datos de la interfaz de usuario y es el responsable de almacenar los
datos de la aplicacin Web. Se puede implementar con clases puras de Java o tambin
conocidas como POJO (Plain Old Java Object) o con Managed Bean de Modelo. No
contienen lgica de la aplicacin ni administran el flujo de la misma.
En cambio la vista, define la interfaz de usuario con una jerarqua de componentes, utiliza
la librera estndar de JSF, tambin tecnologas como EL (Expression Language), JSTL
(Java Standar Tag Library), etc. Esto para facilitar el despliegue de la informacin del
modelo. La tecnologa utilizada por default en JSF 2.0 son los Facelets por medio del
lenguaje de Expresin de JSF es posible enlazar y utilizar los objetos de modelo he
integrarlo con la vista para el despliegue de informacin.

El controlador maneja las interacciones del usuario

y la navegacin o flujo de la aplicacin, se
implementa con Managed Bean de Control.
Tecnologa de los Facelets
Los Facelets incluyen las siguientes caractersticas:
Los Facelets son la tecnologa estndar de
despliegue en JSF 2.0.
Los Facelets fueron creados tomando en
cuenta el ciclo de vida de JSF.
Al
ejecutar
un
Facelet,
todos
los
componentes JSF se convierten a instancias Java y son administradas por un
Component Tree
Todos
los
componentes
JSF
se
derivan
de
la
clase
abstracta
javax.faces.component.UIComponent
El estado de los compnentes (Component Tree) pueden almacenarse del lado del
cliente o del lado del servidor.
Flujo de Navegacin en JSF
1. Como primer punto el Framework inicia una peticin GET a una pgina por ejemplo
nuestro index.xhtml.
2. una vez que ya estamos dentro del contexto de JSF, el usuario recibe el contenido
de respuesta y enva nuevamente una peticin POST / GET al servidor WEB, en
esta peticin el usuario est solicitando cierto recurso.
3. El servidor web recibe la peticin y revisa los managed bean involucrados en la
peticin, si es necesario crea una instancia de ellos dependiendo de su alcance y
en este momento tambin si es necesario se mandan a llamar los mtodos seters
de las propiedades del bean que se deben de llenar.
4. Se ejecuta el mtodo que procesa la peticin solicitada por el cliente, en este
momento ya deben de estar instanciados los managed bean involucrados en esta
peticin, si es que los hubiera.
5. Se ejecuta la lgica de negocio con el objetivo de obtener el modelo de nuestra
aplicacin, esto es la informacin que se va a desplegar o manipular dentro de
nuestra aplicacin.
6. Se selecciona el caso de navegacin respectivo y se redirecciona a la vista
correspondiente, en este caso la vista puede ser una pgina Facelet o puede ser un
JSP.
7. La vista utiliza la informacin de modelo que le comparti la aplicacin JSF para
finalmente regresar la respuesta solicitada al cliente.
8. Opcionalmente como solicitud de la peticin podra simplemente re direccionarse a
algn caso de navegacin es decir pasar de la peticin 2 directamente al paso 6,
simplemente para seleccionar una pgina a redireccionar.

Requerimientos para JSF 2.0

Ejecucin en Tomcat
Instalar Java 5 o mayor
Tomcat 6 o mayor (Cualquier servidor que soporte Servlets 2.5)
Agregar los Archivos Jar de JSF 2.0
o Jsf-api.jar
o Jsf-impl.jar
Descargar de Oracle
o Mojarra o Apache
o MyFaces
Configurar web.xml
Configurar faces-config.xml (opcional)
Ejecucin en Glassfish o JBoss
Instalar Java 6 o mayor
Descargar Glassfish 3 o JBoss AS 6 o cualquier servidor que soporte Java EE 6
No se requieren libreras
o Java EE 6 tiene soporte integrado para JSF 2.0
Configurar web.xml
Configurar faces-config.xml (opcional)
Nota: para generar un .xhtml, creamos un html file con el Template de New Facelet
Composition Page

Leccin 2
Managed Bean en JSF
Java Bean
Un Java Bean es una clase java que sigue las siguientes convenciones:
Tiene un constructor vaco
Tiene atributos privados y por cada atributo tenemos un mtodo get y un mtodo
set.
Partiendo del concepto de un java bean, los managed bean van a ser clases java que
tambin cumplen con las convenciones de los java beans, sin embargo al trabajar con
java server faces, vamos a configurarlos y declararlos de manera distinta.
Un managed bean es una clase java que sigue la nomenclatura de los JavaBeans
o Los managed Beans no estn obligados a extender de ninguna otra clase.
o Esto a diferencia de frameworks como Struts, si era necesario depender de
una clase llamada action o de una clase llamada actionForm dependiendo
del objetivo de la clase a procesar la peticin en el caso de los managed
bean esto ya no es necesario, esto tiene como ventajas que el framework de
JSF sea menos intrusivo que de Struts.
Aunque JSF no define una clasificacin para los Backing Beans, podemos definir las
siguientes:
o Un Backing Beans es lo mismo que un Managed Bean, debido a que es una
clase de Java del lado del servidor.
Beans de Modelo: Representan el modelo en el patrn MVC.
Beans de Control: Representan el control en el patrn MVC.
Beans de Soporte o Helpers: Contienen cdigo por ejemplo de
Convertidores.
Beans de Utilerias: Tareas genricas, como obtener el objeto HTTP
Request.

Esta clasificacin de Bean es nicamente para apoyarnos y poder clasificar

el uso de nuestros managed beans.

Uso de los Managed Beans

Un managed Bean se puede declarar de distintas maneras, por ejemplo:
Con anotaciones, antes del nombre de la clase:
o @ManagedBean

Como bean CDI (Contexts and Dependency Inyection), antes del nombre de la
clase:
o @Named
o Si utilizamos este concepto debemos agregar un archivo llamado beans.xml
en la carpeta web/WEB-INF
o Los beans CDI estn asociados a un contexto por ejemplo request, session,
etc.
o CDI especifica un mecanismo para inyectar beans, interceptar, filtrar u
observar ciertos eventos.
o CDI tambin utiliza el concepto de inversion of control, el cual lo podemos
entender como fabrica de beans para obtener de manera indirecta, algn
bean que necesitemos.
El concepto de inversion of control, permite crear aplicaciones con
bajo acoplamiento, el bean debe de implementar la interfaz
serializable.

En el archivo faces-config.xml:
o <managed-bean></managed-bean>
o Sin embargo en la versin 2.0 de JSF esto es opcional, es mas comn utilizar
anotaciones de Managed Bean.

Alcance de los Managed Beans

JSF provee los siguientes alcances o mbitos para almacenar informacin en forma de
mapa o tabla, eso quiere decir que almacenamos una llave y un valor asociado a esa
llave.
JSF 2.0 agrego algunos alcances llamados view y custom, el alcance de custom es
simplemente una estructura de datos map que enlaza objetos, es decir valores con sus
llaves respectivas, es decir sus keys, el tiempo de vida del map es administrado por el
implementador, por eso este alcance es de tipo custom o personalizado.
Como podemos observar en la figura tenemos los alcances de request, view, session y
application, cada uno de los alcances tiene un tiempo de duracin, los cuales se indican
por el tamao de los crculos, por ejemplo el alcance de request tiene menos alcance que
el de view y as sucesivamente.
Estos alcances nos van a servir para almacenar informacin de nuestra aplicacin web y
por lo tanto vamos a poder recuperarla durante el tiempo de vida de estos objetos, el
objeto de request almacena informacin nicamente durante la peticin de un usuario,
una vez que esa peticin a terminado, por ejemplo que ya solicito una nueva pgina la
informacin que el usuario almaceno en el alcance de request se elimina de la memoria
java, o lo que es lo mismo de la informacin del servidor web.

Posteriormente tenemos el alcance de view, este alcance es nuevo dentro de la

especificacin de JSF 2.0, este alcance nos permite guardar informacin en el servidor,
siempre y cuando sea la misma pgina, es decir la misma vista, es muy til si estamos
utilizando conceptos como puede ser AJAX, ya que las peticiones AJAX son rflex parciales
hacia la misma pgina HTML.
Posteriormente tenemos el alcance de session, este alcance de session nos permite
almacenar informacin en el servidor durante el tiempo de vida de la session de un
usuario, por lo tanto tiene mayor duracin que los alcances de view y request.
Y finalmente tenemos el alcance de application, este alcance va a guardar informacin
durante todo el tiempo de vida de nuestra aplicacin web, este alcance nos va a permitir
guardar informacin como puede ser la ip del usuario y cubrir requerimientos como
puede ser, si un usuario ya se registr desde una maquina distinta, podemos guardar su
ip y denegar el acceso si este mismo usuario intenta conectarse desde otra pc al mismo
sistema.

CDI y el alcance de los Beans

El concepto es muy similar al de los Managed Beans de JSF, sin embargo tiene algunas
diferencias, JSF y CDI tienen en comn los alcances de request, session y application,
pero tienen como diferencia el alcance de view en el caso de JSF y el alcance de
conversation de CDI, de hecho tambin las anotaciones para cada uno de estos alcances
si es que vamos a declararlas se encuentran en distintos paquetes, en el caso de JSF se
encuentran en javax.faces.Bean y en el caso del paquete de CDI se encuentran en
javax.enterprice.Context adems CDI agrega este alcance conversation, este alcance
permite guardar informacin entre paginas relacionadas y la informacin almacenada es
eliminada hasta que se cumpla cierta tarea.
Primer Ejemplo: Hola mundo
<!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:ui="http://java.sun.com/jsf/facelets"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<f:loadBundle basename="resources.application" var="msg"/>
<head> v
<title><h:outputText value="#{msg.welcomeTitle}" /></title>
</head>
<body>
<h3><h:outputText value="#{msg.welcomeHeading}" /></h3>
<p><h:outputText value="#{msg.welcomeMessage}" /></p>
</body>
</html>

resources/application.properties
# -- welcome --

welcomeTitle=JSF Blank Application

welcomeHeading=Welcome!
welcomeMessage=This is a JSF blank application. \
You can find the application.properties file with this message in the src/resources folder.

Ejemplo 2: Model ManagedBeans

Saludo.xhtml
<!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:ui="http://java.sun.com/jsf/facelets"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<f:loadBundle basename="resources.application" var="msg" />
<head>
<title><h:outputText value="#{msg.welcomeTitle}" /></title>
</head>
<body>

<h:form>
<h:outputLabel for="nombre" value="Nombre:" />
<h:inputText id="nombre" value="#{candidato.nombre}" />
<h:message for="nombre" />
<br/>
<h:commandButton value="Enviar" />
</h:form>
</body>
</html>

Clase Candidato.java
package mx.com.cadillacs.beans.model;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.RequestScoped;
@ManagedBean
//estamos indiando el tipo de clase administrada por JSF
@RequestScoped
// El alcance de tipo request, se va a construir y destruir cada vez que hagamos una
peticion a nuestro navegador.
public class Candidato {
//Es requerido, un constructor vacio
public Candidato(){
}
//Cada atributo debe de ser privado y tener sus metodos get/set publicos.
private String nombre = "Escriba su nombre";
public String getNombre() {
return nombre;
}
public void setNombre(String nombre) {
this.nombre = nombre;
}
}

Inyeccin de dependencias en JSF

Esto sucede cuando un usuario solicita una pagina, en este caso la pagina de
index.xhtml, esa pagina a su vez necesita de un objeto backing ManagedBean llamado
VacanteForm.java y este a su vez tiene una dependencia con la clase Candidato.java.
Lo que hace el framework de JSF, es identificar si ya existen objetos de tipo backing Bean
de tipo candidato en el alcance de request y si existen entonces regresa la referencia
hacia la clase VacanteForm.java y a su vez este objeto una vez que est completo
regresa la referencia hacia la pgina JSF y finalmente la pgina JSF index.xhtml puede
hacer uso ya sea del objeto vacanteForm o del objeto candidato, dependiendo de la
informacin.

Ejercicio 3: Vacante
vacante.xhtml
<html xmlns="http://www.w3.org/1999/xhtml"
xmlns:ui="http://java.sun.com/jsf/facelets"
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
<head>
<title>saludo</title>
</head>
<body>
<h:form>
<h:outputLabel for="nombre" value="Nombre:" />
<h:inputText id="nombre" value="#{candidato.nombre}" />
<h:message for="nombre" />
<br/>
<h:commandButton action="#{vacanteForm.enviar}" value="Enviar" />
</h:form>
</body>
</html>

exito.xhtml
<head>
<title>exito</title>
</head>
<body>
<h:form>
Gracias #{candidato.nombre} por aplicar la vacante
<br/>
<h:commandLink action="vacante">Regresar</h:commandLink>
</h:form>
</body>
</html>

fallo.xhml
<head>
<title>Fallo</title>
</head>
<body>
<h:form>
Lo sentimos #{candidato.nombre}, ya se han cubierto las vacantes.
<br/>
<h:commandLink action="vacante">Regresar</h:commandLink>
</h:form>
</body>

</html>

VacanteForm.java
package mx.com.cadillacs.beans.backing;
import javax.faces.bean.ManagedBean;
import javax.faces.bean.ManagedProperty;
import javax.faces.bean.RequestScoped;
import mx.com.cadillacs.beans.model.Candidato;
@ManagedBean
@RequestScoped
public class VacanteForm {
/*
* La Clase va a tener una dependencia con la propiedad de candidato
*/
@ManagedProperty(value = "#{candidato}")
private Candidato candidato;
public Candidato getCandidato() {
return candidato;
}
public void setCandidato(Candidato candidato) {
this.candidato = candidato;
}
//Metodo de flujo de control
public String enviar(){
if(this.candidato.getNombre().equals("Juan")){
return "exito"; //exito.xhtml
}else{
return "fallo"; //fallo.xhtml
}
}
}

Nota: La clase de candidato es la misma que en el ejercicio anterior.

Expression Language (EL) en JSF

Ejemplo de uso de Managed Beans
Podemos crear managed Bean que posteriormente sern utilizados en las pginas JSF,
comnmente utilizaremos EL de JSF o tambin conocido como EL.
Para declarar un Bean, hemos visto que podemos utilizar la anotacin:
1. Creacin del Bean
@ManagedBean
@SessionScoped

public class EmpleadoForm{}

Uso en la pgina JSF con el EL (Expression Language)
Ahora como vamos a utilizar este bean dentro de nuestra pgina para obtener cierta
informacin, vamos a utilizar EL y simplemente lo que vamos hacer es especificar el
nombre del bean dentro del tag de nuestro EL.
Una vez especificado el nombre del bean lo que hacemos es especificar el nombre del
atributo, que tengamos en nuestra clase y que tengamos la necesidad de mostrarlo
en la pantalla JSF, sin embargo aqu podemos ver una diferencia, en este caso
tenemos una e minscula comparada con la de la Clase, esta es la anotacin de los
ManagedBeans cuando estamos utilizando una clase, nuestra clase simplemente por
nomenclatura la definimos con la E mayscula, pero cuando estamos utilizando un
objeto de esta clase, las instancias de esta clase los declaramos con minsculas.
#{empleadoForm.atributo}
2. Creacin del Bean con nombre personalizado y notacin CDI
@Named
public class EmpleadoForm{}
En este caso podemos observar que agregamos la anotacin de Named.
Posterior mente definimos nuestra clase y para utilizar este bean en nuestra pgina
JSF la misma sintaxis que utilizamos creando nuestro ManagedBean.
#{empleadoForm.atributo}
Nota: Si el despliegue de nuestra aplicacin se va a realizar en un servidor JEE 6, se
recomienda utilizar CDI, en cambio, si se va a utilizar un servidor como Tomcat, el cual no
tiene un soporte completo para la especificacin JEE 6 podemos utilizar las anotaciones
de JSF, esto se debe a que las anotaciones de CDI nos van a permitir simplificar la
integracin con tecnologas como puede ser EJB y JPA.

Inyeccin de dependencias
En muchas ocasiones una pgina JSF puede utilizar varios managed bean de ah la
necesidad de relacionar distintos managed bean, la inyeccin de dependencias, es un
derivado de la inversin de control.
JSF soporta una inyeccin de dependencias simple.
La inyeccin se puede hacer de dos maneras:

Con anotaciones dentro del Managed Bean:

o @ManagedProperty(value= #{nombreBean})

Nota: para inyectar los beans, estos debern de haber sido declarados con anterioridad.

Tambin podemos inyectarlos, por medio del archivo faces-config.xml utilizando la

etiqueta dentro de un managed bean:
o <managed-property>#{nombreBean}</managed-property>

Nota: esta sintaxis ya es menos comn en la especificacin 2.0 debido a cmo podemos
observar, definir una anotacin he inyectar el contenido de un managed property dentro
de otro managed bean es mucho ms simple utilizando anotaciones.
Archivo faces-config.xml
En la especificacin de JSF 2.0 el archivo de faces-config se convierte en un archivo
opcional, sin embargo este archivo tiene grandes caractersticas, las cuales podemos
seguir utilizando sin ningn problema.
Uso y ventajas del archivo faces-config.xml
Configuracin centralizada, todos nuestros componentes los vamos a tener en un
solo archivo definidos y ah podemos entender la configuracin de nuestra
aplicacin JSF.
o Desventaja, difcil saber si una clase tiene definido una anotacin de
Managed Bean o no.
Reglas de navegacin, tambin en el archivo de faces-config, podemos definir
reglas de navegacin, es decir el flujo de nuestras pginas, en una aplicacin JSF.
Tambin podemos definir nuestros Managed Bean segn hemos especificado.
Podemos definir tambin la inyeccin de dependencias.
Definir configuraciones regionales.
Registrar validadores.
Registro de listeners
Etc
Nota: Este archivo en una aplicacin web debe de encontrarse dentro de la ruta de
WEB-INF/faces-config.cml
Con el uso de anotaciones, cada vez es menos indispensable utilizar este archivo.

Ejemplo de anotaciones de Beans dentro de faces-config.xml

Nota: si no se especifica el alcance, este por default se encuentra en el alcance de

request.

Expression Languaje (EL)

El lenguaje de expresin (EL) de JSF nos permite simplificar el manejo de expresiones en
la pgina JSF.
El lenguaje EL enlaza la vista con el modelo del patrn MVC.
Es decir al definir un bean, simplemente para desplegar esta informacin, en nuestra
pgina JSF vamos a agregar la siguiente sintaxis
#{nombreBean.propiedad}
Lo que sucede al colocar esta expresin:
Se busca el bean a utilizar en cierto alcance, primero en request, session y
finalmente en alcance de aplication.
Una vez localizado se manda a llamar el mtodo get o set de la propiedad
indicada.

Objetos implcitos en JSF

El lenguaje EL tambin permite acceder fcilmente a objetos implcitos (ya instanciados)

en las pginas JSF, algunos ejemplos son:
Cookie: el cual es un Map
facesContext: nos va a permitir acceder de manera indirecta a los objetos request,
session o aplication.
header: el cuale es un Map
headerValues. Map
param: Map
paramValues. Map.
request (JSF 1.2): ServletRequest or PortletRequest
session (JSF 1.2): HttpSession or PortletSession
requestScope: Map
sessionScope: Map
applicationScope. Map
initParam: Map

view: UIViewRoot

Operadores EL
El lenguaje EL cuenta con operadores para evaluar expresiones:

Nota: no utilizarlos mucho, ya que esto rompe el patrn de diseo MVC, al agregar lgica
en nuestra vista.

Ciclo de vida de JSF

El ciclo de vida de JSF comienza con la peticin de un usuario, el cual solicita un recurso
de nuestro servidor web, la primera fase dentro de este ciclo de vida (1) es el proceso de
restauracin o creacin de la vista, si es la primera vez que solicita esta vista, se va a
crear cada uno de estos componentes que representan las etiquetas de nuestra pgina
JSF y va a tener una clase correspondiente de Java que represente esta etiqueta en JSF,
todas estas etiquetas son administradas por un componente principal llamado
component tree o arbol de componentes en caso de que la peticin haya sido get
o sin parmetros, en este caso el framework no tiene nada ms que realizar y
simplemente regresa la respuesta hacia el cliente, en caso contrario y que necesitemos
procesar informacin, (2) el paso 2, es aplicar los valores de la peticin, en este paso los
parmetros enviados son mapeados con cada uno de los componentes java
correspondientes, esto nos permitir llenar la informacin que los usuarios estn
enviando a nuestra aplicacin java, (3) en este paso se realiza el procesamiento de
validaciones y conversiones, es decir en el paso 2 ya se asignaron los valores
correspondientes a nuestras clases java sin embargo en este punto todava no sabemos
si esos valores son los adecuados o si es necesario convertirlos a cierto tipo de datos, por
ello en este paso 3 si una validacin falla, el estado del componente se marca como
invalido y se pasa directamente al estado (6) esto sucede solamente en caso de que
hayamos encontrado algn error de conversin o de validacin sin embargo esto nos
garantiza que nuestra aplicacin java no va a continuar si es que tiene algn problema
de validacin o de correccin de datos. En caso de que no tengamos errores de validacin
de datos, pasamos al paso (4) el cual actualiza los valores de nuestras clases de modelo,
los valores de los componentes java ya una vez validados y convertidos en el paso 3 son
puestos en los objetos de modelo utilizando los mtodos seters respectivos, es decir que
hasta el paso 4 es donde realmente el framework nos garantiza que esos valores ya los
podemos utilizar para operar, por ejemplo si estamos enviando un dato de tipo fecha, en
este momento la fecha se puede convertir directamente a un tipo de dato Date y no
seguir manejndolo como un String ya que normalmente as es como suceda dentro del
Api de los servlets / JSP, cuando utilizbamos esas tecnologas nosotros ramos
responsables de hacer ese tipo de conversiones, en el caso de JSF mucho de ese trabajo
queda resuelto por el propio Framework, en el paso (5) ya que tenemos la informacin de
modelo, procedemos a invocar nuestra aplicacin o lo que es lo mismo los mtodos que
procesan las peticiones de nuestros usuarios , en este punto se ejecutan los mtodos
action que estn almacenados en los managed bean, los mtodos actionListener son
llamados antes que los mtodos de tipo action.
Una vez que hemos procesado los mtodos de nuestra aplicacin se genera una
respuesta respectiva hacia el cliente, con esto se concluye el ciclo de vida de nuestra
aplicacin de JSF, es posible crear clases JSF para la depuracin de las faces paso a paso
para ello debemos implementar la interface faces listener y se debe de registrar en el
archivo de faces-config.xml