Tutoriales simples en Oracle ADF principiantes

Pueblos (principiantes Oracle ADF) que son todos de paso por esta calle,
aqu es una manera de empezar con tutoriales de inicio simples.

Oracle JDeveloper y Oracle ADF 11g Tutoriales

Construir Formas de clientes ricos con oscilacin ADF y ADF de Empresas
Componentes

Oracle JDeveloper 11g Release 2 (11.1. 2) Tutoriales

Oracle ADF 11g

DeskTop Integracin

http://www.roselen.com.ar/Tutoriales/oracle/htmls/capitulo1.html
http://plinioa.blogspot.com.ar/search/label/1.Curso%20ADF%2011g
http://adfsalvaje.blogspot.com.ar/p/blog-page_21.html
http://www.adictosaltrabajo.com/index.php?filter=tutorials&autor=10

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.
2. 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.
3. Procesamiento de las validaciones (process validations). Se verifican los parmetros de
entrada segn un conjunto de reglas definidas en un fichero de configuracin.
4. Actualizar los valores del modelo (update model values). Los valores ledos y validados son
cargados en los beans.
5. Invocacion a la aplicacin (invoke application). Se ejecutan las acciones y eventos solicitados
para la pgina. Si es necesario se realiza la navegacin.
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

Tipo de la propiedad

valor

bean.stringProperty

String

el valor del String

bean.myBoolean

boolean

true o false o su cadena t

bean.property.property2

Property : Class, property 2, String

El valor de la propiedad 2
property del bean

bean.myhashmap[madrid]

Bean: class

Devuelve el elemento de cla

hashmap myhashmap del bean

Myhashmap: HashMap (Map)

bean.myhashmap[madrid].property3

bean.myhashmap.madrid

Bean: class

Devuelve la propiedad prope

Myhashmap: HashMap (Map)

elemento de clave madrid

myhashmap del bean

Bean: class
Myhashmap: HashMap (Map)

Devuelve el elemento de cla

hashmap myhashmap del bean
acceder)

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()
beanName +

.createValueBinding

"}").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 #000000; padding: 0.05cm
0.19cm">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 =

facesContext.getAp

.getExpressionFactory();
javax.el.ValueExpression ve =
ef.createValueExpression(elContext, "#{InstallationBean}",

Object.class);

return ve.getValue(elContext);
}

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