You are on page 1of 29

Introduccin a JSF Java Server Faces

Introduccin a JSF Java Server Faces. 1 Resumen. 1 Introduccin. 1 Qu es JSF?. 2 Porqu utilizar JSF en nuestros proyectos. 2 Riesgos en el desarrollo JSF. 3 Cmo funciona JSF. 4 Las etiquetas JSF. 4 Los backbeans. 5 Respondiendo a las acciones del usuario. 6 La navegacin entre pginas. 6 Las etapas del procesamiento de la peticin. 7 Gestin de los beans. 8 El lenguaje de expresiones EL. 8 El entorno FacesContext 9 Acceso a los beans de la aplicacin. 10 Cmo seguir la pista a una peticin JSF. 12

Seguir la pista a peticiones .jsf 12 Seguir la pista a acciones JSF. 12 JSF frente a Struts. 14 JSF y AJAX.. 15 El futuro de JSF. 15 Conclusin. 15

Resumen
En este tutorial sobre Java Server Faces (JSF) intento responder a dos preguntas bsicas de JSF: porqu usar JSF en nuestras aplicaciones web Java cmo usar JSF Hablaremos de su funcionamiento, las pginas JSF, las etiquetas JSF, los managed beans, la navegacin entre pginas, el ciclo de vida de l peticin al servidor y otros temas.

Introduccin
Para el desarrollo de aplicaciones de negocio se utiliza frecuentemente el patrn de diseo MVC Modelo Vista Controlador (Model View Contrdller) que ademas es sencillo de implenentar en las aplicaciones web. En este patrn el modelo es modificable por las funciones de negocio. Estas funciones son solicitadas por el usuario mediante el uso de un conjunto de vistas de la aplicacin que solicitan dichas funciones de negocio a travs de un controlador, que es el mdulo que recibe la peticiones de las vistas y las procesa. Se suele clasificar en dos tipos a las aplicaciones basadas en MVC: tipo 1. Las vistas conocen la accin que se va a invocar en su peticion. Normalmente la funcin esta cableada dentro de la

vista tipo 2. El controlador introduce un conjunto de reglas que mapean a las peticiones con las funciones, controlando adems el flujo de navegacin por la aplicacin. Un ejemplo de aplicaciones de tipo 1 son las que se construyen utilizando JSF o ASP.NET y como ejemplo de tipo 2 serian las creadas con Struts. La creacin de aplicaciones basadas en el patrn MVC se ve facilitada por el uso de marcos de trabajo (frameworks). Un marco de trabajo es un conjunto de APIs y mdulos normalmente acompaados de la documentacin y guia de uso que definen la manera de implementar alguna de las capas de nuestra aplicacin. Lo podemos ver tambin como la estructura o cimientos sobre los que crear nuestra aplicacin.

Qu es JSF?
JSF es un marco de trabajo para crear aplicaciones java J2EE basadas en el patron MVC de tipo 1. JSF tiene como caracterstas principales: -Utiliza pginas JSP para generar las vistas, aadiendo una biblioteca de etiquetas propia para crear los elementos de los formularios HTML. Asocia a cada vista con formularios un conjunto de objetos java manejados por el controlador (managed beans) que facilitan la recogida, mapipulacin y visualizacin de los valores nostrados en los diferentes elementos de los formularios. Introduce una serie de etapas en el procesamiento de la peticin, como por ejemplo la de validacin, reconstruccin de la vista, recuperacin de los valores de los elementos, etc. Utiliza un sencillo fichero de configuracin para el controlador en

formato xml Es extensible, pudiendo crearse nuevos elementos de la interfaz o modificar los ya existentes. Y lo que es ms importante: forma parte del estndar J2EE. En efecto, hay muchas alternativas para crear la capa de presentacin y control de una aplicacin web java, como Struts y otros frameworks, pero solo JSP forma parte del estndar.

Porqu utilizar JSF en nuestros proyectos


JSF nos permite desarrollar rpidamente aplicaciones de negocio dinmicas en las que toda la lgica de negocio se implementa en java, o es llamada desde java, creando pginas para las vistas muy sencillas (salvo que introduzcamos mucha maquetacin HTML o Javascript) JSF nos ofrece una serie de ventajas: El cdigo JSF con el que creamos las vistas (etiquetas jsp) es muy parecido al HTML estndar. Lo pueden utilizar fcilmente desarrolladores y diseadores web. JSF se integra dentro de la pgina JSP y se encarga de la recogida y generacin de los valores de los elementos de la pgina JSF resuelve validaciones, conversiones, mensajes de error e internacionalizacin (i18n) JSF permite introducir javascript en la pgina, para acelerar la respuesta de la interfaz en el cliente (navegador del usuario). JSF es extensible, por lo que se pueden desarrollar nuevos componentes a medida, Tambin se puede modificar el comportamiento del framework mediante APIs que controlan su funcionamiento. Desde el punto de vista tcnico podemos destacar los siguientes: JSF forma parte del estndar J2EE, mientras que otras tecnologas

para creacin de vistas de las aplicaciones no lo forman, como por ejemplo Struts. JSF dispone de varias implementaciones diferentes, incluyendo un conjunto de etiquetas y APIs estndar que forman el ncleo del framework. Entre estas implementaciones cabe destacar la implementacin de referencia de Sun Microsystems, actualmente desarrollada como un proyecto open source, y la implementacin del proyecto Apache, MyFaces, dotada de un conjunto de extensiones que la hacen muy interesante para el desarrollo de aplicaciones corporativas. El desarrollo de JSF est realmente empezando. Las nuevas versiones del framework recogen la funcionalidad de versiones anteriores siendo su compatibilidad muy alta, de manera que el mantenimiento de aplicaciones no se ve penalizado por el cambio de versiones.

Riesgos en el desarrollo JSF


Antes de comenzar el desarrollo con JSF debemos conocer aquellos puntos que lo pueden hacer ms largo de lo realmente necesario. Entre ellos la experiencia nos muestra los siguientes: Utilizar el alicate para clavar. JSF es una herramienta y como tal tiene una forma de uso. Si nos empeamos en seguir desarrollando las pginas como siempre, intentando adaptar JSF al modo al que habitualmente desarrollamos en vez de adaptarnos a JSF complicaremos el desarrollo Abuso del javascript. JSF permite utilizar javascipt para hacer ms rpida una pgina html, evitando peticiones al servidor. Sin embargo la introduccin de javascript en la pgina complica y alarga los desarrollos con JSF, y en general con jsp. La capa javascript aade etapas adicionales a la aplicacin, que hace ms difcil su depurado. Un consejo: la pgina debera poderse ejecutar sin prdida de funcionalidad (slo de rendimiento si se desactiva el javascript). La maquetacin compleja tambin complica el desarrollo ya que obliga a utilizar muchas etiquetas y atributos, especialmente en

los datatables. Si la maquetacin de nuestras pginas es compleja deberamos pensar en crear componentes JSF a medida que simplifiquen dicho trabajo.

Cmo funciona JSF


Normalmente las aplicaciones web se construyen como un conjunto de pantallas con las que va interactuando el usuario. Estas pantallas contienen textos, botones, imgenes, tablas y elementos de seleccin que el usuario modifica. Todos estos elementos estarn agrupados en formularios HTML, que es la manera en que las pginas web envan la informacin introducida por el usuario al servidor. La principal funcin del controlador JSF es asociar a las pantallas, clases java que recogen la informacin introducida y que disponen de mtodos que responden a las acciones del usuario. JSF nos resuelve de manera muy sencilla y automtica muchas tareas: Mostrar datos al usuario en cajas de texto y tablas. Recoger los datos introducidos por el usuario en los campos del formulario. Controlar el estado de los controles del formulario segn el estado de la aplicacin, activando, ocultando o aadiendo y eliminando controles y dems elementos Realizando validaciones y conversiones de los datos introducidos por el usuario Rellenando campos, listas, combos y otros elementos a medida que el usuario va interactuando con la pantalla Controlando los eventos que ocurren en los controles (pulsaciones de teclas, botones y movimientos del ratn). Las aplicaciones JSF estn formadas por los siguientes elementos principales:

Pginas JSP que incluyen los formularios JSF. Estas pginas generarn las vistas de la aplicacin Beans java que se conectan con los formularios JSF Clases java para la lgica de negocio y utilidades. Ficheros de configuracin, componentes a medidad y otros elementos del framework. Resto de recursos de la aplicacin web: recursos esttios, javascript y otros elementos.

Las etiquetas JSF


JSf dispone de un conjunto bsico de etiquetas que permiten crear fcilmente componentes dinmicos en las pginas web. Estas etiquetas son: h:commandButton. Un botn al que podemos asociar una accin. h:commandLink. Un enlace hipertexto al que podemos asociar una accin. h:dataTable. Crea una tabla de datos dinmica con los elementos de una propiedad de tipo Array o Map del bean. h:form. Define el formulario JSF en la pgina JSP h:graphicImage. Muestra una imagen jpg o similar. h:inputHidden. Incluye un campo oculto del formulario. h:inputSecret . Incluye un campo editable de tipo contrasea (no muestra lo que se escribe) h:inputText. Incluye un campo de texto normal. h:inputTextarea. Incluye un campo de texto multilnea.

h:message. Imprime un mensaje de error en la pgina (si se ha producido alguno). h:messages. Imprime varios mensajes de error en la pgina, si se han producido. h:outputFormat. Muestra texto parametrizado. Utiliza la clase java.text.MessageFormat de formateo. h:outputLabel. Muestra un texto fijo. h:outputLink. Crea un enlace hipertexto. h:outputText h:panelGrid. Crea una tabla con los componentes incluidos en el panelGrid. h:panelGroup. Agrupa varios componentes para que cierto componente los trate como un nico componente (por ejemplo para meter varios componentes en una celda de un panelGrid. h:selectBooleanCheckbox. Crea una casilla con dos estados: activado y desactivado. h:selectManyCheckbox. Crea un conjunto de casillas activables. h:selectManyListbox. Crea una lista que permite seleccionar mltiples elementos. h:selectManyMenu. Crea una lista desplegable de seleccin mltiple. h:selectOneListbox. Crea una lista en la que se puede seleccionar un nico elemento. h:selectOneMenu. Crea na lista desplegable de seleccin. h:selectOneRadio. Crea una lista de botones, redondos normalmente, excluyentes.

Los backbeans

A las clases java que se asocian a los formularios JSF se les denomina backend beans ya que son los beans (clases java) que estn detras del formulario. Estos beans se referencian en el fichero de configuracion de JSF en el apartado de managed beans, ya que son beans gestionados por el controlador JSF. este se encarga de su construccin y destruccin automticas cuando es necesario. Estructura de las pginas En su versin ms sencilla, cada pgina JSF est formada por una pgina JSP que contiene un formulario (HTML FORM) y un backbean. El controlador JSF registra en el servidor de aplicaciones un tipo especial de peticin, tipicamente *.jsf, que estar asociado a estas pginas. El primer caso comienza cuando el usuario realiza en su navegador una peticin de navegacin a una url de tipo *.jsf. Cuando al servidor web llega una peticin del tipo pagina JSF, el controlador JSF entra en funcionamiento. Primero comprueba si es la primera vez que se accede a dicha pgina. Si es as, carga la pgina jsp asociada pagina.jsp y la procesa construyendo en memoria la repesentacin de los controles de la pgina. Tras esta etapa JSF sabe cmo construir el cdigo HTML de salida y la lista de controles de usuario que la cumplen, es decir, sabe lo que contiene y cmo pintarla. El siguiente paso es asociarle los backbeans. Para ello, del procesamiento de la pgina jsp, el controlador ha obtenido la lista de backbeans asociados, por lo que procede a buscarlos en sus correspondientes mbitos de la aplicacin como la request y la session. Los beans que no existan se crean llamando a los constructores de sus clases, definidos en la seccion de managed beans del fichero de configuracin de JSF. El tercer paso es dar valores a las propiedades de los elementos JSF de la pgina. Aqu juega un papel fundamental el lenguaje de

expresiones de JSF, que es parecido al lenguaje de expresiones que se permite en las pginas jsp normales. En su versin ms sencilla una expresin JSF sera del tipo #{mibackbean.propiedad}. Finalmente el servidor devuelve al usuario una pgina creada a partir de una pgina JSP que incluye normalmente etiquetas JSF, cuyos valores se extraern del backbean asociado, ahora ya actualizados.

Respondiendo a las acciones del usuario


Una vez que el usuario ve la pgina web que se ha construido con JSF, est listo para comenzar a interactuar con ella. El mtodo mas sencillo de interaccin es el uso de formularios web. Un formulario web simple consta de: Etiquetas que muestran informacin Campos editables El botn de envo del formulario El controlador JSF dispone de un conjunto de etiquetas que permiten definir formularios JSF. Las ms sencillas son: h:form. Esta etiqueta sustituye al form de HTML, aadiendo la funcionalidad JSF al formulario h:outputText. Sirve para imprimir valores en la pgina h:inputText. Sirve para crear campos editables en los que introducir los datos h:commandButton. Crea botones que envan el formulario Cuando la pgina JSF contiene elementos que incluyen acciones se ejecuta una fase ms en el procesamiento de la peticin al servidor. Si en nuestro formulario hay botones u otros elementos que tienen una propiedad action, si se pulsa sobre el elemento cuando la peticin sea procesada por el servidor se ejecutar la lgica de la

accin asociada a este elemento. Este es el mecanismo JSF habitual para ejecutar a lgica de la aplicacin. Esto se hace ejecutando los mtodos del backbean asociado a la pgina

La navegacin entre pginas


Cuando se ejecuta una peticin que incluye una accin se ejecuta el mecanismo de navegacin de JSF. Tras la ejecucin de la accin, el controlador determina cmo se debe mostrar al usuario el resultado de la peticin. Hay varias posibilidades: Finalizar la peticin mostrando la pgina jsp que origin la peticin, que es la opcin por defecto. Mostrando otra pgina jsp diferente. Envindo al usuario una peticin de redireccin, por lo que el navegador del usuario se dirigir automticamente a otra pgina cuando reciba la respuesta a su peticin. Este mecanismo de navegacin se implementa de manera sencilla en la pgina JSF. Cuando el controlador JSF llama al mtodo asociado a la accin, este devuelve un valor de tipo String. Este valor es utilizado junto con las reglas de navegacin creadas en el fichero de configuracin de JSF para determinar la pgina que se debe enviar como respuesta al usuario. Las reglas de navegacin definen: La pgina de origen. Indica el jsp que origin la peticin. La etiqueta de destino. Es la cadena que identifica el destino. Esta cadena es devuelta por el mtodo del backbean que procesa la accin. La pgina de destino para cada etiqueta. Normalmente es el jsp el que procesar la peticin de salida, utilizando los datos que hay en la request y en la sesin. Si es un envo directo interno o una redireccin externa. En el primer caso la respuesta se generar en la misma peticin

mediante una redireccin interna a otro jsp o servlet. En el segundo caso se enviar como respuesta al navegador una instruccin de redireccin para que el navegador realice una nueva peticin de otra pgina. Adems las direcciones de origen admiten el * para que una misma regla sirva para mltiples pginas. Tambien se pueden poner reglas por defecto que se aplican a todas las peticiones.

Las etapas del procesamiento de la peticin


Para entender el procesamiento de una pgina JSF hay que entender el ciclo de vida de la peticin dentro del controlador JSF. Este ciclo de vida est compuesto de 6 fases (al menos en la versin actual, ya que se est preparando la versin 2.0 de JSF y esto podra cambiar) Durante el procesamiento de una peticin el controlador JSF realiza las siguientes etapas: 1. Restaurar los conponentes de la vista (restore view). En esta etapa el controlador construye en memoria la estructura de componentes de la pgina. Aplicar los valores de la peticin.. (apply request values). En esta etapa se recuperan los valores de la request y se asignan a los beans de la pgina. Procesamiento de las validaciones (process validations). Se verifican los parmetros de entrada segn un conjunto de reglas definidas en un fichero de configuracin. Actualizar los valores del modelo (update model values). Los valores ledos y validados son cargados en los beans. Invocacion a la aplicacin (invoke application). Se ejecutan las acciones y eventos solicitados para la pgina. Si es necesario se realiza la navegacin.

2.

3.

4. 5.

6.

Generacin de la pgina (render response). En esta fase se genera la pgina que ser enviada al usuario con todos sus elementos y valores actualizados.

Gestin de los beans


JSF gestiona automticamente la creacin y el acceso a los beans que utilizan las pginas jsp. Para ello el controlador determina qu beans utiliza la pgina y dnde debe almacenarlos. El fichero de configuracin JSF mapea los nombres cortos de los beans utilizados en las pginas con las clases java que los definen. Cuando se crean los beans?. JSF busca el bean cada vez que se menciona en la pgina, en el orden en que aparecen en la pgina. Si el bean no existe en el mbito, lo crea. Por tanto el orden de las expresiones EL determinan el orden de la creacin de los beans, si usamos ms de un bean en la pgina. Cmo se hace esto internamente?. Al procesar la pgina JSP, las etiquetas JSF aaden cdigo que busca el bean mencionado en cada expresin EL. Si el bean no existe en el mbito elegido (request, session o application) se crea uno nuevo, llamando a su constructor por defecto, y se asocia al mbito requerido. Este mecanismo es fundamental para la comprensin del procesamiento de la pgina, sobre todo si trabajamos con beans de mbito request. Mi recomendacin: ponle siempre logs a los constructores para saber el momento exacto de su ejecucin.

El lenguaje de expresiones EL
Para facilitar la visualizacin y recogida de los datos de los formularios JSF introduce un lenguaje de expresiones similar al introducido en jsp. De hecho a partir de JSF 1.2, mbos lenguajes de expresiones se han unificado. El lenguaje de expresiones permite acceder de manera muy sencilla a las propiedades de los backbeans. En una forma ms sencijla una xpresin EL se puede escribir como:

#{backbean.propiedad} Esto permite asignar o leer valores de las etiquetas JSF. Por ejemplo para escribir y leer valores se pueden usar las etiquetas JSF: <h:outputText value=#{backbean.propiedad} /> <h:inputTtxt value=#{backbean.propiedad} /> Otros ejemplos de expresiones seran: Expresin EL
bean.stringProperty bean.myBoolean bean.property.property2 bean.myhashmap[madrid]

Tipo de la propiedad
String boolean Property : Class, property 2, String Bean: class Myhashmap: HashMap (Map) Bean: class Myhashmap: HashMap (Map) Bean: class Myhashmap: HashMap (Map)

bean.myhashmap[madrid].property3

bean.myhashmap.madrid

Hay otras muchos tipos de expresiones EL, por ejemplo usando el operador ! o el operador empty. Describir el lenguaje EL es tema de un artculo...

El entorno FacesContext
Un backbean es una clase simple que no conoce nada del resto de la aplicacin. Para acceder al entorno JSF y en general al entorno de ejecucin en el que la clase se est ejecutando JSF prev el mecanismo de contexto JSF FacesContext. El FacesContext es una clase que sirve al bean de puente al exterior, ya que le permite acceder no solo al contexto JSF sino tambin al contexto HTTP. Esto permite al bean el acceso a los dems beans de la aplicacin, a las

propiedades de la aplicacin e incluso a la peticin HTTP que se est ejecutando. El uso del contexto FacesContext desde el bean es simple, ya que la clase FacesContext proporciona un mtodo que devuelve una referencia a la instancia JSF asociada a la peticin. El siguiente cdigo muestra un ejemplo de este acceso:

import javax.faces.context.ExternalContext; import javax.faces.context.FacesContext; import javax.servlet.http.HttpServletRequest; import javax.servlet.http.HttpSession;

//Con esto obtenemos el contexto FacesContext facesContext= FacesContext.getCurrentInstance();

//Con esto obtenemos la request HttpServletRequest request = (HttpServletRequest) facesContext; .getExternalContext().getRequest();

//Con esto obtenemos la lista de nombres de los parmetros enviados // en la request Enumeration params = request.getParameterNames();

//Acceso a la sesin http HttpSession sessio = request.getSession();

Estudiando las diferentes APIs involucradas en la gestin del contexto jsf, la peticin (request), la respuesta (response) y la aplicacin (Application) obtenidas desde facesContext podremos realizar otras tareas avanzadas en JSF.

Acceso a los beans de la aplicacin


El contexto FacesContext permite a la aplicacin acceder a los beans que se encuentran en los diferentes mbitos (request, session y application). El mtodo de acceso ha variado segn la versin del framework JSF. Para la versin 1.1 se puede usar el siguiente cdigo: // obtiene el bean mybean de clase MyBean FacesContext facesContext = FacesContext.getCurrentInstance();

MyBean myBean = (MyBean) facesContext.getApplication() .getVariableResolver().resolveVariable(facesContext, "myBean");

Para MyFaces 1.2.5 se usa el cdigo siguiente:


public Object getBean(String beanName) { FacesContext facesContext = FacesContext.getCurrentInstance(); return facesContext.getApplication().createValueBinding("#{" + beanName + "}").getValue(facesContext); }

El mtodo oficial para acceder a un bean en JSF 1.2, segn cdigo de ejemplo de Sun es:
/** Nueva forma de obtener un bean en JSF 1.2 */

=" CLASS="msonormal" STYLE="margin-bottom: 0.5cm; border: 1.00pt solid #00000


public Object getBeanNuevo(String beanName) { FacesContext facesContext = FacesContext.getCurrentInstance(); //Este es el mtodo correcto segn define el api RI de Sun

javax.el.ELContext elContext = facesContext. getELContext(); javax.el.ExpressionFactory ef = .getExpressionFactory(); javax.el.ValueExpression ve = ef.createValueExpression(elContext, "#{InstallationBean}", return ve.getValue(elContext); }

facesContext.getApplicati

De esta forma podemos obtener el bean que necesitamos. Esto se usa fundamentalmente dentro de los mtodos de los beans que ejecutan las acciones. Ya que los backbeans de las aplicaciones JSF no implementan ninguna interfaz especial y los mtodos de las acciones no reciben parmetros, sin la ayuda del contexto FacesContext no podran comunicarse con otros beans de la aplicacin. El ejemplo ms sencillo de acceso a otros bean consiste en preparar el bean para la jsp que procesa una peticin JSF. Supongamos una pgina JSP que tiene un botn cuya accin nos va a llevar a otra pgina diferente. Si ambas pginas comparten el mismo backbean, el paso de la informacin de una a otra es sencillo. Basta que o bien pongamos el bean en la sesin o bien pasemos todos las propiedades del bean como inputs. Al ejecutar la accin se llamar al mtodo del bean que es responsable de su ejecucin, y en este mtodo podremos fijar los valores de las propiedades que utilizar la pgina de salida. Pero podra ocurrir que ambas pginas tuviesen backbeans diferentes. Entonces, antes de finalizar el mtodo de la accin debemos preparar el bean de la segunda pgina. Para ello se utilizan

los mtodos antes presentados (getBean y getBeanNuevo), que nos permitirn recuperar o crear el bean que necesita la pgina de salida. Una vez que tenemos el bean es fcil asignarle valores a sus propiedades. Un ejemplo sencillo podra ser el siguiente:

public String cambiar() {

//Creamos un bean en la request externo // al bean actual Ejemplo6b ejemplo6b = (Ejemplo6b) getBean("ejemplo6b");

//fijamos propiedades de este bean ejemplo6b.setNombre("un nuevo nombre");

//Cuando el controlador navege al jsp de salida ejemplo6b // no construir un nuevo bean, ya que existir en // la request return "ejemplo6b"; }

Donde suponemos que tenemos dos pginas ejemplo6.jsp y ejemplo6b.jsp, cada una de ellas con el backbean ejemplo6 o ejemplo6b, que son objetos de clase Ejemplo6 y Ejemplo6b que se han declarado en el faces-config.xml as:

<!-- managed beans para ejemplo6 --> <managed-bean> <managed-bean-name>ejemplo6</managed-bean-name> <managed-bean-class> adictosaltrabajo.ejemplo6.Ejemplo6 </managed-bean-class> <managed-bean-scope>request</managed-bean-scope> </managed-bean> <managed-bean> <managed-bean-name>ejemplo6b</managed-bean-name> <managed-bean-class> adictosaltrabajo.ejemplo6.Ejemplo6b </managed-bean-class>

<managed-bean-scope>request</managed-bean-scope> </managed-bean>

Cmo seguir la pista a una peticin JSF


El punto ms oscuro cuanto de enfrentas por primera vez a una pgina JSF es determinar qu cdigo se est ejecutando y qu elementos intervienen en tu peticin. Vamos a escribir unas sencillas reglas que nos ayudarn a seguir el rastro de la peticin, y saber qu se est ejecutando. Hay dos tipos de peticiones importantes en JSF: Navegacin a una url con extensin JSF (normalmente *.jsf o *.faces). Este es el caso cuando escribimos en la URL del navegador una url que est controlada por JSF, por ejemplo siguiento el enlace de una pgina que estamos visitando. Ejecucin de una accin dentro de una pgina JSF. Este es el caso que se produce cuando pinchamos en un botn de una pgina de una aplicacin JSF.

Seguir la pista a peticiones .jsf


Este es el caso ms sencillo. Partimos de la URL que queremos investigar. En este caso la url nos da la pista de la pgina JSP que se ha cargado, ya que cada url de JSF debe tener asociada su correspondiente JSP. Analizando las expresiones EL de la pgina JSP encontraremos los beans que se cargan para construir la pgina, y el orden en que se llaman a sus propiedades.

Seguir la pista a acciones JSF


Este es el caso ms complejo. Partimos de una pgina que estamos visualizando y sabemos que se ha pulsado un botn. Lo primero que hay que tener en cuenta es que la URL que aparece en la barra del navegador no implica que sepamos cual es la JSP asociada a la pagna que estamos viendo. En efecto, si se ha producido una

navegacin, la URL que aparece es la origen de la peticin, pero no la de destino. Por tanto, para seguir la pista a una accin primero vamos a suponer que estamos en el caso en el que la JSP que estamos visualizando se corresponde con la URL de JSF que vemos en la barra del navegador. Para seguir la pista a la accin de un botn de esa pgina seguimos el siguiente mtodo: 1. Buscamos en la pgina JSP el cdigo del botn. Por ejemplo podra ser algo as:

<h:commandButton action="#{ejemplo3.enviar}" value="Enviar success o error" />

2. De la expresin EL de la accin del botn obtenemos el nombre del bean y el nombre del mtodo que ejecuta la accin. Normalmente las acciones sern del tipo #{beanName.actionName}, por lo que el nombre del bean sera beanName y el del mtodo que ejecutar la accin actionName. En el ejemplo anterior, el bean es ejemplo3 y el mtodo que se ejecutar es enviar. 3. Ahora buscamos la clase del bean. Para ello buscamos en el faces-config.xml el managed-bean que hemos encontrado. En nuestro ejemplo la seccin correspondiente indica, como vemos a continuacin, que el bean ejemplo3 se crea en el mbito request de la peticin y es de clase:
adictosaltrabajo.ejemplo3.Ejemplo3

<!-- managed beans para ejemplo3 --> <managed-bean> <managed-bean-name>ejemplo3</managed-bean-name> <managed-bean-clas> adictosaltrabajo.ejemplo3.Ejemplo3 </managed-bean-class> <managed-bean-scope>request</managed-bean-scope> </managed-bean>

4. Ahora localizamos en la clase Ejemplo3 el mtodo enviar, que ser un public String enviar()

public class Ejemplo3 { ...

public String enviar() {

//aqu ir la lgica de negocio de esta accin

return "success"; }

5. Tras seguir la pista a la lgica de negocio que veremos en el mtodo (el de ejemplo es muy simple, no aparece ninguna), nos fijamos en las sentencias return del mtodo, ya que son las que generan el valor de retorno del mtodo. En nuestro ejemplo tambin es muy simple, ya que slo contiene el return success. 6. Cuando hemos localizado la cadena de retorno, en nuestro casso success, buscamos en el facesconfig.xml la regla de navegacin cuya entrada sea el JSP inicial. En nuestro caso las reglas de navegacin para esta peticin son:

<!-- Reglas de navegacion para el ejemplo 3--> <navigation-rule> <from-view-id>/ejemplo3/ejemplo3.jsp</from-view-id>

<navigation-case> <from-outcome>success</from-outcome> <to-view-id>/ejemplo3/panelSuccess.jsp</to-view-id> </navigation-case> <navigation-case> <from-outcome>OK</from-outcome> <to-view-id>/ejemplo3/panelOk.jsp</to-view-id> </navigation-case> <navigation-case> <from-outcome>error</from-outcome> <to-view-id>/ejemplo3/panelError.jsp</to-view-id> </navigation-case> </navigation-rule>

7. la etiqueta from-view-id nos dice las JSP de entrada que sern controladas por esta regla de navegacin (puede contener caracteres comodn). Las etiquetas from-outcome nos dan los posibles valores de las cadenas retornadas por las acciones, y las etiquetas toview-id nos dan las JSP de salida correspondientes.

Estas dos etiquetas irn siempre en pares de etiquetas dentro de una etiqueta navigation-rule, que define una regla de navegacin. En nuestro ejemplo la cadena success lleva a la pgina
/ejemplo3/panelSuccess.jsp

8.

Ahora ya sabemos la pgina por la que saldr la accin. Slo nos resta echarle un vistazo a dicha pgina para saber los beans que se van a necesitar para su construccin.

En el caso ms complicado, la pgina que estamos viendo la hemos obtenido tras ejecutar varias acciones. Esto nos obligar a repetir el proceso anterior varias veces desde el inicio de la peticin para saber a qu pagina hemos llegado. Para evitarnos estos los conviene poner al principio de la pgina algn comentario en el propio cdigo fuente de la pgina que nos indique el JSP que estamos visualizando.

JSF frente a Struts


JSF es uno de los posibles frameworks que se pueden utiliar para crear aplicaciones web Java. Uno de los ms extendidos es Struts, un framework bien maduro, que sin embargo no forma parte del estndar J2EE. En esencia, Struts es un controlador MVC de tipo 2, en el que la accin del formulario se liga a una clase accin, que sigue el patrn comando de diseo (una clase que representa un comando). El controlador de Struts sigue a su vez el patron de controlador frontal, dirigiendo cada peticin solicitada a la clase accin que la procesa, y pasndole los datos de la peticin encapsulados en un objeto (patrn objeto valor). JSF se desarroll teniendo en mente Struts, ya que los impulsores de este desarrollo, en los que se encontraban gente como IBM y el propio creador de Struts, queran crear un nuevo framework ms potente. Prcticamente todo lo que se puede hacer con Struts tiene un

equivalente JSF (hay como siempre que adaptarse al modo de trabajo de JSF, no intentar clonar el comportamiento de Struts en JSF), pero adems utilizando JSF obtendremos una serie de ventajas: La arquitectura del controlador es ms avanzada y flexible. Podremos hacer algunas tareas avanzadas de manera sencilla (por ejemplo, utilizando phase listeners). JSF permite definir la navegacin no solo a travs de los mtodos de navegacin de los beans, sino incluso en la propia pgina (navegacin definida en los componentes de la pgina). JSF permite recoger los parmetros del formulario de manera ms sencilla que Struts, e incorpora un lenguaje de expresiones que lo hace ms simple. JSF soporta la creacin de manejadores de eventos asociados a los componentes de la pgina, lo que dota a dichos componentes de gran potencia. Un ejemplo: creacin de combos enlazados, en los que la eleccin de un elemento en el primer combo obliga a recalcular los elementos disponibles en el segundo combo, por ejemplo, en combos de paises y estados o ciudades. JSF est pensado para la creacin de interfaces de usuario avanzadas. Basta ver los nuevos frameworks extendidos JSF, como Apache MyFaces Trinidad y el resto de frameworks JSF con soporte AJAX. Em resumen, para los desarrolladores que han usado algn lenguaje visual (visual basic, delphi, swing, etc.) el modo de trabajo de JSF pronto les parecer cercano. Para un proyecto nuevo, la eleccin es sencilla, como dice el propio creador de Struts: utiliza JSF.

JSF y AJAX
JSF es un framework que lanza muchas peticiones al servidor. Para optimizar dicho dialogo estn empezando a aparecer

implementaciones de JSF que incorporan AJAX en sus etiquetas. Esto permite actualizar los componentes en el navegador del usuario de manera selectiva, sin necesidad de recargar la pgina completa. La combinacin JSF ajax dota a las pginas de gran dinamismo sin complicar el desarrollo, evitando el uso de javascript codificado a mano asegurando un mayor soporte a los navegadores web.

El futuro de JSF
El framework JSF forma parte importante del estndar java J2EE. De hecho se est preparando una nueva versin que traer numerosas novedades, sobre todo en lo que se refiere a su integracin con AJAX. Tambin se est comenzando a utilizar en numerosas aplicaciones empresariales, ya que permite crear pantallas de usuario bastante complejas con una cierta facilidad, aunque desde luego no es sencillo la primera vez que te enfrentas a este framework. En la nueva versin se espera una mejora sobre el control de las fases del ciclo de vida de la peticin que faciliten la creacin de componentes JSF complejos que se usan de manera simple. En un artculo posterior intentar poneros ejemplos de aplicaciones basadas en JSF y AJAX utilizando alguno de los frameworks ms importantes, como puede ser MyFaces Trinidad o IceFaces.

Conclusin
Este artculo sirve de introduccin al framework JSF. Ser complementado con otro artculo que incluir una aplicacin de ejemplo lista para funcionar que explicar muchas de las tcnicas fundamentales de creacin de aplicaciones JSF. Espero que con este artculo y echando un vistazo a aplicaciones JSF ya desarrolladas os podais hacer una idea de sus posibles aplicaciones, as como de su potencia. Un consejo, una vez que comenceis a desarrollar una aplicacin de gran envergadura con JSF os dareis rpidamente cuenta que con el API JSF bsico no vais muy lejos. En mi caso llevo bastante tiempo usando MyFaces Tomahawk y la verdad es que es bastante potente, eliminando bastantes de las restricciones que impone el JSF Core

Tags, y que aade etiquetas bastante tiles.

You might also like