Curso de Java Server Faces 2 Con Hibernate 3

Curso de
Java Server Faces 2

con Hibernate 3
Manual del alumno
<JSF 2>
<Hibernate 3>
Docente: Cdric Simon Versin 1.1

S
o
l
u
c
i
o
n
J
a
v
a
.
c
o
m

I
n
g
.

C
e
d
r
i
c

S
i
m
o
n

T
e
l
:

2
2
6
8

0
9
7
4

C
e
l
:

8
8
8
8

2
3
8
7

E
m
a
i
l
:

c
e
d
r
i
c
@
s
o
l
u
c
i
o
n
j
a
v
a
.
c
o
m

W
e
b
:

w
w
w
.
s
o
l
u
c
i
o
n
j
a
v
a
.
c
o
m
Curso de JSF 2 con Hibernate 3 Pagina 2 / 68
ndice
ndice .................................................................................................................................................................................... 2
1 Introduccin al curso ......................................................................................................................................................... 5
1.1 Objetivo de este curso ................................................................................................................................................ 5
1.2 Manual del alumno ..................................................................................................................................................... 5
1.3 Ejercicios prcticos .................................................................................................................................................... 5
1.4 Requisitos para atender a este curso ........................................................................................................................ 5
1.5 Soporte despus del curso .......................................................................................................................................... 5
2 Introduccin a Java Server Faces ..................................................................................................................................... 6
2.1 !"ue es #S$% ............................................................................................................................................................... &
2.2 Servidor ' (erramientas utili)ados ........................................................................................................................... &
2.3 *rear una aplicaci+n en ,et-eans ............................................................................................................................ .
2.4 *rear una aplicaci+n en Eclipse ................................................................................................................................ /
2.5 0rimera p1ina #S$ ................................................................................................................................................... 2
2.& Recuperando in3ormaciones del c+di1o #ava ......................................................................................................... 11
3 Aplicaciones JSF ............................................................................................................................................................. 12
3.1 !"u es una aplicaci+n #avaServer $aces% ............................................................................................................ 12
3.2 Modelo de componentes de inter3a) de usuario ..................................................................................................... 12
3.3 4as clases de componentes de inter3a) de usuario ................................................................................................ 12
3.4 *onversi+n de Modelo ............................................................................................................................................. 15
3.5 Evento ' el o'ente de modelo .................................................................................................................................. 1&
1.1 5alidaci+n ................................................................................................................................................................. 1.
3.& Modelo de nave1aci+n .............................................................................................................................................. 1.
3.6.1 Configuracin de reglas de navegacin .............................................................................................................. 17
3.6.2 Reglas de navegacin implcitas ......................................................................................................................... 19
3.. -ac6ed -eans ............................................................................................................................................................ 27
3.7.1 Crear una clase de backed bean ........................................................................................................................... 2
3.7.2 Configuracin de un !ean ................................................................................................................................... 21
3./ 8sando el E4 uni3icada para re3erenciar -ac6ed beans ...................................................................................... 21
3.".1 #l Ciclo de $ida de una p%gina &ava'erver (aces .............................................................................................. 22
3.".2 (ase de restauracin de vista ............................................................................................................................... 2)
3.".3 (ase de aplicacin de valores .............................................................................................................................. 2)
3.".) (ase de validaciones de proceso .......................................................................................................................... 2*
3.".* (ase de actuali+acin de valores de modelo ........................................................................................................ 2*
3.".6 (ase de invocacin de la aplicacin .................................................................................................................... 26
3.".7 (ase de creacin de la respuesta .......................................................................................................................... 26
4 Formularios ...................................................................................................................................................................... 27
4.1 $ormulario sencillo .................................................................................................................................................. 2.
4.2 $ormulario mas complejo ........................................................................................................................................ 2/
5 tml!ata"a#le ................................................................................................................................................................. 3$
6 %ensa&e de error personali'ados ..................................................................................................................................... 35
&.1 4ista de mensaje personali)ados ............................................................................................................................. 35
&.2 01ina de error personali)ada9 ............................................................................................................................... 35
Copyright Cdric Simon, 2009-2011 Versin 1.1 Reproduccin prohibida
7 (onvertidores ................................................................................................................................................................... 36
..1 !"u es un convertidor% .......................................................................................................................................... 3&
..2 8so de los convertidores .......................................................................................................................................... 3&
..3 *onvertidores incluidos ........................................................................................................................................... 3&
7.3.1 Convertidor ,ate-ime ......................................................................................................................................... 37
7.3.2 Convertidor de ./mero ....................................................................................................................................... 37
..4 *onvertidores personali)ados ................................................................................................................................. 32
) *alidadores ....................................................................................................................................................................... 42
/.1 8so ' *reaci+n de los validadores .......................................................................................................................... 42
/.2 5alidadores incluidos ............................................................................................................................................... 42
/.3 5alidaci+n a nivel de aplicaci+n .............................................................................................................................. 42
/.4 5alidadores personali)ados ..................................................................................................................................... 43
/.5 5alidador en -ac6ed -ean ...................................................................................................................................... 44
+ (omponentes personali'ados ........................................................................................................................................... 45
2.1 *reaci+n de componentes personali)ados para #S$ ............................................................................................. 45
9.1.1 #l Componente .................................................................................................................................................... )6
9.1.2 Renderer .............................................................................................................................................................. )7
9.1.3 -ag ....................................................................................................................................................................... )9
9.1.) 0nline Renderer ................................................................................................................................................... *1
2.2 *omponentes personali)ados para $acelets .......................................................................................................... 52
1$ (omponentes JSF para A&a, ......................................................................................................................................... 54
17.1 !*+mo #S$ ' :ja; pueden trabajar juntos% ....................................................................................................... 54
17.2 8tili)ar el <:ja;= #avaScript en su p1ina #S$ .................................................................................................... 54
1.2.1 1ros .................................................................................................................................................................... *)
1.2.2 Contras .............................................................................................................................................................. *)
17.3 0oner su c+di1o de :ja; #avaScript en los componentes #S$ ............................................................................ 54
1.3.1 1ros .................................................................................................................................................................... *)
1.3.2 Contras .............................................................................................................................................................. *)
17.4 :provec(ar la creciente colecci+n de marcos de trabajo :ja; #S$ .................................................................. 55
1.).1 1ros .................................................................................................................................................................... **
1.).2 Contras .............................................................................................................................................................. **
17.5 8tili)ar el nuevo ta1 >39aja;? ................................................................................................................................ 55
1.*.1 1ros .................................................................................................................................................................... **
1.*.2 Contras .............................................................................................................................................................. **
1.*.3 21or 3u4 el 56a7 en &'(8 ................................................................................................................................... **
1.*.3.1 $enta6as de un enfo3ue especfico &'( 56a7 ............................................................................................. **
1.*.) 9so del tag :f;a6a7< .......................................................................................................................................... *6
1.*.).1 #6emplo sencillo ......................................................................................................................................... *6
1.*.).2 renderer; #specificacin de los elementos de actuali+acin en el cliente .................................................. *7
1.*.).3 e7ecute; #specificacin de los elementos a procesar en servidor .............................................................. *7
1.*.).) event; mencionar a cual evento de usuario debe disparar la llamada 56a7 ................................................ *"
11 i#ernate ........................................................................................................................................................................ 5+
11.1 @ntroducci+n ............................................................................................................................................................ 52
11.2 @nstalaci+n ............................................................................................................................................................... 52
11.3 *on3i1uraci+n ......................................................................................................................................................... 52
11.4 8tili)aci+n ............................................................................................................................................................... 52
11.).1 #&!3 para la table cit= ....................................................................................................................................... *9
11.).2 >ibernate>elper ................................................................................................................................................ 6
11.).3 1rueba de uso de >ibernate desde &ava ............................................................................................................. 61
11.5 Aibernate "uer' 4an1ua1e ................................................................................................................................... &3
11.& Aibernate con #S$ .................................................................................................................................................. &3
11.6.1 Clase ,5? ........................................................................................................................................................ 63
11.6.2 5cceso desde &'( .............................................................................................................................................. 6*
1 Introduccin al curso
1.1 Objetivo de este curso
En este curso vamos a aprender el lenguaje JSF que nos permitir crear pginas web dinmicas.
1.2 Manual del alumno
Este manual del alumno es una ayuda para el alumno, para tenga un recuerdo del curso. Este manual
contiene un resumen de las materias que se van a estudiar durante el curso, pero el alumno debera de
tomar notas personales para completas este manual.
1.3 Ejercicios prcticos
Para captar mejor la teora, se harn muchos ejercicios con los alumnos, para probar la teora y verificar
la integracin de la materia.

Tambin, el alumno podr copiar sus cdigos en un disquete al fin del curso para llevarse, con fin de
seguir la prctica en su hogar.
1.4 Requisitos para atender a este curso
Una buen conocimiento de los lenguajes Java, JSP, HTML, y Javascript es requerida para seguir este
curso. La creacin y el manejo de objetos Java as como el JSP estn considerada cmo asimilado antes
de empezar este curso.
Si el alumno tiene dificultades en un u otro capitulo, el debe sentirse libre de pedir explicaciones
adicionales al profesor.
Pero si aparece que el alumno no posee los requisitos mnimos para este curso, por respeto a los otros
alumnos que ya poseen esta materia, el alumno podra ser traslado para otro curso en el futuro, cuando
el cumplir con los requisitos.
1.5 Soporte despus del curso
Si tienes preguntas sobre la materia del curso en tus ejercicios prcticos, puedes escribir tus
preguntas a cedric@solucionjava.com.
Para informaciones sobre otros cursos, visita el sitio web www.solucionjava.com.
2 Introduccin a Java Server Faces
2.1 Que es JSF?
JavaServer Faces (JSF) es un tecnologa y framework para aplicaciones Java basadas en web que
simplifica el desarrollo de interfaces de usuario en aplicaciones Java EE.
JSF usa JavaServer Pages (JSP) como la tecnologa que permite hacer el despliegue de las pginas, pero
tambin se puede acomodar a otras tecnologas como XUL.
JSF incluye:
Un conjunto de APIs para representar componentes de una interfaz de usuario y administrar su
estado, manejar eventos, validar entrada, definir un esquema de navegacin de las pginas y dar
soporte para internacionalizacin y accesibilidad.
Un conjunto por defecto de componentes para la interfaz de usuario.
Dos bibliotecas de etiquetas personalizadas para JavaServer Pages que permiten expresar una
interfaz JavaServer Faces dentro de una pgina JSP.
Un modelo de eventos en el lado del servidor.
Administracin de estados.
Beans administrados.
La especificacin de JSF fue desarrollada por la Java Community Process
Versiones de JSF:
JSF 1.0 (11-03-2004) - lanzamiento inicial de las especificaciones de JSF.
JSF 1.1 (27-05-2004) - lanzamiento que solucionaba errores. Sin cambios en las especificaciones
ni en el renderkit de HTML.
JSF 1.2 (11-05-2006) - lanzamiento con mejoras y correccin de errores.
JSF 2.0 (12-08-2009) - ltimo lanzamiento.
Las principales implementaciones de JSF son:
JSF Reference Implementation de Sun Microsystems.
MyFaces proyecto de Apache Software Foundation.
Rich Faces, de Jboss. Trae componentes adicionales para crear aplicaciones ms ricas
ICEfaces Contiene diversos componentes para interfaces de usuarios ms enriquecidas, tales
como editores de texto enriquecidos, reproductores de multimedia, entre otros.
jQuery4jsf Contiene diversos componentes sobre la base de uno de los ms populares framework
javascript jQuery.
2.2 Servidor y herramientas utilizados
Java Server Faces 2.0 es una tecnologa nueva, y necesita las ltimas versiones de las herramientas de
desarrollo y servidores web para poder usarla.
A nivel de herramientas, las ms utilizadas son Eclipse y NetBeans. En el curso usaremos NetBeans
versin 6.8 o arriba.
A nivel de servidores web, servidores como Apache Tomcat 6+, Jboss 5+, o GlassFish 3 soportan JSF 2.0.
2.3 Crear una aplicacin en NetBeans
Se requiere NetBeans 6.8 o arriba. Escoge de crear un nuevo proyecto.
Agregamos la librera JSF 2.0 al servidor.
Iniciamos el servidor web y desplegamos la aplicacin.
Miramos el resultado en http://localhost:8080/CursoJSF-war
Por el momento solo estamos mirando a una pgina JSP, nada de JSF.
2.4 Crear una aplicacin en Eclipse
Se requiere Eclipse 3.6SR1 o arriba. Para utilizar Jboss 6, se requiere en plugin de Jboss Tools.
Escogemos de crear un nuevo proyecto Web Dinmico.
Creamos una pgina index.jsp debajo de WebContent, e iniciamos el servidor web desplegando la
aplicacin.
Miramos el resultado en http://localhost:8080/CursoJSF20
2.5 Primera pgina JSF
Las pginas JSF son pginas JSP con unas libreras Taglib adicionales.
Ademas, las pginas JSP no se llaman directamente, pero se llaman a travs del motor JSF. Para llamar
a la pgina JSF, basta con agregar /faces/ antes el nombre de la pgina.
http://localhost:8080/CursoJSF-war/faces/index.jsp
Como lo vemos, una pgina JSP (sin cdigo JSF) puede ser llamada sin problema.
La configuracin del reenvo se puede personalizar (por carpeta y/o por extensin) en web.xml:
<servlet>
<servlet-name>Faces Servlet</servlet-name>
<servlet-class>javax.faces.webapp.FacesServlet</servlet-class>
<load-on-startup>1</load-on-startup>
</servlet>
<servlet-mapping>
<servlet-name>Faces Servlet</servlet-name>
<url-pattern>/faces/*</url-pattern>
</servlet-mapping>
Cuando creamos una nueva pgina JSF, podemos
escoger entre dos tipos de sintaxis: Facelets o JSP.
Facelets usa un formato XML (XHTML), y JSP
usa... el formato JSP.
El JSF usa pginas JSP o XHTML, un archivo de
configuracin XML (faces-config.xml), y Java
POJO's.
A partir de JSF 2.0, el formato XML es el estndar.
Agregamos el archivo de configuracin.
Ahora que tenemos todo listo, creamos nuestra primera pgina JSF, usando la opcin JSP:
<!page content"#pe$%text/&tml% page'ncoding$%("F-
)%>
<!taglib prefix$%f%
uri$%&ttp*//java.sun.com/jsf/core%>
<!taglib prefix$%&%
uri$%&ttp*//java.sun.com/jsf/&tml%>
<+,-."/0' 1"23 0(435. %-//67.//,", 1"23 8.91
"ransitional//':%
%&ttp*//www.w7.org/";/&tml8/loose.dtd%>
<f*view>
<&tml>
<&ead>
<meta &ttp-e<uiv$%.ontent-"#pe%
content$%text/&tml= c&arset$("F-)%/>
<title>2i primera pagina >S0</title>
</&ead>
<bod#>
<&1><&*output"ext value$%1ola
alumno+%/></&1>
</bod#>
</&tml>
</f*view>
El cdigo JSF en la pgina JSP se debe encontrar entre los tags <f:view> y </f:view>.
Como podemos ver, se incluyen las dos libreras Taglib, que se usan luego, con las etiquetas <f: > y <h: >.
Si usamos el formato XHTML, todo el contenido se considera JSF.
<?xml version$@1.9@ encoding$@("F-)@ ?>
<+,-."/0' &tml 0(435. %-//67.//,", A1"23 1.9 "ransitional//':%
%&ttp*//www.w7.org/";/x&tml1/,",/x&tml1-transitional.dtd%>
<&tml xmlns$%&ttp*//www.w7.org/1BBB/x&tml%
xmlns*&$%&ttp*//java.sun.com/jsf/&tml%>
<&*bod#>
<&1>1ello alumno +++</&1>
</&*bod#>
</&tml>
La biblioteca <h: > contiene equivalentes del HTML, ya sea formularios, botones, cajas de texto,
imgenes, etc...
En el futuro usaremos los Facelets y no mas el JSP.
2.6 Recuperando informaciones del cdigo Java
Vamos a crear una clase Java (JSF Backed Bean) Hello y llamarla desde nuestra pgina JSF.
pacCage curso.beans=
import javax.faces.bean.2anaged4ean=
import javax.faces.bean.;e<uestScoped=
!2anaged4eanDname$%1ello%E
!;e<uestScoped
public class 1ello F
private String nombre$%:o inicialiGado%=
public 1elloDE F
H
public String get:ombreDEF
return nombre=
H
public void set:ombreDString nombreE F
t&is.nombre $ nombre=
H
H
Y modificamos la pgina index.xhtml:
<&1>1ello IF1ello.nombreH +++</&1>
En el futuro usaremos el formato XHTML, y no incluir las etiquetas <xml>, <DOCTYPE> ni <html>,
que sern los siguientes:
xmlns*f$%&ttp*//java.sun.com/jsf/core%
xmlns*&$%&ttp*//java.sun.com/jsf/&tml%
xmlns*ui$%&ttp*//java.sun.com/jsf/facelets%
>
3 Aplicaciones JSF
3.1 Qu es una aplicacin JavaServer Faces?
En su mayor parte, una aplicacin JavaServer Faces es como cualquier otra aplicacin Java Web. Una
aplicacin tpica de JavaServer Faces incluye las siguientes piezas:
Un conjunto de pginas web, en la que los componentes de interfaz de usuario son establecidos.
Un conjunto de bibliotecas de etiquetas proporcionar etiquetas para aadir componentes de
interfaz de usuario a la pgina web.
Un conjunto de Backed Bean, que son JavaBeans componentes que definen las propiedades y
funciones de los componentes de la interfaz de usuario en una pgina.
Opcionalmente, uno o ms ficheros de configuracin de la aplicacin de recursos (como faces-
config.xmlfile), que definen las normas de navegacin de la pgina y configura los beans y otros
objetos personalizados, tales como componentes personalizados.
Un descriptor de despliegue (un archivo web.xml).
Es posible que un conjunto de objetos personalizados creados por el desarrollador de aplicaciones.
Estos objetos pueden incluir componentes personalizados, validadores, convertidores, o los
oyentes.
Un conjunto de etiquetas personalizadas para representar los objetos personalizados en la
pgina.
3.2 Modelo de componentes de interfaz de usuario
JavaServer Faces componentes de interfaz de usuario (UI) son los bloques de construccin de vista de
JavaServer Faces.
JavaServer Faces componentes de interfaz de usuario son elementos configurables, reutilizables que
componen la interfaz de usuario de aplicaciones JavaServer Faces. Un componente puede ser simple,
como un botn, o pueden ser compuestos, tales como una tabla, compuesta de mltiples componentes.
La tecnologa JavaServer Faces proporciona una rica arquitectura de componentes flexibles que incluye
lo siguiente:
Un conjunto de clases UIComponent para especificar el estado y el comportamiento de los
componentes de la interfaz de usuario
Un modelo de representacin que define el modo de hacer los componentes de varias maneras
Un evento de escucha y el modelo que define cmo manejar los eventos de los componentes
Un modelo de conversin que define cmo registrar los convertidores de datos en un componente
Un modelo de validacin que define cmo registrar validadores en un componente
Esta seccin describe brevemente cada una de estas piezas de la arquitectura de componentes.
3.3 Las clases de componentes de interfaz de usuario
La tecnologa JavaServer Faces proporciona un conjunto de clases de componentes de interfaz de usuario
y de comportamiento asociados a las interfaces que especifican todas las funcionalidad de los
componentes de interfaz de usuario, como componente de participacin del estado, mantener una
referencia a los objetos, y un evento de conduccin y manejo de la prestacin de un conjunto de
componentes estndar.
Las clases de componentes son totalmente extensible, permitiendo a los escritores de componentes para
crear sus propios componentes personalizados. Creacin de componentes personalizados es un tema
avanzado que veremos ms tarde.
La clase base abstracta para todos los componentes de interfaz de usuario es
javax.faces.component.UIComponent.
Las clases de componentes de interfaz de usuario amplian la clase UIComponentBase, (una subclase de
la clase UIComponent), que define el estado por defecto y el comportamiento de un componente de
interfaz de usuario. El siguiente conjunto de clases de componentes de interfaz de usuario se incluye con
la tecnologa JavaServer Faces:
UIColumn: Representa una sola columna de datos en un componente UIData.
UICommand: Representa un control que inicia acciones cuando se activa.
UIData: Representa un enlace de datos a una coleccin de datos representados por una instancia
dataModel.
UIForm: Encapsula un grupo de controles que enviar datos a la aplicacin. Este componente es
anlogo a la etiqueta de formulario en HTML.
UIGraphic: Muestra una imagen.
UIInput: Toma de entrada de datos de un usuario. Esta clase es una subclase de UIOutput.
UIMessage: Muestra un mensaje de error traducidos.
UIMessages: Muestra un conjunto de mensajes de error traducidos.
UIOutcomeTarget: Muestra un hipervnculo en la forma de un vnculo o un botn.
UIOutput: Muestra la salida de datos en una pgina.
UIPanel: administra el diseo de sus componentes nio.
UIParameter: Representa los parmetros de sustitucin.
UISelectBoolean: Permite al usuario establecer un valor booleano en un control de seleccin y
anulacin de ella. Esta clase es una subclase de la clase UIInput.
UISelectItem: Representa un solo elemento en un conjunto de elementos.
UISelectItems: Representa todo un conjunto de elementos.
UISelectMany: Permite al usuario seleccionar varios elementos de un grupo de elementos. Esta
clase es una subclase de la clase UIInput.
UISelectOne: Permite al usuario seleccionar un elemento de un grupo de elementos. Esta clase
es una subclase de la clase UIInput.
UIViewParameter: Representa los parmetros de consulta en una solicitud. Esta clase es una
subclase de la clase UIInput.
UIViewRoot: Representa la raz del rbol de componentes.
Adems de ampliar UIComponentBase, las clases de componente tambin aplicar una o ms interfaces
de comportamiento, cada uno de los cuales define cierto comportamiento de un conjunto de componentes
cuyas clases implementan la interfaz.
Estas interfaces de comportamiento son las siguientes:
ActionSource: Indica que el componente puede desencadenar un evento de accin. Esta interfaz
est diseado para utilizarse con componentes basados en la tecnologa JavaServer Faces 1.1_01
y versiones anteriores.
ActionSource2: Extiende ActionSource, y por lo tanto proporciona la misma funcionalidad. Sin
embargo, se permite a los componentes a utilizar el EL unificado cuando se hace referencia a los
mtodos para controlar los eventos de accin.
EditableValueHolder: Extiende ValueHolder y especifica las caractersticas adicionales para los
componentes modificable, como la validacin y emitir los eventos de cambio de valor.
NamingContainer: los mandatos que cada componente de raz en este componente tiene una
identificacin nica.
StateHolder: Indica que un componente ha estado que deben guardar entre las solicitudes.
ValueHolder: Indica que el componente mantiene un valor local, as como la posibilidad de
acceder a los datos en el nivel de modelo.
SystemEventListenerHolder: Mantiene una lista de casos SystemEventListener para cada tipo
de SystemEvent definido por esa clase.
ClientBehaviorHolder: aade la capacidad de unir los casos ClientBehavior como una secuencia
de comandos reutilizables.
Cada etiqueta personalizada definida en el estndar HTML hacer kit se compone de la funcionalidad de
los componentes (definidos en la clase UIComponent) y la prestacin de atributos (definidos por la clase
Renderer).
Lista de etiquetas UI Component
Tag Funciones Rendered As Apariencia
column ;epresenta una columna de
datos en un componente
(5,ata
J column of data in an 1"23
table
(na columna de una
tabla
command4utton 'nvKa un formulario para la
solicitud
Jn 1"23 <input t#pe$t#pe>
elementL w&ere t&e t#pe value
can be submitL resetL or
image
(n botMn
command3inC 'nlaces a otra pNgina o
ubicaciMn en una pNgina
Jn 1"23 <a &ref> element (n &ipervKnculo
data"able ;epresenta un contenedor de
datos
Jn 1"23 <table> element (na tabla <ue se
pueden actualiGar de
forma dinNmica
form ;epresenta una forma de
entrada Deti<uetas internas
de la forma recibir los
datos <ue se presentarN con
el formularioE
Jn 1"23 <form> element :o aparece
grap&ic5mage 2uestra una imagen Jn 1"23 <img> element (na imagen
input1idden 0ermite a un autor de la
pNgina incluir una variable
oculta en una pNgina
Jn 1"23 <input t#pe$&idden>
element
:o aparece
inputSecret 0ermite al usuario
introducir una cadena sin la
cadena aparece en claro en
el campo
Jn 1"23 <input t#pe$password>
element
(n campo de textoL
<ue muestra una fila
de estrellas en
lugar de la cadena
real <ue &a#a
entrado
input"ext 0ermite al usuario
introducir una cadena
Jn 1"23 <input t#pe$text>
element
(n campo de texto
input"extarea 0ermite a un usuario
introducir una cadena de
varias lKneas
Jn 1"23 <textarea> element (n campo de texto de
varias lineas
message 2uestra un mensaje
localiGado
Jn 1"23 <span> tag if st#les
are used
(na cadena de texto
messages 2uestra los mensajes
localiGados
J set of 1"23 <span> tags if
st#les are used
(na cadena de texto
outputFormat 2uestra un mensaje
localiGado
0lain text "exto sin formato
output3abel 2uestra un componente
anidado como una eti<ueta
para un campo de entrada
especificado
Jn 1"23 <label> element "exto sin formato
output3inC 'nlaces a otra pNgina o
ubicaciMn en una pNgina sin
<ue se genere un evento de
Jn 1"23 <a> element (n &ipervKnculo
acciMn
output"ext 2uestra una lKnea de texto 0lain text "exto sin formato
panelOrid 2uestra una tabla Jn 1"23 <table> element wit&
<tr> and <td> elements
(na tabla
panelOroup Orupos de un conjunto de
componentes en uno de los
padres
J 1"23 <div> or <span>
element
(na fila de una
tabla de
select4oolean.&ecC
box
0ermite a un usuario cambiar
el valor de una opciMn
boleana
Jn 1"23 <input t#pe$c&ecCbox>
element.
(na casilla de
verificaciMn
select5tem ;epresenta un elemento en
una lista de elementos en un
componente (5Select-ne
Jn 1"23 <option> element :o aparece
select5tems ;epresenta una lista de
elementos en un componente
(5Select-ne
J list of 1"23 <option>
elements
:o aparece
select2an#.&ecCbox 2uestra un conjunto de
casillas de verificaciMn de
<ue el usuario puede
seleccionar varios valores
J set of 1"23 <input>
elements of t#pe c&ecCbox
(n conjunto de
casillas de
verificaciMn
select2an#3istbox 0ermite al usuario
seleccionar varios elementos
de un conjunto de elementosL
todos muestran a la veG
Jn 1"23 <select> element (n cuadro de lista
select2an#2enu 0ermite al usuario
seleccionar varios elementos
de un conjunto de elementos
Jn 1"23 <select> element (n cuadro combinado
desplaGable
select-ne3istbox 0ermite a un usuario para
seleccionar un elemento de
un conjunto de elementosL
todos muestran a la veG
Jn 1"23 <select> element (n cuadro de lista
select-ne2enu 0ermite a un usuario para
un conjunto de elementos
Jn 1"23 <select> element (n cuadro combinado
desplaGable
select-ne;adio 0ermite a un usuario para
un conjunto de elementos
Jn 1"23 <input t#pe$radio>
element
(n conjunto de
botones de radio
3.4 Conversin de Modelo
Una aplicacin JavaServer Faces, opcionalmente, se puede asociar con un componente de servidor de
datos de objetos secundarios. Este objeto es un componente JavaBeans, llamado BackedBean. Una
aplicacin obtiene y establece el objeto de datos para un componente llamando a las propiedades de
objeto apropiado para ese componente.
Cuando un componente est asociado a un objeto, la aplicacin tiene dos puntos de vista de los datos del
componente:
El punto de vista del modelo, en el que se representan los datos como tipos de datos, tales como
int o long.
La vista de presentacin, en el que se representan los datos de una manera que puede ser ledo o
modificado por el usuario. Por ejemplo, un java.util.Date puede ser representada como una
cadena de texto en el formato mm / dd / aa o como un conjunto de tres cadenas de texto.
La implementacin de JavaServer Faces convierte automticamente datos de los componentes entre
estos dos puntos de vista cuando la propiedad de bean asociados con el componente de uno de los tipos
soportados por los datos del componente.
Por ejemplo, si un componente de UISelectBoolean se asocia con una propiedad de bean de
java.lang.Boolean tipo, la implementacin JavaServer Faces se convertir automticamente los datos del
componente de la cadena en Boolean. Adems, algunos datos de los componentes deben estar vinculadas
a las propiedades de un tipo particular. Por ejemplo, un componente UISelectBoolean debe estar
enlazado a una propiedad de tipo boolean o java.lang.Boolean.
A veces puede que desee convertir los datos de un componente a un tipo distinto de un tipo estndar, o
puede que desee convertir el formato de los datos. Para facilitar esto, la tecnologa JavaServer Faces le
permite registrar la aplicacin Converter en componentes UIOutput y componentes cuyas clases
UIOutput subclase. Si se registra la aplicacin Converter en un componente, la aplicacin Converter
convierte los datos del componente entre los dos puntos de vista.
Puede utilizar los convertidores estndar suministrados con la implementacin JavaServer Faces o crear
su propio convertidor personalizado. La creacin de convertidor personalizado es un tema avanzado que
se ver ms adelante.
3.5 Evento y el oyente de modelo
JavaServer Faces 2.0 define tres tipos de eventos: los eventos de aplicacin, los eventos del sistema y los
datos de eventos de modelo.
Eventos de aplicacin estn vinculados a una aplicacin en particular y son generados por un
UIComponent. Ellos representan el estndar de eventos disponibles en versiones anteriores de la
tecnologa JavaServer Faces.
Un objeto de evento identifica el componente que gener el evento y almacena informacin sobre el
evento. Para ser notificado de un evento, una aplicacin debe proporcionar una implementacin de la
clase de escucha y debe registrarlo en el componente que genera el evento. Cuando el usuario activa un
componente, por ejemplo, hacer clic en un botn, se dispara un evento. Esto hace que la implementacin
JavaServer Faces para invocar el mtodo de escucha que procesa el evento.
JavaServer Faces soporta dos tipos de eventos de aplicacin: eventos de accin y eventos de cambio de
valor.
Un evento de accin (ActionEvent clase) se produce cuando el usuario activa un componente que
implemente ActionSource. Estos componentes incluyen botones y los hipervnculos.
Un evento de cambio de valor (ValueChangeEvent clase) se produce cuando el usuario cambia el valor de
un componente representada por UIInput o uno de sus subclases. Un ejemplo es la seleccin de una
casilla de verificacin, una accin que resulta en el valor del componente est cambiando a true. Los
tipos de componentes que puede generar este tipo de eventos son los UIInput, UISelectOne,
UISelectMany, y los componentes de UISelectBoolean. Valor eventos de cambio son despedidos slo si no
se detectaron errores de validacin.
Los sucesos del sistema son generados por un objeto en lugar de un UIComponent. Que se generan
durante la ejecucin de una aplicacin en tiempos predefinidos. Son aplicables a toda la aplicacin en
lugar de a un componente especfico.
Un modelo de datos de eventos se produce cuando se selecciona una nueva fila de un componente de
UIData.
Los sucesos del sistema y los datos de eventos de modelo son temas avanzados que se mirarn ms tarde.
1.1 Validacin
La tecnologa JavaServer Faces soporta un mecanismo para la validacin de los datos locales de los
componentes modificables (como los campos de texto). Esta validacin se produce antes de que el modelo
de datos correspondiente se actualiza para que coincida con el valor local.
Al igual que el modelo de conversin, el modelo de validacin define un conjunto de clases estndar para
la realizacin de comprobaciones de validacin de datos comunes. La etiqueta de JavaServer Faces
ncleo biblioteca tambin define un conjunto de etiquetas que corresponden a las implementaciones
estndar de Validator.
La mayora de las etiquetas tienen un conjunto de atributos para configurar las propiedades del
validador, tales como los valores mximo y mnimo permitidos para los datos del componente. Los
registros de autor es el validador en un componente por la etiqueta de anidacin del validador dentro de
la etiqueta del componente.
3.6 Modelo de navegacin
El modelo de navegacin JavaServer Faces hace que sea fcil de manejar cualquier procesamiento
adicional que se necesita para elegir la secuencia en la que se cargan las pginas.
En la tecnologa JavaServer Faces, la navegacin es un conjunto de reglas para la eleccin de la pgina
siguiente o la vista que se mostrar despus de una accin de aplicacin, como cuando un botn o
hipervnculo se hace clic.
Estas normas se declaran en cero o ms recursos de configuracin de la aplicacin, tales como <faces-
config.xml>, utilizando un conjunto de elementos XML. La estructura por defecto de una regla de
navegacin es el siguiente:
<navigation-rule>
<description>
</description>
<from-view-id></from-view-id>
<navigation-case>
<from-action></from-action>
<from-outcome></from-outcome>
<if></if>
<to-view-id></to-view-id>
</navigation-case>
</navigation-rule>
En JavaServer Faces 2.0, la navegacin puede ser implcito o definidos por el usuario. Las reglas de
navegacin implcitas entran en juego cuando las normas de navegacin no estn disponibles en un
archivo de configuracin de la aplicacin de recursos.
3.6.1 Configuracin de reglas de navegacin
Como se explica en el modelo de navegacin, la navegacin es un conjunto de reglas para la eleccin de la
siguiente pgina que se muestra despus de un botn o un componente de hipervnculo se hace clic.
Las reglas de navegacin se definen en el expediente de solicitud de recursos de configuracin.
Cada regla de navegacin especifica cmo navegar de una pgina a un conjunto de otras pginas. La
implementacin de JavaServer Faces elige la regla de navegacin adecuado de acuerdo a la pgina que
se muestra actualmente.
Despus de la regla de navegacin adecuado es seleccionado, la eleccin de que para acceder a la pgina
siguiente de la pgina actual depende de dos factores:
El mtodo de accin que se invoca cuando el componente se ha hecho clic
El resultado lgico que se hace referencia por el componente en la etiqueta , o fue devuelto por el
mtodo de accin
El resultado puede ser cualquier cosa que el desarrollador decide, pero la tabla aqu van algunos
resultados de uso comn en aplicaciones web.
Final Lo que significa comnmente
success Todo ha funcionado. Ir a la pgina siguiente.
failure Algo est mal. Ir a una pgina de error.
logon El usuario debe iniciar sesin primero. Ir a la pgina de inicio de sesin.
no results La bsqueda no encontraron nada. Ir a la pgina de bsqueda de nuevo.
Normalmente, el mtodo de accin realiza un procesamiento de los datos del formulario de la pgina
actual.
Por ejemplo, el mtodo podra comprobar si el nombre de usuario y la contrasea introducida en el
formulario de coincidir con el nombre de usuario y contrasea en el archivo. Si coinciden, el mtodo
devuelve el xito de los resultados. De lo contrario, devuelve la falta de resultados.
Como demuestra este ejemplo, tanto el mtodo utilizado para procesar la accin y los resultados
devueltos son necesarias para determinar la pgina propia de acceso.
He aqu una regla de navegacin que podran ser utilizados con el ejemplo que acabamos de describir:
<navigation-rule>
<from-view-id>/logon.jsp</from-view-id>
<navigation-case>
<from-action>IF3ogonForm.logonH</from-action>
<from-outcome>success</from-outcome>
<to-view-id>/storefront.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-action>IF3ogonForm.logonH</from-action>
<from-outcome>failure</from-outcome>
<to-view-id>/logon.jsp</to-view-id>
</navigation-case>
</navigation-rule>
Esta regla de navegacin define las posibles maneras de navegar de logon.jsp. Cada elemento de
navegacin caso, define una ruta de navegacin posible de logon.jsp. La navegacin primer caso se dice
que si LogonForm.logon devuelve un resultado de xito, entonces storefront.jsp se tendr acceso. La
navegacin segundo caso se dice que logon.jsp se vuelven a representar, si vuelve LogonForm.logon
fracaso.
La configuracin de una aplicacin, el flujo de la pgina consta de un conjunto de reglas de navegacin.
Cada regla se define por el elemento de regla de navegacin en el archivo faces-config.xml.
Cada elemento de regla de navegacin corresponde a un identificador del componente arbreo definido
por el facultativo de vista de elemento de identificacin. Esto significa que cada Estado define todas las
posibles maneras de navegar de una pgina especial en la aplicacin.
Si no hay ningn elemento de la vista-de-id, las reglas de navegacin se define en el elemento de regla de
navegacin se aplican a todas las pginas de la aplicacin. La concordancia de patrones-view-ID de
elemento tambin permite comodn. Por ejemplo, este de-vista-ID de elemento dice que la regla de
navegacin se aplica a todas las pginas en el directorio de libros:
<from-view-id>/libros/*</ from-view-id>
Como se indica en la regla de navegacin ejemplo, un elemento de regla de navegacin puede contener
cero o ms elementos de navegacin caso. El elemento de navegacin caso, define un conjunto de criterios
de coincidencia. Cuando se cumplen estos criterios, la aplicacin se vaya a la pgina definida por el a-
ver-ID de elemento contenido en la navegacin del mismo elemento de caso.
Los criterios son definidos por la navegacin opcional de resultados-y de elementos de accin. El
resultado de elemento define un resultado lgico, como el xito. El elemento de la accin mtodo utiliza
una expresin para referirse a un mtodo de accin que devuelve una cadena, que es el resultado lgico.
El mtodo realiza alguna lgica para determinar el resultado y devuelve el resultado.
Los elementos de navegacin caso de que se cotejarn con los resultados y el mtodo de expresin en este
orden:
Los casos que especifica la vez un resultado de valor y de valor de la accin. Ambos elementos
pueden ser utilizados si el mtodo de accin devuelve resultados diferentes dependiendo del
resultado de la transformacin que realiza.
Los casos que especifica slo un valor de resultado. El elemento de resultado debe coincidir con el
resultado ya sea definido por el atributo de accin del componente de UICommand o el resultado
devuelto por el mtodo mencionado por el componente de UICommand.
Especificando los casos slo una de valor de la accin. Este valor debe coincidir con la expresin
accin especificada por la etiqueta del componente.
Cuando se compara cualquiera de estos casos, el rbol de componentes definidos por el a-ver-elemento de
identificacin sern seleccionados para la representacin.
3.6.2 Reglas de navegacin implcitas
A partir de JavaServer Faces 2.0, las reglas de navegacin implcita estn disponibles para aplicaciones
de Facelets. Las reglas de navegacin implcita entrar en juego si no hay reglas de navegacin se
configuran en los archivos de configuracin de recursos de aplicacin.
Cuando se agrega un componente de interfaz de usuario como un comando y asigna una pgina como el
valor de su propiedad la accin, el controlador de navegacin por defecto tratan de combinar una pgina
adecuada dentro de la aplicacin.
<&*command4utton value$%'nviar% action$%response%>
En el ejemplo anterior, el controlador de navegacin por defecto tratar de localizar la pgina
response.xhtml y navegar hacia l.
3.7 Backed Beans
Una aplicacin tpica de JavaServer Faces incluye uno o ms beans de apoyo, cada uno de ellos es un
JavaServer Faces gestionados de bean que est asociado con los componentes de la interfaz de usuario
utilizados en una determinada pgina.
Los beans Gestionado son JavaBeans componentes que se pueden configurar mediante la instalacin de
bean gestionado, que se describe en Configuracin de Beans. Esta seccin presenta los conceptos bsicos
sobre la creacin, configuracin y uso de semillas de apoyo en una aplicacin.
3.7.1 Crear una clase de backed bean
Adems de definir un constructor sin argumento, como todos los componentes JavaBeans debe hacer,
una clase de backed bean tambin define un conjunto de propiedades de los componentes de interfaz de
usuario y, posiblemente, un conjunto de mtodos que realizan funciones de un componente.
Cada una de las propiedades de los componentes se pueden enlazar a una de las siguientes:
El valor de un componente
Una instancia de componente
Un ejemplo del convertidor
Un ejemplo de escucha
Un ejemplo de validador
Las funciones ms comunes que los mtodos de backed bean realizar son las siguientes:
Validar los datos de un componente
Manejo de un evento disparado por un componente de
Realizacin de tratamiento para determinar la siguiente pgina para que la solicitud debe
navegar
Como con todos los componentes JavaBeans, una propiedad consta de un campo de datos privados y un
conjunto de mtodos de acceso, como lo muestra este cdigo:
(ser:umber 5nteger $ null=
...
set(ser:umber public void D5nteger userPnumberE D
$ user:umber userPnumber=
E
get(ser:umber public 5nteger DE D
user:umber retorno=
E
public String get;esponse DE D
...
E
Cuando una propiedad de bean est ligada al valor de un componente, puede ser cualquiera de los tipos
bsicos primitivos y numrico o cualquier tipo de objeto de Java para que la aplicacin tenga acceso a un
convertidor apropiado. Por ejemplo, una propiedad puede ser de tipo fecha, si la aplicacin tiene acceso a
un convertidor que puede convertir el tipo de fecha en una cadena y viceversa.
Cuando una propiedad se une a una instancia del componente, el tipo de la propiedad debe ser el mismo
que el objeto de componentes. Por ejemplo, si un UISelectBoolean est ligado a la propiedad, la
propiedad debe aceptar y devolver un objeto UISelectBoolean.
Del mismo modo, si la propiedad est enlazado a un convertidor, validador, o el oyente ejemplo, la
propiedad debe ser del convertidor caso, validador, o el oyente tipo.
3.7.2 Configuracin de un Bean
La tecnologa JavaServer Faces soporta un sofisticado establecimiento administrado por la creacin de
bean, que permite a los arquitectos de aplicaciones para hacer lo siguiente:
Configurar beans simple y rboles ms complejo de beans
Inicializar el bean con los valores
Poner los beans en un mbito particular (mbitos disponibles: request, view, session, application)
Expone los beans a la EL unificada para que los autores de pginas se puede acceder a ellos
El siguiente ejemplo muestra un ejemplo de archivo faces-config.xml:
<managed-bean>
<managed-bean-name> (ser:umber4ean </ managed-bean-name>
<managed-bean-class>
guess:umber.(ser:umber4ean
</ managed-bean-class>
<managed-bean-scope> sesiMn </ managed-bean-scope>
<managed-propert#>
<propert#-name> mKnimos </ propiedad name>
<propert#-class> largo </ propiedad de clase>
<valor> 9 </ value>
</ managed-propert#>
<managed-propert#>
<propert#-name> <mNximo / propert#-name>
<propert#-class> largo </ propiedad de clase>
<valor> 19 </ value>
</ managed-propert#>
</ managed-bean>
La implementacin de JavaServer Faces procesa la <managed-bean-scope> elemento en el momento de
inicio de la aplicacin. Cuando un bean es llamado la primera vez de la pgina, se crea una instancia.
Un autor de la pgina puede acceder a las propiedades de bean de las etiquetas de componentes en la
pgina utilizando el EL unificada, como se muestra aqu:
<&*output"ext value$%IF(ser:umber4ean.minimumH%/>
Tambin es posible aprovechar la funcin de anotaciones para el bean logrado evitar la configuracin de
bean gestionado en archivo de configuracin de recursos de aplicacin.
Ejemplo:
!2anaged4eanDname $ %3ogin%E
!;e<uestScoped
public class 3ogin F...H
3.8 Usando el EL unificada para referenciar Backed beans
Para obligar a los valores de la interfaz de usuario de los componentes y propiedades de los objetos al
apoyo de bean o de respaldo para hacer referencia a los mtodos de bean de etiquetas de componentes de
interfaz de usuario, los autores de pginas utilizar el lenguaje de expresin unificada (EL) sintaxis
definida por JSP 2.1.
Las siguientes son algunas de las caractersticas que ofrece este lenguaje:
Evaluacin diferida de las expresiones
La capacidad de usar una expresin de valor tanto para leer y escribir datos
Expresin de mtodos
Estas caractersticas son especialmente importantes para apoyar el modelo de interfaz de usuario
sofisticado componente que ofrece la tecnologa JavaServer Faces.
Evaluacin diferida de las expresiones es importante porque el ciclo de vida de JavaServer Faces est
dividido en fases distintas, de manera que el manejo de eventos de componentes, la conversin de datos y
validacin, y la propagacin de datos a los objetos externos, se realizan en forma ordenada. La aplicacin
debe ser capaz de retrasar la evaluacin de las expresiones, hasta la fase apropiada del ciclo de vida se
ha alcanzado. Por lo tanto, su etiqueta de atributos siempre utiliza la sintaxis de la evaluacin diferida,
que se distingue por el delimitador # {}.
Con el fin de almacenar datos en los objetos externos, casi todos los atributos de etiquetas JavaServer
Faces utilizar expresiones de valor valor-, que son expresiones que permiten tanto obtener y establecer
datos sobre los objetos externos.
Por ltimo, algunos atributos de etiqueta de componente de aceptar expresiones mtodo que los mtodos
de referencia para controlar los eventos de componentes, o validar o convertir los datos de los
componentes.
Para ilustrar una etiqueta de JavaServer Faces usando el EL unificado, supongamos que una etiqueta
de una solicitud de referencia a un mtodo para realizar la validacin de entrada de usuario:
<&*input"ext id$%user:o%
value$%IF(ser:umber4ean.user:umberH%
validator$%IF(ser:umber4ean.validateH% />
Esta etiqueta se une el valor del componente userNo para el bean de la propiedad
UserNumberBean.userNumber utilizando una expresin value. Se utiliza un mtodo de expresin para
hacer referencia al mtodo de UserNumberBean.validate, que realiza la validacin de valor local del
componente. El valor local es lo que el usuario entra en el campo correspondiente a esta etiqueta. Este
mtodo se invoca cuando se evala la expresin, que es durante la fase de validacin del proceso del ciclo
de vida.
Casi todos los atributos de etiquetas JavaServer Faces aceptar expresiones de valor. Adems de las
propiedades referencias, expresiones de valor puede tambin listas de referencias, mapas, paneles,
objetos implcita, y los paquetes de recursos.
Otro uso de las expresiones de valor vinculante es una instancia del componente a una propiedad de
backed bean. Un autor de la pgina hace referencia a la propiedad del atributo :
<input"ext binding$%IF(ser:umber4ean.user:o.omponentH% />
Esas etiquetas de componentes que las expresiones mtodo de uso son las etiquetas y las etiquetas de
componentes UIInput componente UICommand.
3.8.1 El Ciclo de Vida de una pgina JavaServer Faces
El ciclo de vida de una pgina JavaServer Faces es algo similar a la de una pgina JSP: El cliente realiza
una solicitud HTTP de la pgina y el servidor responde con la pgina traducida a HTML. Sin embargo, el
ciclo de vida de JavaServer Faces difiere del ciclo de vida de JSP en que se divide en varias fases para
apoyar el modelo de interfaz de usuario sofisticado componente. Este modelo requiere que los elementos
de ser convertidos y validados, eventos de los componentes se manipulan, y los datos de los componentes
se propaga a las judas en una manera ordenada.
Una pgina de JavaServer Faces es tambin diferente de una pgina JSP en la que es representado por
un rbol de componentes de interfaz de usuario, denominado punto de vista. Durante el ciclo de vida, la
implementacin JavaServer Faces debe construir el punto de vista al considerar el estado guardado de
una presentacin anterior de la pgina. Cuando el cliente enva una pgina, la implementacin
JavaServer Faces realiza varias tareas, tales como la validacin de la entrada de datos de los
componentes de la vista y la conversin de los datos de entrada a los tipos especificados en el lado del
servidor.
La implementacin de JavaServer Faces realiza todas estas tareas como una serie de pasos en la
solicitud de JavaServer Faces ciclo de vida de respuesta.
Diagrama de flujo de la solicitud de Faces y respuesta de Faces, incluyendo el evento de validacin y el
procesamiento, manejo de errores, el modelo de actualizacin, la invocacin de la aplicacin.
El ciclo de vida maneja ambos tipos de solicitudes: Las solicitudes iniciales y devoluciones de datos.
Cuando un usuario hace una solicitud inicial de una pgina, l o ella est solicitando la pgina por
primera vez. Cuando un usuario ejecuta una devolucin de datos, se le enva el formulario que figura en
una pgina que fue previamente cargado en el navegador como resultado de la ejecucin de una solicitud
inicial.
Cuando el ciclo de vida se encarga de la peticin inicial, slo se ejecuta la restauracin de vista y hacer
que las fases de respuesta, porque no hay ninguna entrada del usuario o acciones para el proceso. Por el
contrario, cuando el ciclo de vida maneja una devolucin de datos, ejecuta todas las fases.
Normalmente, la primera solicitud para una pgina JavaServer Faces trata de un cliente, como
resultado de hacer clic en un hipervnculo en una pgina HTML que enlaza con la pgina de JavaServer
Faces.
Para hacer una respuesta que es otra pgina JavaServer Faces, la aplicacin crea una nueva visin y la
almacena en la instancia FacesContext, que representa a toda la informacin contextual asociada con el
procesamiento de una solicitud entrante y crear una respuesta. La aplicacin se adquiere referencias a
objetos que necesita la opinin y solicita FacesContext.renderResponse, que obliga a la prestacin
inmediata de la opinin de pasar por la respuesta a la fase de procesamiento del ciclo de vida, como
indican las flechas etiquetados Render de respuesta en el diagrama.
A veces, una aplicacin podra necesidad de reorientar los recursos a diferentes aplicaciones web, como
un servicio web, o generar una respuesta que no contiene componentes JavaServer Faces. En estas
situaciones, el desarrollador debe saltarse la fase de renderizado (Render Fase de respuesta) llamando
FacesContext.responseComplete. Esta situacin tambin se muestra en el diagrama, esta vez con las
flechas de la etiqueta respuesta completa.
La propiedad de la currentPhaseID FacesContext, que representa la fase que se encuentra, debe ser
actualizada tan pronto como sea posible por la aplicacin.
La situacin ms comn es que un componente JavaServer Faces presenta una solicitud de la pgina de
otro JavaServer Faces. En este caso, la implementacin JavaServer Faces maneja la solicitud y
automticamente pasa a travs de las fases del ciclo de vida para realizar cualquier conversin
necesaria, validaciones y actualizacin de los modelos, y para generar la respuesta.
Los detalles del ciclo de vida se explica en esta seccin estn destinados principalmente para
desarrolladores que necesitan conocer dicha informacin como cuando validaciones, conversiones, y los
eventos son generalmente tramitadas y lo que pueden hacer para cambiar cmo y cundo se les da. Los
autores de pginas no tienen por qu conocer los detalles del ciclo de vida.
3.8.2 Fase de restauracin de vista
Cuando una solicitud de una pgina JavaServer Faces se hace, como cuando un enlace o un botn se
presiona, la implementacin JavaServer Faces comienza la fase de restauracin de vista.
Durante esta fase, la implementacin JavaServer Faces construye el punto de vista de la pgina,
controladores de eventos y los validadores de los componentes en la vista, y guarda la vista en el ejemplo
FacesContext, que contiene toda la informacin necesaria para procesar una solicitud nica. Todas las
etiquetas de componentes de la aplicacin, los controladores de eventos, convertidores y validadores de
tener acceso a la instancia de FacesContext.
Si la solicitud de la pgina es una solicitud inicial, la implementacin JavaServer Faces crea una visin
de vaco en esta etapa y los avances del ciclo de vida para hacer la fase de respuesta, durante el cual se
llena con los componentes de referencia de las etiquetas en la pgina .
Si la solicitud de la pgina es una devolucin de datos, una vista correspondiente a esta pgina ya existe.
Durante esta fase, la implementacin JavaServer Faces restaura la vista mediante el uso de la
informacin de estado guardada en el cliente o el servidor.
3.8.3 Fase de aplicacin de valores
Despus de que el rbol de componentes que se restablezca, cada componente en el rbol de los extractos
de su nuevo valor de los parmetros de la peticin mediante el uso de su decodificar (processDecodes ())
mtodo. El valor se almacena localmente en el componente. Si la conversin del valor de falla, un
mensaje de error que est asociado con el componente se genera y en la cola en FacesContext. Este
mensaje se mostrar durante la fase de dar respuesta, junto con los errores de validacin resultante de
la fase de validacin del proceso.
Si los mtodos descifrar o detectores de eventos llamado renderResponse FacesContext en la instancia
actual, la implementacin JavaServer Faces salta a la fase de dar respuesta.
Si los acontecimientos se han cola durante esta fase, las emisiones de aplicacin JavaServer Faces los
acontecimientos a los oyentes interesados.
Si algunos componentes de la pgina tienen sus atributos de inmediato establece en true, entonces la
validacin, la conversin, y los eventos relacionados con estos componentes sern tratados durante esta
fase.
En este punto, si la solicitud tiene que reorientar los recursos a diferentes aplicaciones web o de generar
una respuesta que no contiene componentes JavaServer Faces, puede llamar a
FacesContext.responseComplete.
Al final de esta fase, los componentes se fijan a sus nuevos valores, y los mensajes y eventos se han
puesto en cola.
Si la peticin actual se identifica como una peticin parcial, el contexto parcial se recupera de las caras
de contexto y el mtodo de transformacin parcial es aplicado.
3.8.4 Fase de validaciones de proceso
Durante esta fase, la implementacin JavaServer Faces procesa todos los validadores registradas en los
componentes en el rbol, mediante su validacin ((processValidators)) mtodo. Se examina el
componente de atributos que especifican las normas para la validacin y compara estas normas para el
valor local almacenado para el componente.
Si el valor local no es vlido, la implementacin JavaServer Faces aade un mensaje de error a la
instancia FacesContext, y el ciclo de vida avanza directamente a la fase de dar respuesta para que la
pgina se representa con el mensaje de error. Si hubo errores de conversin de la solicitud de aplicar los
valores de fase, los mensajes de estos errores tambin se muestran.
Si alguna validar mtodos o detectores de eventos llamado renderResponse en el FacesContext actual, la
implementacin JavaServer Faces salta a la fase de dar respuesta.
Si los acontecimientos se han cola durante esta fase, la implementacin JavaServer Faces emisiones a
oyentes interesados.
de contexto y el mtodo de transformacin parcial es aplicado. Procesamiento parcial est cubierto en
Java EE 6 Tutorial, Volumen II: Temas avanzados.
3.8.5 Fase de actualizacin de valores de modelo
Despus de la implementacin JavaServer Faces determina que los datos son vlidos, se puede recorrer
el rbol de componentes y establecer el servidor correspondiente de las propiedades del objeto de lado a
los valores locales de los componentes. La implementacin de JavaServer Faces actualizar slo las
propiedades judas apuntado por un componente de valor de atributo de entrada. Si los datos locales no
pueden ser convertidos a los tipos especificados por las propiedades judas, el ciclo de vida avanza
directamente a la fase de dar respuesta para que la pgina es re-emitida con errores mostrados. Esto es
similar a lo que sucede con los errores de validacin.
Si los mtodos updateModels o cualquier oyentes llamado renderResponse FacesContext en la instancia
actual, la implementacin JavaServer Faces salta a la fase de dar respuesta.
Si los acontecimientos se han cola durante esta fase, la implementacin JavaServer Faces emisiones a
oyentes interesados.
de contexto y el mtodo de transformacin parcial es aplicado.
3.8.6 Fase de invocacin de la aplicacin
Durante esta fase, la implementacin JavaServer Faces maneja cualquier solicitud de eventos de nivel,
tales como la presentacin de un formulario o un vnculo a otra pgina.
Si se procesa el punto de vista fue reconstruido a partir de informacin de estado de una solicitud
anterior y si un componente ha disparado un evento, estos eventos se transmiten a los oyentes
interesados.
Por ltimo, las transferencias de JavaServer Faces aplicacin de control para hacer que la fase de
respuesta.
3.8.7 Fase de creacin de la respuesta
Durante esta fase, JavaServer Faces construye el punto de vista y delega la autoridad para el
renderizado de las pginas. Por ejemplo, para el contenedor de JSP si la aplicacin es la utilizacin de
pginas JSP.
Si se trata de una solicitud inicial, los componentes que estn representados en la pgina se agrega al
rbol de componentes. Si esto no es una solicitud inicial, los componentes se aaden ya al rbol para que
no se necesita aadir ms.
Si la solicitud es una devolucin de datos y los errores fueron encontrados durante la fase de solicitud de
aplicar los valores, las validaciones de proceso de fase, o fase de actualizacin de los valores del modelo,
la pgina original se representa en esta fase. Si las pginas contienen mensajes o los mensajes de las
etiquetas, los mensajes de error en la cola se muestran en la pgina.
Despus de que el contenido de la vista se representa, el estado de la respuesta se guarda para que las
solicitudes posteriores se puede acceder a l. El estado guardado se est a disposicin de la fase de
restauracin de vista.
4 Formularios
4.1 Formulario sencillo
Para poner en practica lo anterior visto, vamos a usar un formulario de entrada al sitio.
Lo vamos a construir poco a poco para llegar al cdigo siguiente:
login.xhtml:
<&*&ead>
<title>'ntrada al sitio</title>
<linC rel$%st#les&eet% &ref$%curso.css% />
<ui*include src$%6'4-5:F/include/&ead.x&tml%/>
</&*&ead>
<&*bod#>
<ui*include src$%6'4-5:F/include/menu.x&tml%/>
<&1><&*output"ext value$%1ello 6orld+%/></&1>
<&*grap&ic5mage alt$%O5F% url$%/images/,uCeP4locCs.gif% widt&$%199px% />
<&*form>
<&*panelOrid columns$%7%>
<&*output"ext value$%(suario% />
<&*input"ext id$%username% value$%IF3ogin.usernameH% re<uired$%true%
validator2essage$%2inimo Q caracteres+%
re<uired2essage$%Ralue is re<uired+% >
<f*validate3engt& minimum$%Q% />
</&*input"ext>
<&*message for$%username% st#le.lass$%error%/>
<&*output"ext value$%.lave% />
<&*input"ext value$%IF3ogin.passwordH% />
<&*command4utton value$%'ntrar% action$%IF3ogin.submitH%
action3istener$%IF3ogin.on3oginH% />
</&*panelOrid>
</&*form>
</&*bod#>
curso.css:
root F
displa#* blocC=
H
.logoF
font-siGe* Q9px=
color* teal=
H
Login.java:
pacCage curso=
import javax.faces.event.Jbort0rocessing'xception=
import javax.faces.event.Jction'vent=
!2anaged4eanDname $ %3ogin%E
!;e<uestScoped
public class 3ogin F
private String username=
private String password=
public void on3oginDJction'vent eE F
if D+username.e<uals5gnore.aseD%duCes%E SS +username.e<uals5gnore.aseD%admin%EE F
t&row new Jbort0rocessing'xceptionD%(suario invalido%E=
H
// password$null=
H
public String submitDE F
String outcome $ %none%=
if Dusername.e<uals5gnore.aseD%duCes%EE F
outcome $ %success%=
H else F
outcome $ %admin%=

H
S#stem.out.printlnDoutcomeE=
return outcome=
H
public void set0asswordDString passwordE F
t&is.password $ password=
H
public void set(sernameDString usernameE F
t&is.username $ username=
H
public String get0asswordDE F
return password=
H
public String get(sernameDE F
return username=
H
H
faces-config.xml:
<?xml version$@1.9@ encoding$@("F-)@?>
<faces-config version$%Q.9%
xmlns$%&ttp*//java.sun.com/xml/ns/javaee%
xmlns*xsi$%&ttp*//www.w7.org/Q991/A23Sc&ema-instance%
xsi*sc&ema3ocation$%&ttp*//java.sun.com/xml/ns/javaee &ttp*//java.sun.com/xml/ns/javaee/web-
facesconfigPQP9.xsd%>
<navigation-rule>
<from-view-id>/login.x&tml</from-view-id>
<navigation-case>
<from-outcome>admin</from-outcome>
<to-view-id>/admin.x&tml </to-view-id>
</navigation-case>
<navigation-case>
<to-view-id>/indexQ.x&tml </to-view-id>
</navigation-case>
</navigation-rule>
</faces-config>
Hay que crear las pginas index2. x&tml y admin. x&tml tambien.
4.2 Formulario mas complejo
Vamos a crear un formulario para agregar un usuario, con diferentes tipos de campos en el formulario.
user_add.xhtml
<&*&ead>
<title>Jgregar un usuario</title>
</&*&ead>
<&*bod#>
<&1>Jgregar un usuario</&1>
<&*form>
<&*panelOrid columns$%7% >
<&*output3abel value$%:ombre*%/>
<&*input"ext id$%nombre% value$%IF(suario.nombreH% siGe$%Q9% maxlengt&$%79%
re<uired$%true% validator2essage$%2inimo Q caracteres+%
re<uired2essage$%'l nombre no puede estar vacio% >
<f*validate3engt& minimum$%Q% />
</&*input"ext>
<&*message for$%nombre% st#le.lass$%error%/>
<&*output3abel value$%Jpellido*%/>
<&*input"ext id$%apellido% value$%IF(suario.apellidoH% siGe$%Q9% maxlengt&$%79%
re<uired2essage$%'l apellido no puede estar vacio% >
<f*validate3engt& minimum$%Q% /></&*input"ext>
<&*message for$%apellido% st#le.lass$%error%/>
<&*panelOroup st#le$%text-align*rig&t=%><&*output3abel
value$%,omicilio*%/></&*panelOroup>
<&*input"extarea id$%add1% value$%IF(suario.add1H% cols$%T9% rows$%7%
></&*input"extarea>
<f*verbatim />
<&*output3abel value$%Sexo*%/>
<&*select-ne3istbox title$%Selecciona el sexo del usuario%
value$%IF(suario.sexoH% siGe$%1%>
<f*select5tem itemRalue$%2% item3abel$%2asculino%/>
<f*select5tem itemRalue$%F% item3abel$%Feminino%/>
</&*select-ne3istbox>
<f*verbatim />
<&*output3abel value$%.uantos &erman!s%/>
<&*input"ext id$%&ermanos% value$%IF(suario.&ermanosH% siGe$%1% maxlengt&$%Q%
re<uired$%true% validator2essage$%Ralor aceptados* de 9 a QT.%
re<uired2essage$%'ste campo no puede estar vacio%
converter2essage$%Se espera un numero entero a<ui.% >
<f*validate3ong;ange minimum$%9% maximum$%QT% />
</&*input"ext>
<&*message for$%&ermanos% st#le.lass$%error%/>
<&*output3abel value$%Salario%/>
<&*input"ext id$%salario% value$%IF(suario.salarioH% siGe$%19% maxlengt&$%1Q%
re<uired$%true% validator2essage$%Ralor aceptados* de 9 a QT9999.%
re<uired2essage$%'ste campo no puede estar vacio%
converter2essage$%Formato incorrecto.% >
<f*convert:umber maxFraction,igits$%Q% max5nteger,igits$%U% t#pe$%currenc#%
currenc#S#mbol$%.V% locale$%es% pattern$%%/>
<f*validate,ouble;ange minimum$%9% maximum$%QT99% />
</&*input"ext>
<&*message for$%salario% st#le.lass$%error%/>
<&*panelOroup>
<&*command4utton value$%Jgregar el usuario% action$%IF(suario.onSubmitH%
></&*command4utton>
</&*panelOroup>
</&*panelOrid>
</&*form>
</&*bod#>
5 HtmlDataTable
Un DataTable muestra una tabla HTML <table>.
Las columnas se especifican con los componentes secundarios UIColumn.
El HtmlDataTable tiene varios parametros:
ID: Se utiliza para identificar el componente de la tabla. Este debe ser nico en el componente
ms cercano de los padres.
Value: Representa el valor del componente. Representa el valor sobre el que la iteracin se debe
hacer. Puede ser una matriz o cualquier objeto iterador.
Var: Este es el nombre de la variable creada por la tabla de datos que representa el elemento
actual en el valor. Este atributo permite exponer los datos en las filas de la tabla.
Bgcolor: Este atributo se utiliza para establecer el color de fondo de la tabla.
Border: Se puede configurar el ancho del borde de la mesa alrededor de la mesa.
Cellpadding: Esto establece el espacio entre el contenido y la frontera de la clula.
Cellspacing: Se especifica la cantidad de espacio para dejar entre las clulas.
First: Se utiliza para especificar el nmero de fila de la primera fila de la que presentamos es que
se inicie en adelante. Supongamos, esta propiedad se establece en 3, que muestra se iniciar
desde la tercera fila de los datos subyacentes.
Rows: Este atributo especifica el nmero de filas a mostrar. Viendo este se pondr en marcha
desde el ndice especificado en la "primera" atributo. Si se establece este atributo a cero, entonces
todas las filas que se mostrarn.
Width: Esto se utiliza para establecer el ancho de toda la tabla. Su valor se especifica en%.
Supongamos que se establece que el 50%, entonces esta tabla se muestra en el espacio del 50% de
la anchura de la pantalla.
Dir: Este atributo indica la direccin del texto que se mostrar en la celda. Se necesita "ltr" (de
izquierda a derecha) y "RTL" (de derecha a izquierda) valores. Si no se especifica este atributo a
continuacin, el contenido se mostrar en el centro.
Frame: Este atributo que specifyes lados de la estructura en torno a esta mesa ser visible. Este
atributo puede tomar algunos valores que se muestran a continuacin:
1. none Ninguna de las partes, Valor predeterminado
2. top lado slo por encima de
3. below de lado el fondo slo
4. hsides partes superior e inferior slo
5. vsides lados derecho e izquierdo slo
6. LHS lado izquierdo slo
7. RHS lado derecho slo
8. box Todas las partes cuadro de cuatro
9. border Todas las partes frontera cuatro
Rules: Este atributo se utiliza para dibujar lneas entre las clulas. Puede tomar algunos valores
que se indican a continuacin:
1. none: No hay reglas ninguno, el valor por defecto
2. group: Entre los grupos de los grupos de filas
3. rows: Entre las filas de las filas slo
4. cols: Entre columnas slo
5. all: Entre todas las todas las filas y columnas
Summary: Puede especificar resumen del propsito de la tabla.
Rendered: Se necesita value.This boolean Indica si este componente debe ser prestado. Su valor
predeterminado es "true". Si se establece en false entonces se impide la prestacin de este
componente a la pgina.
CaptionClass: lista separada por espacios de la clase o clases CSS que se aplicar a cualquier
ttulo generado para esta tabla.
CaptionStyle: Especifica estilo CSS o estilos que deben aplicarse cuando se representa este
epgrafe.
ColumnClasses: lista separada por comas de las clases CSS que se aplicar a las columnas de
este cuadro.
FooterClass: Este atributo tiene lista separada por espacios de estilo CSS de la clase o clases que
se aplicar a aheaderter generado para esta tabla.
HeaderClass: Este atributo tiene lista separada por espacios de la clase de estilo CSS o clases
que se aplicarse a cualquier encabezado generado para esta tabla.
RowClasses: Es una lista de clases CSS aplicados a las filas de las clases table.These deben estar
separadas por comas. Si queremos aplicar la clase de CSS para filas individuales, entonces
podemos especificar lista separada por espacios de clases CSS. Clases de estilo se aplican a las
filas en el mismo orden que se definidos. Si tenemos dos clases CSS continuacin de primera
categora se aplica a la primera fila y la segunda se aplica a la segunda. Entonces, de nuevo en la
tercera fila, el CSS se aplica primero y as sucesivamente. Este proceso contina hasta la ltima
fila de la tabla.
Lang: Establece el idioma base de los atributos de un elemento, es decir, el texto y el lenguaje
utilizado en el marcado generado para este componente.
StyleClass: Se establece el nombre de las clases de classor CSS que se aplica en el momento de la
prestacin del elemento.
Title: El atributo del ttulo se utiliza para establecer el texto para mostrar informacin sobre
herramientas para el component.Tooltip prestados describe un elemento cuando se representa
para el cliente.
Binding: Es un valor de la expresin de unin que es utilizado para conectar componentes a una
propiedad en un backed bean.
OnClick: Se establece el cdigo JavaScript a ejecutar cuando se hace clic en los botones del ratn
sobre este elemento.
Ondblclick: Se establece el cdigo JavaScript que se ejecuta cuando el botn del puntero es doble
clic sobre este elemento.
Onkeydown: Se establece el cdigo JavaScript que se ejecuta cuando se presiona una tecla hacia
abajo sobre este elemento.
Onkeypress: Se establece el cdigo JavaScript que se ejecuta cuando se pulsa una tecla y
publicado sobre este elemento.
Onkeyup: Se establece el cdigo JavaScript que se ejecuta cuando se suelta una tecla sobre este
elemento.
Onmousedown: Se establece el cdigo JavaScript que se ejecuta cuando el botn es pulsado el
puntero sobre este elemento.
Onmousemove: Se establece el cdigo JavaScript a ejecutar cuando un botones del ratn se
mueve dentro de este elemento.
Onmouseout: Se establece el cdigo JavaScript a ejecutar cuando un botones del ratn se aleja de
este elemento.
Onmouseover: Se establece el cdigo JavaScript a ejecutar cuando un botones del ratn se mueve
Onmouseup: Se establece el cdigo JavaScript a ejecutar cuando un botones del ratn se suelta
Ejemplo:
user_details.xhtml
<&*&ead>
<title>,etalles del usuario</title>
</&*&ead>
<&*bod#>
<&1>,etalles del usuario</&1>
<&*data"able value$%IF(suarioH% var$%user% border$%1%
cellspacing$%Q%>
<&*column>
<f*facet name$%&eader%>
<&*output"ext value$%First :ame%/>
</f*facet>
<&*output"ext value$%IFuser.nombreH%/>
</&*column>
<&*column>
<&*output"ext value$%3ast :ame%/>
</f*facet>
<&*output"ext value$%IFuser.apellidoH%/>
</&*column>
<&*column>
<&*output"ext value$%4alance%/>
</f*facet>
<&*output"ext value$%IFuser.salarioH%>
<f*convert:umber t#pe$%currenc#%/>
</&*output"ext>
</&*column>
</&*data"able>
</&*bod#>
(suario.java*
import java.util..alendar=
import java.util.,ate=
import java.util.Oregorian.alendar=
import javax.faces.application.Faces2essage=
import javax.faces.component.(5.omponent=
import javax.faces.context.Faces.ontext=
!2anaged4eanDname$%(suario%E
!;e<uestScoped
public class (suario F
private String nombre=
private String apellido=
private String sexo=
private ,ate fecnac$new ,ateDE=
private String add1=
private String pasatiempo=
private 4#te &ermanos=
private ,ouble salario$1TT9.QTTU8=
private 5nteger test5nt$1QB99=
public (suarioDE F
H
public (suarioDString nombreL String apellidoL String sexoL ,ate fecnacL String add1L String
pasatiempoL 4#te &ermanosL ,ouble salarioE F
t&is.apellido $ apellido=
t&is.sexo $ sexo=
t&is.fecnac $ fecnac=
t&is.add1 $ add1=
t&is.pasatiempo $ pasatiempo=
t&is.&ermanos $ &ermanos=
t&is.salario $ salario=
H
public String onSubmitDEF
return %success%=
H
public void validate..'xpir#DFaces.ontext cntxL (5.omponent cmpL -bject valE F
S#stem.out.printlnD%Ralidando la entrada %WvalE=
String messS $ null=
StringXY fields $ DDStringE valE.splitD%/%L 7E=
if Dfields.lengt& +$ QE F
messS $ %Se espera 22/JJ+%=
H else F
int mont& $ 9=
int #ear $ 9=
tr# F
mont& $ 5nteger.parse5ntDfieldsX9YE=
#ear $ 5nteger.parse5ntDfieldsX1YE=
H catc& D:umberFormat'xception eE F
H
if Dmont& <$ 9 ZZ mont& > 1QE F
messS $ %2es % W fieldsX9Y W % invalido+%=
H else if D#ear < 9 ZZ #ear > BBE F
messS $ %JSntild*o % W fieldsX1Y W % invalido+%=
H else F
Oregorian.alendar cal $ new Oregorian.alendarDE=
int t&is2ont& $ cal.getD.alendar.2-:"1E W 1=
int t&is/ear $ cal.getD.alendar./'J;E - Q999=
if D#ear < t&is/ear ZZ #ear $$ t&is/ear SS mont& < t&is2ont&E F
messS $ %"arjeta vencida+%=
H
H
H
if DmessS +$ nullE F
Faces2essage mess $ new Faces2essageDmessSE=
cntx.add2essageDcmp.get.lient5dDcntxEL messE=
H
H
public String get:ombreDE F
return nombre=
H
public void set:ombreDString nombreE F
H
public String getJpellidoDE F
return apellido=
H
public void setJpellidoDString apellidoE F
t&is.apellido $ apellido=
H
public String getSexoDE F
return sexo=
H
public void setSexoDString sexoE F
t&is.sexo $ sexo=
H
public ,ate getFecnacDE F
return fecnac=
H
public void setFecnacD,ate fecnacE F
t&is.fecnac $ fecnac=
H
public String getJdd1DE F
return add1=
H
public void setJdd1DString add1E F
t&is.add1 $ add1=
H
public String get0asatiempoDE F
return pasatiempo=
H
public void set0asatiempoDString pasatiempoE F
t&is.pasatiempo $ pasatiempo=
H
public void setSalarioD,ouble salarioE F
t&is.salario $ salario=
H
public void set1ermanosD4#te &ermanosE F
t&is.&ermanos $ &ermanos=
H
public ,ouble getSalarioDE F
return salario=
H
public 4#te get1ermanosDE F
return &ermanos=
H
public void set"est5ntD5nteger test5ntE F
t&is.test5nt $ test5nt=
H
public 5nteger get"est5ntDE F
return test5nt=
H
H
demoPtable.x&tml
<&*&ead>
<title>3ista de usuarios</title>
</&*&ead>
<&*bod#>
<&1>3ista de usuarios</&1>
<&*data"able value$%IF,emo"able.dataH% var$%user% border$%1% cellspacing$%Q%
column.lasses$%col1LcolQLcol1LcolQ% row.lasses$%row1LrowQ%
&eader.lass$%&eader%>
<&*column>
<&*output"ext value$%:ombre%/>
</f*facet>
<&*output"ext value$%IFuser.nombreH%/>
</&*column>
<&*column>
<&*output"ext value$%Jpellido%/>
</f*facet>
<&*output"ext value$%IFuser.apellidoH%/>
</&*column>
<&*column>
<&*output"ext value$%Sexo%/>
</f*facet>
<&*output"ext value$%IFuser.sexoH%/>
</&*column>
<&*column>
<&*output"ext value$%Salario%/>
</f*facet>
<&*output"ext value$%IFuser.salarioH%>
<f*convert:umber t#pe$%currenc#%/>
</&*output"ext>
</&*column>
</&*data"able>
</&*bod#>
,emo"able.java
import java.util.Jrra#3ist=
import java.util.,ate=
import java.util.3ist=
import javax.faces.bean.JpplicationScoped=
!2anaged4eanDname$%,emo"able%E
!JpplicationScoped
public class ,emo"able F
3ist<(suario> data $ new Jrra#3istDE=
public ,emo"ableDE F
populate,ataDE=
H
public 3ist get,ataDEF
return data=
H
public void set,ataD(suario aEF
data.addDaE=
H
public void populate,ataDEF
data.addDnew (suarioD%.edric%L%Simon%L%2%Lnew ,ateDEL%2anagua%L%demo%LDb#teEQLQT99.)9EE=
data.addDnew (suarioD%>uan%L%0almado%L%2%Lnew ,ateDEL%2anagua%L%demo%LDb#teEQLQT.9)EE=
data.addDnew (suarioD%2elanie%L%.astro%L%F%Lnew ,ateDEL%2anagua%L%demo%LDb#teEQL1Q9T.9TEE=
data.addDnew (suarioD%2elanieQ%L%.astro%L%F%Lnew ,ateDEL%2anagua%L%demo%LDb#teEQL1Q9T.9TEE=
data.addDnew (suarioD%2elanie7%L%.astro%L%F%Lnew ,ateDEL%2anagua%L%demo%LDb#teEQL1Q9T.9TEE=
data.addDnew (suarioD%2elanie8%L%.astro%L%F%Lnew ,ateDEL%2anagua%L%demo%LDb#teEQL1Q9T.9TEE=
H
H
6 Mensaje de error personalizados
6.1 Lista de mensaje personalizados
En faces-context.xml:
<application>
<resource-bundle>
<base-name>curso.Jpplication2essages</base-name>
<var>'rr2sg</var>
</resource-bundle>
</application>
En src/curso/ crear archivo ApplicationMessages.properties:
test$1ola 2undo
Uso: IF'rr2sg.testH Hola Mundo
6.2 Pgina de error personalizada:
error.x&tml :
<&*&ead>
<title>0agina de error</title>
</&*&ead>
<&*bod#>
<&Q>(n error fata ocurio+</&Q>
<a &ref$%IFre<uest.get.ontext0at&DEH/faces/login.x&tml%>Favor prueba de nuevo.</a>
<p><&*linC outcome$%success% value$%Favor prueba de nuevo.%></&*linC></p>
<p><&*linC outcome$%index% value$%Favor prueba de nuevo.%></&*linC></p>
</&*bod#>
Configurar en web.xml:
<error-page>
<location>/error.x&tml</location>
</error-page>
<error-page>
<error-code>404</error-code>
<location>/error.xhtml</location>
</error-page>
7 Convertidores
7.1 Qu es un convertidor?
Un convertidor se utiliza para dar formato "agradable" a un objeto, texto que se mostrar.
Por ejemplo, si desea para mostrar una fecha en JSP se puede utilizar un convertidor de formato de la
fecha a un formato mas comn para el usuario, como "10/03/2005".
Pero hay otra forma de usar un convertidor. Si los utiliza en combinacin con un control de entrada,
la entrada del usuario debe estar en el formato especificado por el convertidor. Si el formato de la
entrada no coincide en el formato, puede lanzar una excepcin en el convertidor que se muestra al
usuario. El objeto asociado no se actualiza hasta que se corrige el error.
7.2 Uso de los convertidores
El convertidore puede ser fijado dentro de JSP, o usted puede registrar el convertidor mediante
programacin.
Usted puede registrar un convertidor con JSP en una de las tres maneras:
Especifique el identificador de convertidor con la propiedad converter dentro de la etiqueta.
<&*output"ext value$%IFm#4ean.dateH% converter$%m#.onverter%>
Juntar <f:converter> de dentro de la etiqueta del componente.
<&*output"ext value$%IFm#4ean.dateH%>
<f*converter converter5d$%m#.onverter%/>
</ &* output"ext>
Juntar la etiqueta personalizada del convertidor dentro de una etiqueta del componente.
<laliluna*m#.onverter />
</ &* output"ext>
Los siguientes JSF Etiquetas apoya convertidores.
<&*output"ext>
<&*outputFormat>
<&*output3inC>
<&*output3abel>
<&*input"ext>
<&*input"extarea>
<&*input1idden>
<&*inputSecret>
<&*select4oolean.&ecCbox>
<&*select2an#3istbox>
<&*select2a#n#2enu>
<&*select-ne;adio>
<&*select-ne3istbox>
<&*select-ne2enu>
7.3 Convertidores incluidos
Si no se especifica un convertidor, JSF escoger uno para usted. El marco ha convertidores estndar
para todos los tipos bsicos: Long, byte, integer, short, Character, Double, Float, BigDecimal,
BigInteger y Boolean .
Por ejemplo, si el componente se asocia con una propiedad de tipo boolean, JSF elija el convertidor de
Boolean. Los tipos primitivos se convierten automticamente a sus homlogos de objeto.
Adems tiene convertidores predefinidos para fechas u nmeros.
7.3.1 Convertidor DateTime
Para todos los tipos bsicos de Java JSF usar automticamente los convertidores. Pero si desea dar
formato a una fecha objeto de JSF proporciona una etiqueta convertidor <f:convertDateTime>.
Esta etiqueta debe ser anidadas dentro de un tag componente que apoya los convertidores.
<f*convert,ate"ime t#pe$%date% dateSt#le$%medium%/>
</&*output"ext>
El convertidor DateTime admite atributos, como el tipo o datestyle, para configurar el convertidor. El
lista a continuacin muestra los atributos que puede utilizar con el convertidor de DateTime.
Nombre del atributo Descripcin
datestyle Especifica el estilo de formato para la porcin de la
fecha de la cadena. Las opciones vlidas
son de short, medium (por defecto), long y full. Slo
es vlido si se establece el tipo de atributo.
timeStyle Especifica el estilo de formato para la porcin de
tiempo de la cadena. Las opciones vlidas
son de short, medium (por defecto), long y full. Slo
es vlido si se establece el tipo de atributo.
timezone Especifica la zona horaria para la fecha. Si no se
establece, hora del meridiano de Greenwich (GMT)
se utilizar.
locale El idioma local a utilizar para la visualizacin de
esta fecha. Reemplaza la localizacin actual
pattern El modelo de formato de fecha utilizado para
convertir esta fecha. Utilice este o el
tipo de propiedad.
type Especifica si se debe mostrar la fecha (date), hora
(time) o ambas (both).
7.3.2 Convertidor de Nmero
Este segundo convertidor se puede personalizar mediante el uso de atributos adicionales, es el
convertidor de Nmero.
El es til para mostrar nmeros en los formatos de base que trabaja para la configuracin regional del
usuario.
<f*convert:umber t#pe$%number% max5nteger,igits$%7%/>
</ &* output"ext>
La lista a continuacin muestra el atributo que se puede utilizar con el convertidor de Nmero. Estos
atributos permiten controlar de manera precisa cmo se muestra un nmero.
Nombre del atributo Descripcin
CurrencyCode Especifica un perodo de tres dgitos del cdigo de
moneda internacional cuando el atributo tipo es la
moneda. Utilice este o CurrencySymbol.
CurrencySymbol Especifica un smbolo especfico, como "$", que se
utiliza cuando el tipo de atributo es moneda.
Utilice este o CurrencyCode.
groupingUsed True si un smbolo de agrupacin, como "," o ""
debe ser utilizado. El valor predeterminado es
true.
integerOnly Verdadero si slo la parte entera del valor de
entrada debe ser procesado (todos los decimales
ser ignorado). El valor predeterminado es falso.
locale El local que se utilizar para la visualizacin de
este nmero. Reemplaza el usuario localizacin
actual
minFractionDigits Una cantidad mnima de decimales que se vea.
maxFractionDigits Mxima nmero de decimales que se vea.
minIntegerDigits Una cantidad mnima de dgitos enteros para
mostrar.
maxIntegerDigits Mxima nmero de dgitos enteros para mostrar.
pattern El modelo de formato decimal para convertir este
nmero. Utilice este o tipo de atributo.
tipo El tipo de nmero, por el nmero (number, por
defecto), la moneda (currency), o por ciento
(percent). Usar este o el patrn de este atributo.
Ejemplo:
converters.x&tml*
<&*&ead>
<title>.onvertidores >SF</title>
</&*&ead>
<&*bod#>
<&8>.onvertidores</&8>
<p> 2ostrar sMlo la fec&a # la datest#le es <i> s&ort </i> </p>
<&*output"ext value$%IF(suario.fecnacH%>
<f*convert,ate"ime t#pe$%date% dateSt#le$%s&ort% />
</&*output"ext>
<p> 2ostrar sMlo el tiempo # el timeSt#le es <i> full </i> </p>
<f*convert,ate"ime t#pe$%time% timeSt#le$%full% />
</&*output"ext>
<p> 0antalla de fec&a # &oraL la datest#le es <i> full </i> # la configuraciMn regional es
<i> ru </i> </p>
<f*convert,ate"ime t#pe$%bot&% dateSt#le$%full% locale$%ru% />
</&*output"ext>
<p> 2ostrar tantoL la fec&a # la &ora # el datest#le es <i> s&ort </i> </p>
<f*convert,ate"ime t#pe$%bot&% dateSt#le$%s&ort% />
</&*output"ext>
<p> 2uestra una fec&a con el patrMn de <i> dd.mm.aaaa 11* mm </i> </p>
11*mm% pattern$%dd.22.#### <f*convert,ate"ime />
</&*output"ext>
<&*form id$%datetime1%>
<p> entrada de una fec&a # el datest#le es <i> s&ort </i> </p>
<&*input"ext value$%IF(suario.fecnacH%>
<f*convert,ate"ime t#pe$%date% dateSt#le$%s&ort% />
</&*input"ext>
<&*command4utton value$%Send% />
</&*form>
<&*form id$%datetimeQ%>
<p> de entrada de una fec&a <ue coincide con este patrMn <i> dd.mm.aaaa </i> </p>
<&*input"ext value$%IF(suario.fecnacH%>
<f*convert,ate"ime pattern$%dd.22.####% />
</&*input"ext>
</&*form>
<&8> convertidor :[mero </&8>
<p> mNxima de pantalla <i> 7 dKgitos entero </i> </p>
<&*output"ext value$%IF(suario.test5ntH%>
<f*convert:umber max5nteger,igits$%7% />
</&*output"ext>
<p> "ipo de pantalla es <i> moneda </i> # la .urrenc#S#mbol es <i> V </i> </p>
<f*convert:umber t#pe$%currenc#% currenc#S#mbol$%V%/>
</&*output"ext>
<p> "ipo de pantalla es <i> por ciento </i> </p>
<f*convert:umber t#pe$%percent%/>
</&*output"ext>
2ostrar <p> mNximo de 8 dKgitos de fracciMn </p>
<&*output"ext value$%IF(suario.salarioH%>
<f*convert:umber maxFraction,igits$%8%/>
</&*output"ext>
<p> 2ostrar el n[mero de patrones <i> I I I 9L99 </i> </p>
<&*output"ext value$%IF(suario.salarioH%>
<f*convert:umber pattern$%III9.99%/>
</&*output"ext>
<&*form id$%number1%>
<p> entrada de un n[meroL pero sMlo los dKgitos entero serN procesado </p>
<&*input"ext value$%IF(suario.test5ntH%>
<f*convert:umber integer-nl#$%true%/>
</&*input"ext>
</&*form>
<&*form id$%numberQ%>
<p> entrada de un n[mero coincida con el patrMn <i> II9L99 </i> </p>
<&*input"ext value$%IF(suario.test5ntH%>
<f*convert:umber pattern$%II9L99%/>
</&*input"ext>
</&*form>
</&*bod#>
7.4 Convertidores personalizados
A veces, los convertidores estndar no son suficientes.
Por ejemplo, usted puede necesitar guardar en una base de datos los nmeros de tarjeta de crdito sin
guiones o espacios. Para usar convertidor personalizado, usted necesita para crear una implementacin
de la interfaz que javax.faces.Converter, y sobreescibir sus mtodos getAsObject y getAsString.
Debe implementar las dos direcciones del convertidor. Durante al Apply Request Values (fase 2), el
servlet JSF utiliza el getAsObject mtodo para convertir la cadena de entrada al modelo de objetos de
datos. Durante Render Response (fase 9), el servlet JSF utiliza el mtodo getAsString para hacer la
conversin en la direccin opuesta, de manera que una cadena puede ser incluido en la respuesta HTML.
Una vez finalizado el conversor, tiene que registrarse con la aplicacin. Se puede registrar en faces-
config.xml o usando la notacin !Faces.onverter.
<converter>
<converter-id>..:umber.onverter</converter-id>
<converter-class>curso.converters...:umber.onverter</converter-class>
</converter>
Para invocar el convertidor, usted necesita juntar como una propiedad de f: convertidor o asignar a la
propiedad Converter del componente de entrada.
Ejemplo:
Vamos a crear un convertidor que va a limpiar un nmero de tarjeta de crdito de cualquier carcter no
numrico.
pacCage curso.converters=
import javax.faces.convert..onverter=
import javax.faces.convert..onverter'xception=
import javax.faces.convert.Faces.onverter=
!Faces.onverterDvalue$%..:umber.onverter%E

public class ..:umber.onvert'r implements .onverter F
// getJs-bject extracts from t&e input string all numeric c&aracters
public -bject getJs-bjectDFaces.ontext ctxL (5.omponent cmpL
String valE F
String convRal $ null=
if Dval +$ nullE F
c&arXY c&ars $ val.trimDE.to.&arJrra#DE=
convRal $ %%=
for Dint C $ 9= C < c&ars.lengt&= CWWE F
if Dc&arsXCY >$ @9@ SS c&arsXCY <$ @B@E F
convRal W$ c&arsXCY=
H
H

S#stem.out.printlnD%..:umber.onverter.getJs-bject* @%
W val W %@ -> @% W convRal W %@%E=

H
return convRal=
H
// getJsString inserts into t&e object string spaces to maCe it readable
// default* nnnn nnnn nnnn nnnnL Jmex* nnnn nnnnnn nnnnn
public String getJsStringDFaces.ontext ctxL (5.omponent cmpL -bject valE
t&rows .onverter'xception F
String convRal $ null=
if Dval +$ nullE F
intXY spaces $ F7L \L 11L BBH=
intXY amex $ F7L BL BBH=
String sRal $ null=
tr# F
sRal $ DStringE val= // "&e val object s&ould be a String+
H catc& D.lass.ast'xception eE F
t&row new .onverter'xceptionD%..:umber.onverter* .onversion 'rror%E=
H
int CSpace $ 9=
c&arXY c&ars $ sRal.to.&arJrra#DE=
if Dc&ars.lengt& $$ 1TE F
spaces $ amex=
H
convRal $ %%=
for Dint C $ 9= C < c&ars.lengt&= CWWE F
convRal W$ c&arsXCY=
if DspacesXCSpaceY $$ CE F
convRal W$ @ @=
CSpaceWW=
H
H

S#stem.out.printlnD%..:umber.onverter.getJsString* @%
W sRal W %@ -> @% W convRal W %@%E=
H
return convRal=
H
convertersPperso.x&tml*
<&*&ead>
<title>.onvertidor 0ersonaliGado</title>
</&*&ead>
<&*bod#>
<&8>.onvertidor 0ersonaliGado </&8>
<&*form id$%numberQ%>
<p> entrada de un n[mero de tarjeta</p>
<&*input"ext value$%IF(suario.pasatiempoH% converter$%..:umber.onverter%>
</&*input"ext>
</&*form>
</&*bod#>
8 Validadores
8.1 Uso y Creacin de los validadores
Cmo garantizar que el usuario de la aplicacin no puede compra un nmero negativo de libros? En
realidad, la aplicacin tambin debe rechazar cualquier intento de compra de cero libros. Y qu hay de
comprobar la validez de un nmero de tarjeta de crdito? Estas son tareas para los validadores.
JSF cuenta con cuatro tipos de mecanismos de validacin:
Integrada en los componentes
Validacin a nivel de aplicacin
Componentes de validacin personalizada
Validacin por mtodos de Backed Beans
8.2 Validadores incluidos
JSF proporciona los siguientes tres componentes de validacin:
F: validateDoubleRange: Se valida que una entrada numrica est dentro de un rango determinado. Es
aplicables a los valores que se pueden convertir a un doble.
f: validateLength: Se valida que la longitud de la cadena de entrada est dentro de un rango
determinado.
F: validateLongRange: Se valida que una entrada numrica est dentro de un rango determinado. Es
aplicables a los valores que se pueden convertir a un long.
Para utilizar estos componentes de validacin, simplemente anidar dentro de la h: input que necesita
validacin. Por ejemplo, para comprobar que slo cantidades positivas se pueden introducir:
<&*input"ext id$%<uantit#% value$%IFitem.<uantit#H% siGe$%Q%
re<uired$%true%
re<uired2essage$%.uantos? :inguno?%
converter2essage$%(n entero por favor+%
validator2essage$%2inimo uno+%>
<f*validate3ong;ange minimum$%1%/>
</&*input"ext>
8.3 Validacin a nivel de aplicacin
La validacin a nivel de aplicacin tiene sentido si es necesario para validar la lgica de aplicacin, a
diferencia de la validacin de la correccin formal de los campos individuales. Por ejemplo, antes de
aceptar un pedido, le gustara comprobar que su banco no tiene en la lista negra el nmero de tarjeta de
crdito.
Si desea hacer alguna solicitud de validacin a nivel de aplicacin, puede insertar su lgica al
principio del mtodo llamada por el formulario y hacer que la actualizacin de bases de datos y el
resultado mtodo depende del resultado de validacin. En caso de error de validacin, tambin podra
enviar un mensaje para el usuario, como se muestra en las pocas lneas siguientes:
Faces.ontext ctxt $ Faces.ontext.get.urrent5nstanceDE=
Faces2essage mess $ new Faces2essageDE=
mess.setSeverit#DFaces2essage.S'R';5"/P';;-;E=
mess.setSummar#D%'ste es el mensaje de error principal%E=
mess.set,etailD%'ste es el detalle%E=
ctxt.add2essageDnullL messE=
El mensaje creado de esta manera es un mensaje global, no vinculada a ningn componente en
particular, y se puede visualizar con el componente JSF siguiente:
<&*messages global-nl#$%true% st#le.lass$%error%/>
8.4 Validadores personalizados
En el capitulo sobre los convertidores, se explico cmo implementar un convertidor personalizado. Para
implementar un validador personalizado, es un proceso casi idntico:
Crear una aplicacin de la interfaz que javax.faces.validator.Validator y reemplaza el mtodo validar.
Registrar el validador en faces-config.xml o usa la notacin Doclet en la clase.
Dentro de la aplicacin de JSF, consulte el atributo validator del componente.
Supongamos que desea asegurarse de que el crdito, fecha de caducidad de tarjeta proporcionada por el
usuario durante el pedido est en el formato mm / ao y que la tarjeta no ha caducado.
pacCage curso.validators=
import javax.faces.validator.Ralidator=
import javax.faces.validator.Ralidator'xception=
import java.util.Oregorian.alendar=
import java.util..alendar=
import javax.faces.validator.FacesRalidator=
!FacesRalidatorD%..'xpir#Ralidator%E
public class ..'xpir#Ralidator implements Ralidator F
public ..'xpir#RalidatorDE F
H
public void validateDFaces.ontext cntxL (5.omponent cmpL -bject valE F
String messS $ null=
StringXY fields $ DDStringE valE.splitD%/%L 7E=
if Dfields.lengt& +$ QE F
messS $ %Se espera 22/JJ+%=
H else F
int mont& $ 9=
int #ear $ 9=
tr# F
mont& $ 5nteger.parse5ntDfieldsX9YE=
#ear $ 5nteger.parse5ntDfieldsX1YE=
H catc& D:umberFormat'xception eE F
H
if Dmont& <$ 9 ZZ mont& > 1QE F
messS $ %2es % W fieldsX9Y W % invalido+%=
H else if D#ear < 9 ZZ #ear > BBE F
messS $ %JSntild*o % W fieldsX1Y W % invalido+%=
H else F
Oregorian.alendar cal $ new Oregorian.alendarDE=
int t&is2ont& $ cal.getD.alendar.2-:"1E W 1=
int t&is/ear $ cal.getD.alendar./'J;E - Q999=
if D#ear < t&is/ear ZZ #ear $$ t&is/ear SS mont& < t&is2ont&E F
messS $ %"arjeta vencida+%=
H
H
H
Faces2essage mess $ new Faces2essageD
Faces2essage.S'R';5"/P';;-;L messSL messSE=
t&row new Ralidator'xceptionDmessE=
H
H
H
Para registrar el validador, es necesario agregarlo a faces-config.xml o usar la anotacin !FacesRalidator.
<validator>
<validator-id>..'xpir#Ralidator</validator-id>
<validator-class>curso.validators...'xpir#Ralidator</validator-class>
</validator>
Uso:
<&*form>
<&*input"ext id$%ccexpir#% value$%IF(suario.apellidoH% rendered$%true%
re<uired2essage$%:o puede estar vacio%>
<f*validator validator5d$%..'xpir#Ralidator% />
</&*input"ext>
<&*message for$%ccexpir#% error.lass$%error% />
<f*verbatim><br/></f*verbatim>
<&*command4utton value$%0robar%></&*command4utton>
</&*form>
8.5 Validador en Backed Bean
En lugar de crear una nueva clase como se describe en la seccin anterior, puede agregar un mtodo a un
backed bean.
En este caso, puedes hacer lo siguiente:
Copiar el mtodo de validacin dentro de la clase
Copia de las importaciones
Sustituya la lnea que lanza la ValidatorException con :
Faces2essage mess $ new Faces2essageDmessSE=
cntx.add2essageDcmp.get.lient5dDcntxEL messE=
H
Ejemplo:
<&*input"ext id$%ccexpir#% value$%IF(suario.apellidoH% rendered$%true% re<uired2essage$%:o puede
estar vacio% validator$%IF(suario.validate..'xpir#H%>
</&*input"ext>
<&*message for$%ccexpir#% error.lass$%error% />
9 Componentes personalizados
9.1 Creacin de componentes personalizados para JSF
La funcionalidad de un componente se centra en la conversin de lo sometido por un usuario (es decir, los
parmetros HTTP de la peticin) a valores de los componentes (a travs del mtodo de decodificacin
durante Apply Request Values) y la conversin de valores de los componentes de vuelta a HTML (a
travs del mtodo de codificar durante Render Response).
Cuando se disea un componente JSF, se puede optar por cambiar la codificacin y decodificacin de una
clase separada de procesamiento. La ventaja de este enfoque es que se puede desarrollar ms de un
procesador para el mismo componente, cada uno con una representacin diferente en HTML. Usted a
continuacin, tienen el mismo comportamiento asociados con diferentes maneras de leer los datos de la
solicitud de y la escritura a la respuesta.
En general, teniendo en cuenta que JSF es de cdigo abierto, podra considerar la modificacin de un
componente existente en lugar de desarrollar un nuevo, o quizs, gracias a la separacin de los
componentes y los renderer, la modificacin de un renderer existentes.
La clase raz de todos los componentes JSF es la clase abstracta javax.faces.component.UIComponent, y
de la clase raz de todos los renderers es javax.faces.render.Renderer. Para desarrollar un componente,
sin embargo, usted probablemente va a preferir ampliar un componente ya existente o, por lo por lo
menos, la clase UIComponentBase, que proporciona implementaciones por defecto de todos los abstractos
los mtodos de UIComponent. De esta forma, usted slo tiene que desarrollar cdigo para los mtodos
que se necesidad de reemplazar. Lo mismo ocurre con el procesador.
Para completar el panorama de lo que usted necesita hacer para tener su componente personalizado, es
crear una etiqueta personalizada para usarlo con JSP. La clase raz de todas las clases de etiqueta
javax.faces.webapp.UIComponentELTag.
En resumen, para desarrollar un componente personalizado, tiene que ir a travs de los pasos siguientes,
aunque no necesariamente en este orden:
Crear una clase de componentes que las subclases UIComponent por la ampliacin de una
existente componente.
Registrar el componente en faces-config.xml.
Crear una clase de procesador que subclasa Renderer y reemplaza los mtodos de codificacin y
descodificacin.
Registrar el renderirer en faces-config.xml.
Crear una etiqueta personalizada que subclasa UIComponentELTag.
Crear un TLD para la etiqueta personalizada.
Una ltima palabra acerca de los componentes y los renderers: a menos que usted realmente piensa que
usted va a la reutilizar el mismo componente para diferentes aplicaciones, te hars la vida mucho ms
fcil si mantienes el renderer dentro del componente.
En primer lugar, vamos a ver lo que se debe hacer cuando estn separados, y a continuacin veremos
cmo mantenerlos juntos.
Le mostraremos cmo desarrollar un componente que combina la funcionalidad de los tres componentes
estndar necesarios para aceptar la entrada de un usuario: una etiqueta que explica lo que se espera, el
campo de texto para aceptar la entrada, y un mensaje para informar de errores de entrada. En otras
palabras, vamos a muestra cmo reemplazar el cdigo de JSF siguientes:
<&*output"ext value$%:ombre de .ontacto%/>
<&*input"ext id $ %nombre% re<uired $ %true%
value $ %I F(suario.nombreH%
re<uired2essage $ %'l valor es necesario+%
/>
<&*message for$%name% st#le.lass$%error%/>
con este componente personalizado:
<curso*input'ntr# label$%:ombre de .ontacto% re<uired $ %true%
value $ %IF(suario.nombreH%
errorSt#le.lass $%error% re<uired2essage $ %'l valor es necesario+%
/>
Tambin le mostraremos cmo este nuevo componente inputEntry imprime un asterisco al lado de
la etiqueta si es necesario = "true".
9.1.1 El Componente
El componente es en realidad la parte ms fcil. Vamos a travs de los mtodos de uno por uno.
InputEntryComponent es la inicializacin de los componentes.
Su nica tarea es registrar con el componente de la cadena que identifica el renderer. La nica
propiedad del componente se define en este archivo es la etiqueta (label). Esto se debe a que esta
ampliacin UIInput, que se encarga de definir todo lo que tiene que ver con el campo de entrada.
Se utiliza el mtodo getFamily para encontrar todos los renderers asociados con este componente.
Estamos planeando crear un solo procesador, pero sigue siendo apropiada para definir una familia ms
bien que heredan de la familia de UIInput, porque no se poda utilizar renderizadores UIInput con
InputEntryComponent.
El estado del componente consiste en el estado de UIInput ms la propiedad de la etiqueta. Por lo tanto,
definir su estado como un arreglo de dos objetos. El metodo SaveState forma una
matriz y lo devuelve, para que JSF puede salvarlo. El mtodo restoreState recibe el Estado,
lo descomprime, y lo almacena localmente. Observe cmo las operaciones que tienen que ver con UIInput
son siempre delegadas.
pacCage curso.components=
import javax.faces.component.Faces.omponent=
import javax.faces.component.(55nput=
!Faces.omponentD%curso.input'ntr#%E
public class 5nput'ntr#.omponent extends (55nput F
private String label=
public 5nput'ntr#.omponentDE F
t&is.set;enderer"#peD%curso.input'ntr#%E=
H
public String get3abelDE F
return label=
H
public void set3abelDString labelE F
t&is.label $ label=
H
// -verridden met&ods
public String getFamil#DE F
return %curso.input'ntr#%=
H
public void restoreStateDFaces.ontext ctxtL -bject stateE F
-bject valXY $ D-bjectXYE state=
super.restoreStateDctxtL valX9YE=
label $ DStringE valX1Y=
H
public -bject saveStateDFaces.ontext ctxtE F
-bject valXY $ new -bjectXQY=
valX9Y $ super.saveStateDctxtE=
valX1Y $ label=
return DD-bjectE valE=
H
H
Ahora que tiene el componente, usted tiene que registrarlo. Para ello, mediante el uso de una notacin
!Faces.omponent o la insercin de la siguientes lneas en faces-config.xml:
<component>
<component-t#pe>curso.input'ntr#</component-t#pe>
<component-class>curso.components.5nput'ntr#.omponent</component-class>
</component>
9.1.2 Renderer
El renderer es un poco ms complicado que el componente. Para implementarlo, se define una clase que
extiende javax.faces.render.Renderer.
Primero vamos a sobreescribir tres mtodos, decode, encodeBegin, y getConvertedValue.
La nica propiedad que se agrega a UIInput es la etiqueta, que el usuario puede modificar.
Por lo tanto, slo es necesario para decodificar el campo de entrada.
El proceso de decodificacin ocurre en la fase de Apply Request Values (fase 2).

El proceso de codificacin requiere ms trabajo que el proceso de decodificacin, porque tiene
para enviar a la respuesta HTTP los tres componentes que se combinan para formar
InputEntryComponent. Esto tiene lugar durante Render Response (fase 9).
Tenemos que crear un mtodo para codificar la etiqueta. Se abre el elemento HTML con la etiqueta
el mtodo de startElement, escribe la etiqueta con un simple mtodo de escritura, escribe un asterisco,
pero slo si se requiere el componente, y se cierra el elemento de la etiqueta con el mtodo de
endElement.
El resultado es algo as como <label>:ombre de contacto * </label>.
Creamos otro mtodo para codificar el campo de entrada. Se abre el elemento de entrada HTML
input, aade los atributos con el mtodo writeAttribute, y cierra el elemento. Los tres
parmetros de writeAttribute son el nombre y el valor del atributo HTML y el nombre de
la propiedad del componente.
El resultado es algo como el siguiente elemento:
<input t#pe$%text% id$%form*name'ntr#% name$%form*name'ntr#% value$%% />
encodeMessage es un mtodo para codificar el mensaje de error. Se obtiene la lista de todos los mensajes
de la cola para el componente, pero slo muestra el primero. Si usted desea mostrar a todos ellos, slo
tiene que sustituir la palabra clave if con un w&ile.
Para mostrar el mensaje, el mtodo abre el elemento SPAN HTML, agrega el atributo de clase para
mostrar el mensaje con el estilo correcto, muestra el mensaje, y se cierra el elemento. El resultado es
algo como lo siguiente elemento: <span class$%error%>(n valor es necesario+</span>
pacCage curso.renderers=
import curso.components.5nput'ntr#.omponent=
import java.io.5-'xception=
import java.util.5terator=
import java.util.2ap=
import javax.el.Ralue'xpression=
import javax.faces.component.(55nput=
import javax.faces.context.;esponse6riter=
import javax.faces.convert..onverter=
import javax.faces.convert..onverter'xception=
import javax.faces.render.Faces;enderer=
import javax.faces.render.;enderer=
!Faces;endererDrenderer"#pe$%curso.input'ntr#%L componentFamil#$%curso.input'ntr#%E
public class 5nput'ntr#;enderer extends ;enderer F
public void decodeDFaces.ontext ctxtL (5.omponent cmpE F
5nput'ntr#.omponent ie.mp $ D5nput'ntr#.omponentE cmp=
2ap re<uest2ap $ ctxt.get'xternal.ontextDE.get;e<uest0arameter2apDE=
String client5d $ cmp.get.lient5dDctxtE=
String val $ DStringE re<uest2ap.getDclient5dE=
DD(55nputE ie.mpE.setSubmittedRalueDvalE=
H
public void encode4eginDFaces.ontext ctxtL (5.omponent cmpE
t&rows 5-'xception F
5nput'ntr#.omponent ie.mp $ D5nput'ntr#.omponentE cmp=
;esponse6riter resp6r $ ctxt.get;esponse6riterDE=
encode3abelDresp6rL ie.mpE=
encode5nputDresp6rL ie.mpE=
encode2essageDctxtL resp6rL ie.mpE=
resp6r.flus&DE=
H
public -bject get.onvertedRalueDFaces.ontext ctxtL (5.omponent cmpL
-bject subRalE t&rows .onverter'xception F
-bject convRal $ null=
Ralue'xpression val'xpr $ cmp.getRalue'xpressionD%value%E=
if Dval'xpr +$ nullE F
.lass val"#pe $ val'xpr.get"#peDctxt.get'3.ontextDEE=
if Dval"#pe +$ nullE F
convRal $ subRal=
if D+val"#pe.e<ualsD-bject.classE SS +val"#pe.e<ualsDString.classEE F
.onverter converter $ DD(55nputE cmpE.get.onverterDE=
converter $ ctxt.getJpplicationDE.create.onverterDval"#peE=
if Dconverter +$ nullE F
convRal $ converter.getJs-bjectDctxtL cmpL DStringE subRalE=
H
H
H
H
return convRal=
H
private void encode3abelD;esponse6riter resp6rL 5nput'ntr#.omponent cmpE
resp6r.start'lementD%label%L cmpE=
resp6r.writeDcmp.get3abelDEE=
if Dcmp.is;e<uiredDEE F
resp6r.writeD%*%E=
H
resp6r.end'lementD%label%E=
H
private void encode5nputD;esponse6riter resp6rL 5nput'ntr#.omponent cmpE
Faces.ontext ctxt $ Faces.ontext.get.urrent5nstanceDE=
resp6r.start'lementD%input%L cmpE=
resp6r.writeJttributeD%t#pe%L %text%L %t#pe%E=
resp6r.writeJttributeD%id%L cmp.get.lient5dDctxtEL %id%E=
resp6r.writeJttributeD%name%L cmp.get.lient5dDctxtEL %name%E=
if Dcmp.getRalueDE +$ nullE F
resp6r.writeJttributeD%value%L cmp.getRalueDE.toStringDEL %value%E=
H
resp6r.end'lementD%input%E=
H
private void encode2essageDFaces.ontext ctxtL ;esponse6riter resp6rL
5nput'ntr#.omponent cmpE t&rows 5-'xception F
5terator it $ ctxt.get2essagesDcmp.get.lient5dDctxtEE=
// :otice* an if instead of a w&ile
if Dit.&as:extDEE F
Faces2essage mess $ DFaces2essageE it.nextDE=
if D+cmp.isRalidDEE F
String errorSt#le.lass $
DStringE cmp.getJttributesDE.getD%errorSt#le.lass%E=
resp6r.start'lementD%span%L cmpE=
resp6r.writeJttributeD%class%L errorSt#le.lassL %class%E=
resp6r.writeDmess.get,etailDEE=
resp6r.end'lementD%span%E=
H
H
H
H
Para registrar el renderer, usa una anotacin !Faces;enderer o inserta las lneas siguientes en faces-
config.xml:
<render-Cit>
<renderer>
<component-famil#>curso.input'ntr#</component-famil#>
<renderer-t#pe>curso.input'ntr#</renderer-t#pe>
<renderer-class>curso.renderers.5nput'ntr#;enderer</renderer-class>
</renderer>
</render-Cit>
9.1.3 Tag
El componente personalizado se hizo, pero para usarlo con JSP es necesario definir la etiqueta
personalizada correspondiente. Se crea igual que una accin personalizada pero extendiendo la clase
UIComponentELTag en este caso.
Se define una propiedad para cada atributo con el apoyo de la etiqueta, pero no para
el atributo id. La razn es que UIComponentELTag ya lo define.
Tenga en cuenta que slo tienen mtodos setter, sin los getters correspondiente. Esto es porque nunca se
necesita el mtodos get. El mtodo SetProperties copia los valores de atributo de la etiqueta al
componente, y el mtodo de liberacin limpia lo que ya no es necesario.
pacCage curso.tags=
import javax.el.Ralue'xpression=
import javax.faces.webapp.(5.omponent'3"ag=
public class 5nput'ntr#"ag extends (5.omponent'3"ag F
private Ralue'xpression errorSt#le.lass=
private Ralue'xpression label=
private Ralue'xpression re<uired=
private Ralue'xpression re<uired2essage=
private Ralue'xpression value=
// Setters
public void set'rrorSt#le.lassDRalue'xpression errorSt#le.lassE F
t&is.errorSt#le.lass $ errorSt#le.lass=
H
public void set3abelDRalue'xpression labelE F
t&is.label $ label=
H
public void set;e<uiredDRalue'xpression re<uiredE F
t&is.re<uired $ re<uired=
H
public void set;e<uired2essageDRalue'xpression re<uired2essageE F
t&is.re<uired2essage $ re<uired2essage=
H
public void setRalueDRalue'xpression valueE F
t&is.value $ value=
H
// -verridden met&ods
public String get.omponent"#peDE F
H
public String get;enderer"#peDE F
H
protected void set0ropertiesD(5.omponent cmpE F
super.set0ropertiesDcmpE=
if DerrorSt#le.lass +$ nullE F
cmp.setRalue'xpressionD%errorSt#le.lass%L errorSt#le.lassE=
H
if Dlabel +$ nullE F
cmp.setRalue'xpressionD%label%L labelE=
H
if Dre<uired +$ nullE F
cmp.setRalue'xpressionD%re<uired%L re<uiredE=
H
if Dre<uired2essage +$ nullE F
cmp.setRalue'xpressionD%re<uired2essage%L re<uired2essageE=
H
if Dvalue +$ nullE F
cmp.setRalue'xpressionD%value%L valueE=
H
H
public void releaseDE F
super.releaseDE=
errorSt#le.lass $ null=
label $ null=
re<uired2essage $ null=
value $ null=
re<uired $ null=
H
H
Antes de poder utilizar la etiqueta personalizada en JSP an necesidad de crear un TLD a poner en la
carpeta WEB-INF/tlds/ .
curso.tld:
<?xml version$%1.9% encoding$%("F-)%?>
<taglib version$%Q.1% xmlns$%&ttp*//java.sun.com/xml/ns/javaee%
xmlns*xsi$%&ttp*//www.w7.org/Q991/A23Sc&ema-instance%
xsi*sc&ema3ocation$%&ttp*//java.sun.com/xml/ns/javaee &ttp*//java.sun.com/xml/ns/javaee/web-
jsptaglibrar#PQP1.xsd%>
<tlib-version>1.9</tlib-version>
<s&ort-name>curso</s&ort-name>
<uri>/6'4-5:F/tlds/curso</uri>
<tag>
<displa#-name>input'ntr#</displa#-name>
<name>input'ntr#</name>
<tag-class>curso.tags.5nput'ntr#"ag</tag-class>
<attribute>
<name>id</name>
<re<uired>false</re<uired>
<rtexprvalue>true</rtexprvalue>
</attribute>
<attribute>
<name>value</name>
<deferred-value><t#pe>java.lang.-bject</t#pe></deferred-value>
</attribute>
<attribute>
<name>re<uired</name>
<deferred-value><t#pe>boolean</t#pe></deferred-value>
</attribute>
<attribute>
<name>label</name>
<deferred-value><t#pe>java.lang.String</t#pe></deferred-value>
</attribute>
<attribute>
<name>errorSt#le.lass</name>
</attribute>
<attribute>
<name>re<uired2essage</name>
</attribute>
</tag>
</taglib>
Con esto, usted estar preparado para utilizar el nuevo h JSF componente de interfaz de usuario:
inputEntry. Slo es necesario agregar la siguiente declaracin de espacio de nombres curso a la jsp:
elemento raz en el inicio de el documento JSP: <!taglib prefix$%curso% uri$%6'4-5:F/tlds/curso.tld%>
La desventaja del nuevo componente en comparacin con tener de manera independiente los label, input,
y message, es que no es posible alinear los campos de entrada vertical.
Ahora que ya est hecho, usted puede preguntar, "Por qu curso: inputEntry slo admiten un atributo,
mientras que h:inputText tiene como 40? "Eso es un buen punto. Podramos haber aadido
ms atributos, tales como el tamao del campo de entrada, que h:inputText pasa a HTML, pero nuestro
objetivo era ser capaz de reemplazar con un componente nico de los tres los campos en que se utilicen.
Ms atributos de lo estrictamente necesario slo generara ms cdigo sin aadir nada til.
9.1.4 Inline Renderer
Es posible incluir la funcionalidad de renderer dentro de la clase de componentes, de modo que el
componente se representa (render) por s mismo. Como hemos mencionado antes, a menos que usted
planea utilizar ms de un procesador con el mismo componente, es posible que no se va a molestar
creando rentderers separados.
Para hacer curso: inputEntry con auto-representacin, tiene que hacer lo siguiente:
1. Mueva los mtodos de InputEntryRenderer.java a InputEntryComponent.java. Usted
necesidad hacer algunos cambios cosmticos que vamos a explicar en un momento. Despues se puede
borrar el archivo de renderer.
2. Agregue el mtodo encodeEnd a InputEntryComponent.java.
3. Return null en el mtodo de getRendererType de InputEntryTag.java.
4. Eliminar el registro del procesador de faces-config.xml.
La clase UIInput, que se extiende para crear el componente, hospeda los tres mtodos decode,
encodeBegin, y getConvertedValue que utiliz en el renderer por separado, pero sin el parmetro
UIComponent. Tiene mucho sentido, porque el objeto componente es directamente accesibles con la
palabra clave t&is.
Cuando se quita el parmetro de cmp de los tres mtodos, tambin deber eliminar esta lnea de
decodificar y encodeBegin, porque se ha convertido en intil:
5nput'ntr#.omponent ie.mp $ D5nput'ntr#.omponentEcmp=
Luego, remplaza todos los cmp y ie.mp con t&is.
Se necesita el mtodo encodeEnd para reemplazar el mtodo en UIComponentBase, que arroja un
NullPointerException. De hecho, usted no necesita hacer nada en encodeEnd, solamente tienes que
escribir un mtodo de vaco: public void encode'ndDFaces.ontext contextE t&rows 5-'xception F H
Tenga en cuenta que slo necesita este mtodo cuando se ejecuta un componente en s mismo, no cuando
se utiliza una clase de procesador separado.
En InputEntryTag.java, el mtodo devuelve getRendererType "curso.inputEntry". Si el mtodo consiste
en utilizar sus mtodos de representacin interna, getRendererType tiene que volver null. Por ltimo,
eliminar las lneas del elemento de render kit de faces-config.xml si estn presente.
9.2 Componentes personalizados para Facelets
Con los Facelets es mas sencilla la creacin de componentes personalizados.
No hay necesidad de crear una clase Java, solo necesitamos archivos XHTML (y XML).

Hay que crear un equivalente al TLD para facelets (.xml), y declararlo en web.xml
Ejemplo de inclusin en web.xml:
<context-param>
<param-name>facelets.354;J;5'S</param-name>
<param-value>/6'4-5:F/facelets/curso.xml</param-value>
</context-param>
Ejemplo de descriptor curso.xml:
<+,-."/0' facelet-taglib 0(435.
%-//Sun 2icros#stemsL 5nc.//,", Facelet "aglib 1.9//':%
%&ttp*//java.sun.com/dtd/facelet-taglibP1P9.dtd%>
<facelet-taglib>
<namespace>&ttp*//local&ost</namespace>
<tag>
<tag-name>pie</tag-name>
<source>../include/footer.x&tml</source>
</tag>
</facelet-taglib>
Pagina footer.xhtml:
xmlns*ui$%&ttp*//java.sun.com/jsf/facelets%>
<&*bod#>
<ui*component>
<&*panelOroup st#le.lass$%footer%>
<&*output"ext value$%,ocente* .edric Simon - %/>
<&*output3inC
value$%mailto*cedric!solucionjava.com%>cedric!solucionjava.com</&*output3inC>
</&*panelOroup>.
</ui*component>
</&*bod#>
</&tml>
La pgina a incluir es una pgina JSF XHTML, y el componente que queremos incluir se encuentra
entre <ui*component> y </ui*component>.
Los parametros se recuperan con #{nombreDelParametro}. Se acceptan como parametros tambien
objetos JSF o metodos.
Ejemplo mas complejo, equivalente a InputEntry:
input_entry.xhtml:
xmlns*c$%&ttp*//java.sun.com/jsp/jstl/core%>
<&*bod#>
<ui*component>
<&*output"ext value$%:ombre de .ontacto%/>
<c*if test$%IFre<uiredH%>*</c*if>*
<&*input"ext id $ %nombre% re<uired $ %IFre<uiredH% value $ %IFvalueH%
re<uired2essage $ %'l valor es necesario+% />
<&*message for$%nombre% st#le.lass$%error%/>
</ui*component>
</&*bod#>
</&tml>
custom_component.xhtml:
<&*form>
<curso*input'ntr# label$%:ombre de .ontacto% re<uired $ %true%
value $ %IF(suario.nombreH%
errorSt#le.lass $%error% re<uired2essage $ %'l valor es necesario+%
/>
<f*verbatim><br/></f*verbatim>
<&*command4utton value$%0robar% t#pe$%submit%></&*command4utton>
</&*form>
box_doble.xhtml:
<&*panelOrid border$%1% columns$%Q%>
<ui*insert name$%iG<uierdo%/>
<ui*insert name$%derec&o%/>
</&*panelOrid>
Uso de box_doble:
<curso*boxPdoble>
<ui*define name$%derec&o%>,erec&o</ui*define>
<ui*define name$%iG<uierdo%>5G<uierdo</ui*define>
</curso*boxPdoble>
10Componentes JSF para Ajax
10.1Cmo JSF y Ajax pueden trabajar juntos?
Utilizar el (Ajax) JavaScript en su pgina JSF
Poner su cdigo de Ajax JavaScript en los componentes JSF
Aprovechar la creciente coleccin de marcos de trabajo Ajax JSF
Utilizar el nuevo tag <f:ajax>
10.2Utilizar el (Ajax) JavaScript en su pgina JSF
El ms prctico / forma fcil de inyectar algo de funcionalidad Web 2.0 en su interfaz de usuario JSF,
Puedes agregar tus propios JS, o extender los marcos de trabajo Ajax existentes como:
Dojo
JQuery
Prototype
Scriptaculous
OAT

10.2.1 Pros
Tcnicamente sencillo
Fcil para cosas simples / pequeas
10.2.2 Contras
Trabajo con JavaScript ms avanzado puede ser un reto para los programadores Java (usted
tiene que pasar cdigo (javascript) al lado del cliente).
Puede ser difcil depurar la aplicacin (busque errores tanto en el servidor y el cliente)
10.3Poner su cdigo de Ajax JavaScript en los
componentes JSF
Mediante el uso de la tecnologa JSF de componentes es posible escribir sus propios componentes que
generan el JavaScript necesario en el cliente.
Esto es factible porque JSF puede generar cualquier tipo de texto en el cliente
/ / >avascript ;ender personaliGado para llamar a >SSlider.js
writer.6rite D %<script language$]%>avaScript]% src$]%% context0at& W W %/js/>SSlider.js]%> </
script>%E=
10.3.1 Pros
Arquitectura slida
Usuario final / desarrollador de aplicaciones lo puede utilizar fcilmente sin tratar con JS.
10.3.2 Contras
Puede ser un reto para construir desde un punto de vista tcnico (tienes que ser un experto
cliente Ajax, as como un experto en JSF)
Difciles de depurar en el desarrollo de componentes
10.4Aprovechar la creciente coleccin de marcos de
trabajo Ajax JSF
Ahora pueden descargar diversas bibliotecas de componentes JSF
Instalacin fcil y rpida
Soporte IDE tambin est disponible para muchos (Eclipse, NetBeans, Exadel, JDeveloper ...)
Algunos ejemplos: JBoss RichFaces (Ajax4JSF), ICEfaces, ADF Faces (Trinidad) Rich Client
10.4.1 Pros
Aprendizaje ms fcil
No tienes que lidiar con las complejidades del JavaScript
Pueden elegir entre una creciente coleccin de las bibliotecas
10.4.2 Contras
Si todo funciona, excelente!
Todava puede ser difcil de depurar en el cliente (esto es porque el cdigo de cliente se
representa desde el cliente, y usted tiene poco o ningn control sobre este)
10.5Utilizar el nuevo tag <f:ajax>
JSF 2.0 trae una nueva librera para Ajax.
10.5.1 Pros
Incluida en JSF 2.0
No tienes que lidiar con las complejidades del JavaScript
10.5.2 Contras
Existen limitaciones al uso de h: outputText con Ajax
Tecnologa muy nueva (-->menos fuentes para aprendizaje autodidacto, depuracin), solo JSF 2.0
Todava puede ser difcil de depurar en el cliente (esto es porque el cdigo de cliente se
representa desde el cliente, y usted tiene poco o ningn control sobre este)
10.5.3 Por qu el Ajax en JSF?
Por qu una biblioteca de JSF Ajax especfico?
Hay toneladas de las bibliotecas Ajax ya (jQuery, DWR, GWT, etc.) Por qu inventar una nueva para
JSF?
10.5.3.1 Ventajas de un enfoque especfico JSF Ajax
JSF especfico
Del lado del cliente:
Usted puede actualizar los elementos JSF (h: outputText, h: inputText, h: selectOneMenu, etc).
Usted no tiene que escribir JavaScript
Del lado del servidor
Los backed beans estn disponible en las llamadas Ajax
Usted no tiene que escribir servlets y analizar parmetros
10.5.4 Uso del tag <f:ajax>
Descripcin general:
<&*command4utton ^ action$%^%>
<f*ajax render$%id1 idQ% execute$%id7 id8%
event$%bla&% onevent$%javaScript1andler%/>
</&*command4utton>
Render: especificar los elementos a actualizar en el cliente
Execute: especificar elementos para procesar en el servidor
Event: especificar los eventos de usuario que inician la llamada Ajax
onEvent: especificar los scripts secundarios (JavaScript) a iniciar la llamada Ajax
Backed bean utilizado en los ejemplos abajo:
import javax.faces.bean.SessionScoped=
!2anaged4eanDname $ %Jjax,emo%E
!SessionScoped
public class Jjax,emo F
private 5nteger a $ 9=
private int b$9=
private String respuesta=
public Jjax,emoDE F
H
public void on.licCDE F
a W$ 19=
H
public void executeDE F
double rand $ 2at&.randomDE=
respuesta $ %'l numero al &aGar es % W rand W %L multiplicado por % W a W % $ % W Drand * aE=
H
public 5nteger getJDE F
return a=
H
public void setJD5nteger aE F
t&is.a $ a=
H
public String get;espuestaDE F
return respuesta=
H
public void set;espuestaDString respuestaE F
t&is.respuesta $ respuesta=
H
public int get4DE F
bW$19=
return b=
H
public void set4Dint bE F
t&is.b $ b=
H
H
10.5.4.1 Ejemplo sencillo
Cdigo:
<&*command4utton ^ action$%^%>
<f*ajax render$%id1%/>
</&*command4utton>
/&*command4utton
^
<&*output"ext ^ id$%id1%/>
Interpretacin:
Cuando se pulsa el botn, vaya al servidor, ejecute la accin, calcular el valor del elemento de JSF, cuyo
id es "id1", enviar ese valor al cliente, y luego sustituir ese elemento en el DOM con el nuevo valor.
Ejemplo:
<&*form prepend5d$%false% id$%form%>
<&1>Jjax demo 1</&1>
<&*command4utton action$%IFJjax,emo.on.licCH% value$%Jgrega 19 a J%>
<f*ajax render$%id1% />
</&*command4utton>
<br/>
<&7>Ralor de J*
<&*output"ext id$%id1% value$%IFJjax,emo.aH% />
</&7>
</&*form>
10.5.4.2 renderer: Especificacin de los elementos de actualizacin en el cliente
Resumen de Cdigo
<f*ajax render$%form5d*element5d% />
Idea
Id o lista separada por espacios de las identificaciones de los elementos de JSF cuyos valores separados
por espacios deben ser devueltos desde el servidor y se sustituye en DOM
Detalles
Hay cuatro valores especiales: @ este @ formulario, ninguno @ y @ todos. Sin embargo, estos son ms
frecuentemente utilizados para la ejecucin de atributos que la hacen atributo. Ver seccin del execute.
A menos que utilice <h:form prependId="false"/>, el REAL ID es FormID: elementId.
10.5.4.3 execute: Especificacin de los elementos a procesar en servidor
Resumen de Cdigo
<f*ajax render$%^% execute$%^%^ />
Idea
Un identificador o lista de identificadores JSF separada por espacio que debe ser enviada al servidor
para su ejecucin. Pro ejemplo, un h: inputText, que ser procesado normalmente (setters, validacin,
etc).
Detalles
Hay 4 valores especiales: @this @form, @none @all
@this. El elemento que encierra f:ajax. Predeterminado.
@form. El h:form incluyendo a f: ajax. Muy conveniente si usted tiene varios campos para enviar.
@none. Nada de lo enviado. til si el elemento que cambia los valores de hacer cada vez que se
evalen.
@all. Todos los elementos de la interfaz de usuario JSF en la pgina.
Ejemplo:
<&*form>
<&*panelOrid columns$%Q%>
:umero a multiplicar *
<&*input"ext id$%a% siGe$%T% value$%IFJjax,emo.aH%>
</&*input"ext>
<&*command4utton action$%IFJjax,emo.executeH% value$%.lic%>
<f*ajax render$%respuesta% execute$%!form%></f*ajax>
</&*command4utton>
</&*panelOrid>
<&r></&r>
<&*output"ext id$%respuesta% value$%IFJjax,emo.respuestaH% />
</&*form>
10.5.4.4 event: mencionar a cual evento de usuario debe disparar la llamada Ajax
Resumen de Cdigo
<f*ajax ;ender$%^% event$%^%^ />
Idea
Nombre del evento Ju JavaScript para responder. No incluya "on", por lo que es mouseover, keyup, Blur,
etc...
Detalles
Por defecto
Si el evento no especificado, por defecto utilizado.
Alto nivel de eventos
JSF aade 2 Extras: accion y valueChange.
Ajuste f:ajax en torno a elementos
<f:ajax render=""> un montn de componentes </ f: Ajax> aade el comportamiento Ajax en el evento
por defecto para cada componente envolvi.
Acciones por defecto:
action: h:CommandButton, h:commandLink
Tenga en cuenta que la "accin" es parte de JSF, y no un nombre de Javascript nativo evento.
Significa que el botn ha sido invocada en cualquier forma (haciendo clic en l, ENTER, si tiene
el foco, el teclado, acceso directo, etc).
valueChange: h:inputText, h:inputSecret, h:inputTextarea, todos los botones de opcin, casilla de
verificacin, y los elementos de men (h:selectOneMenu, etc),
Una vez ms, este evento es aadido por JSF y no es un nombre Javascript nativo evento.
Diferentes navegadores manejan un "cambio" de manera diferente, por lo que este unifica el
comportamiento.
Tambin tenga en cuenta que es "valueChange" no ", valuechange". Los acontecimientos nativas
JavaScript son minsculas (mouseover, keyup, etc)
Ejemplo:
<&*form prepend5d$%false%>
<&1>Jjax 'vent</&1>
<&*command4utton action$%IFJjax,emo.on.licCH% value$%Jgrega 19 a 4%>
<f*ajax render$%id1% event$%mouseover% />
</&*command4utton>
<br/>
<&7>Ralor de 4*
<&*output"ext id$%id1% value$%IFJjax,emo.bH% />
</&7>
</&*form>
11Hibernate
11.1Introduccin
Hibernate es un marco de trabajo para persistencia de datos (en Java).
Hibernate permite manejar la persistencia de los datos en Java, haciendo abstraccin de la base de
datos. Hibernate se encargar de dar los datos al cdigo Java, y se encargar de mantener la base de
datos al da, si se utiliza una base de datos. Es una implementacin de JPA.
11.2Instalacin
Hibernate viene preinstalado en los servidores Jboss y Glassfish.
11.3Configuracin
Para poder usar Hibernate, se requiere configurar un archivo llamado hibernate.cfg.xml que se
encuentra en WEB-INF/clases ( en la raz de las clases Java).
Aqu va un ejemplo de configuracin para conectarse con una base de datos MySQL:
<+,-."/0' &ibernate-configuration 0(435. %-//1ibernate/1ibernate .onfiguration ,", 7.9//':%
%&ttp*//www.&ibernate.org/dtd/&ibernate-configuration-
7.9.dtd%>
<&ibernate-configuration>
<session-factor# name$%curso%>
<propert# name$%&ibernate.connection.driverPclass%>org.gjt.mm.m#s<l.,river</propert#>
<propert# name$%&ibernate.connection.url%>jdbc*m#s<l*//local&ost/curso</propert#>
<propert# name$%&ibernate.connection.username%>curso</propert#>
<propert# name$%&ibernate.connection.password%>1Q7</propert#>
<propert# name$%&ibernate.dialect%>org.&ibernate.dialect.2#S_3T5nno,4,ialect</propert#>
<+-- t&read is t&e s&ort name for
org.&ibernate.context."&read3ocalSession.ontext
and let 1ibernate bind t&e session automaticall# to t&e t&read
-->
<propert# name$%currentPsessionPcontextPclass%>t&read</propert#>
<+-- t&is will s&ow us all s<l statements -->
<propert# name$%&ibernate.s&owPs<l%>true</propert#>
<propert# name$%&ibernate.connection.autocommit%>true</propert#>
</session-factor#>
</&ibernate-configuration>
11.4Utilizacin
Para utilizar Hibernate necesitamos crear un Entity EJB3 y referenciarlo en el archivo de configuracin
de Hibernate.
Existen herramientas para crear las clases a partir de la base de datos.
11.4.1 EJB3 para la table city
City.java:
pacCage curso.&ibernate=
import java.io.SerialiGable=
import javax.persistence.*=
import java.util.Set=
!'ntit#
!"ableDname$%cit#%E
public class .it# implements SerialiGable F
private static final long serialRersion(5, $ 13=
!5d
!OeneratedRalueDstrateg#$Oeneration"#pe.5,':"5"/E
!.olumnDname$%:-P.5"/%E
private int no.it#=
!.olumnDname$%.5"/P:J2'%E
private String cit#:ame=
!.olumnDname$%;'O5-:%E
private String region=
//bi-directional man#-to-one association to 0atient
!-ne"o2an#Dmapped4#$%cit#1%E
private Set<0atient> patients1=
//bi-directional man#-to-one association to 0atient
!-ne"o2an#Dmapped4#$%cit#Q%E
private Set<0atient> patientsQ=
public .it#DE F
H
public int get:o.it#DE F
return t&is.no.it#=
H
public void set:o.it#Dint no.it#E F
t&is.no.it# $ no.it#=
H
public String get.it#:ameDE F
return t&is.cit#:ame=
H
public void set.it#:ameDString cit#:ameE F
t&is.cit#:ame $ cit#:ame=
H
public String get;egionDE F
return t&is.region=
H
public void set;egionDString regionE F
t&is.region $ region=
H
public Set<0atient> get0atients1DE F
return t&is.patients1=
H
public void set0atients1DSet<0atient> patients1E F
t&is.patients1 $ patients1=
H
public Set<0atient> get0atientsQDE F
return t&is.patientsQ=
H
public void set0atientsQDSet<0atient> patientsQE F
t&is.patientsQ $ patientsQ=
H
H
Luego agregamos una lnea en hibernate.cfg.xml:
...
<session-factor# name$%curso%>
...
<mapping class="curso.hibernate.City" />
</session-factor#>
...
11.4.2 HibernateHelper
Para recuperar y manejar la sesin de Hibernate, se necesita una clase, como por ejemplo la clase
HibernateHelper.
HibernateHelper.java:
import org.&ibernate.1ibernate'xception=
import org.&ibernate.Session=
import org.&ibernate.SessionFactor#=
import org.&ibernate.cfg..onfiguration=
public class 1ibernate1elper F
/**
* ;eference to SessionFactor#.
*/
private static SessionFactor# sf=
public static final "&read3ocal session $ new "&read3ocalDE=
public static s#nc&roniGed void initDE F
if Dsf +$ nullE return=
S#stem.out.printlnD%5nitialiGing 1ibernate%E=
tr# F
.onfiguration cfg $ new .onfigurationDE.configureDE=
sf $ cfg.buildSessionFactor#DE=
H catc& D'xception &eE F
S#stem.err.printlnD%(nable to create session factor# from configuration%E=
&e.printStacC"raceDE=
t&row new ;untime'xceptionD%(nable to create session factor#
from configuration%L &eE=
H
S#stem.out.printlnD%1ibernate initialiGed%E=
H
/**
* ;eturn t&e SessionFactor#.
* !return "&e SessionFactor# for t&is application session
*/
public static SessionFactor# sessionFactor#DE F
if Dsf $$ nullE initDE=
return sf=
H
public static void destro#DE F
if Dsf +$ nullE F
tr# F
sf.closeDE=
H catc& D1ibernate'xception &eE F
&e.printStacC"raceDE=
H
H
sf $ null=
S#stem.out.printlnD%1ibernate resources released%E=
H
/**
* .loses an &ibernate F!linC SessionHL releasing its resources.
* !t&rows 1ibernate'xception if an &ibernate error occurs
*/
public static void closeSessionDE t&rows 1ibernate'xception F
Session s $ DSessionEsession.getDE=
session.setDnullE=
if Ds +$ nullE F
s.closeDE=
H
H
/**
* ;eturns an &ibernate F!linC SessionH from t&e session factor#.
* !return an &ibernate F!linC SessionH
* !t&rows 1ibernate'xception if an error occurs
*/
public static Session openSessionDE t&rows 1ibernate'xception F
if Dsf $$ nullE initDE=
Session s $ DSessionEsession.getDE=
if Ds $$ nullE F
s $ sf.openSessionDE=
session.setDsE=
H
return DsE=
H
H
11.4.3 Prueba de uso de Hibernate desde Java
Vamos a conectarnos desde Java y utilizar Hibernate para recuperar datos en la base de datos.
TestExample.java:
import org.&ibernate.1ibernate'xception=
import org.&ibernate."ransaction=
import org.slf8j.3ogger=
import org.slf8j.3oggerFactor#=
public class "est'xample F
final static 3ogger logger $ 3oggerFactor#.get3oggerD"est'xample.classE=
public static void mainDStringXY argsE F
.it# forest1one# $ new .it#DE=
forest1one#.set.it#:ameD%forest cit#%E=
forest1one#.set;egionD%ver# sweet%E=
.it# countr#1one# $ new .it#DE=
countr#1one#.set.it#:ameD%countr# cit#%E=
countr#1one#.set;egionD%tast#%E=
create.it#Dforest1one#E=
create.it#Dcountr#1one#E=
S#stem.out.printlnD%listing...%E=
list.it#DE=
delete.it#Dcountr#1one#E=
list.it#DE=
forest1one#.set.it#:ameD%:ort&er Forest .it#%E=
update.it#Dforest1one#E=
1ibernate1elper.closeSessionDE=
H
private static void list.it#DE F
"ransaction tx $ null=
S#stem.out.printlnD%listing1...%E=
Session session $ 1ibernate1elper.openSessionDE=
tr# F
S#stem.out.printlnD%listing.Q..%E=
tx $ session.begin"ransactionDE=
3ist cit#s $ session.create_uer#D%select & from curso.&ibernate..it# as &%E
.listDE=
S#stem.out.printlnD%listing.7..%E=
S#stem.out.printlnDcit#s.siGeDEE=
for D5terator iter $ cit#s.iteratorDE= iter.&as:extDE=E F
.it# element $ D.it#E iter.nextDE=
S#stem.out.printlnD%.it# $ % W element.get.it#:ameDEE=
H
tx.commitDE=
H catc& D;untime'xception eE F
if Dtx +$ null SS tx.isJctiveDEE F
tr# F
// Second tr# catc& as t&e rollbacC could fail as well
tx.rollbacCDE=
H catc& D1ibernate'xception e1E F
logger.debugD%'rror rolling bacC transaction%E=
H
// t&row again t&e first exception
t&row e=
H
H
H
private static void delete.it#D.it# cit#E F
tr# F
session.deleteDcit#E=
tx.commitDE=
tr# F
tx.rollbacCDE=
H
t&row e=
H
H
H
private static void create.it#D.it# cit#E F
tr# F
session.saveDcit#E=
S#stem.out.printlnD%created...%E=
tx.commitDE=
tr# F
tx.rollbacCDE=
H
t&row e=
H
H
H
private static void update.it#D.it# cit#E F
tr# F
session.updateDcit#E=
tx.commitDE=
tr# F
tx.rollbacCDE=
H
t&row e=
H
H
H
H
11.5Hibernate Query Language
Hibernate utiliza un lenguaje de consulta potente (HQL) que se parece a SQL. Sin embargo, comparado
con SQL, HQL es completamente orientado a objetos y comprende nociones como herencia, polimorfismo
y asociacin.
Para obtener ms informacin sobre el uso del HQL, ver en
http://docs.jboss.org/hibernate/core/3.6/reference/es-ES/html/queryhql.html
11.6Hibernate con JSF
Para usar Hibernate con JSF, vamos a crear un objeto DAO para acceder a la clase City. Luego
podremos manejar el objeto desde JSF.
11.6.1 Clase DAO
Generico.java:
pacCage dao=
/**
*
* !aut&or >avJdicto
*/
public interface Oenerico F
public void guardarD-bject objE=
public void actualiGarD -bject objE=
public void borrarD-bject objE=
public void borrar0or5dD.lass<?> claseL java.io.SerialiGable idE=
public -bject buscar0or5dD .lass<?> claseL java.io.SerialiGable idE=
public 3ist buscar"odosD.lass claseE=
public void inicialiGarD-bject objE=
public void inicialiGar.oleccionDjava.util..ollection coleccionE=
public void guardar.oleccionDjava.util..ollection coleccionE=
public void flus&DE=
public void mergeD-bject objE=
H
CityDao.java:
pacCage dao=
import java.io.SerialiGable=
import java.util..ollection=
import org.&ibernate.1ibernate=
import org.&ibernate._uer#=
import curso.&ibernate..it#=
import curso.&ibernate.1ibernate1elper=
public class .it#,ao implements Oenerico F
Session session=
public .it#,aoDE F
//session $ SessionFactor#(til.get5nstanceDE.get.urrentSessionDE=
session$1ibernate1elper.openSessionDE=
H
public 3ist buscar"odosD.lass claseEF
3ist<.it#> cit#3ist=
session.begin"ransactionDE=
_uer# <uer# $ session.create_uer#D%from %Wclase.getSimple:ameDEE=
cit#3ist $ <uer#.listDE=
session.get"ransactionDE.commitDE=
return cit#3ist=
H
!-verride
public void actualiGarD-bject objE F
session.refres&DobjE=
H
!-verride
public void borrarD-bject objE F
session.deleteDobjE=
H
!-verride
public void borrar0or5dD.lass<?> claseL SerialiGable idE F
-bject obj $ buscar0or5dDclaseL idE=
session.deleteDobjE=
H
!-verride
public -bject buscar0or5dD.lass<?> claseL SerialiGable idE F
-bject instance $ null=
tr#
F
instance $ session.getDclaseL idE=
H
catc&D ;untime'xception e E
F
e.printStacC"raceDE=
H
return instance=
H
!-verride
public void flus&DE F
session.flus&DE=
H
public -bject find D.lass claseL int idEF
-bject obj $ session.loadDclaseL idE=
return obj=
H
!-verride
public void guardarD-bject objE F
tr#
F
session.save-r(pdateDobjE=
H
F
H
H
!-verride
public void guardar.oleccionD.ollection coleccionE F
session.save-r(pdateDcoleccionE=
H
!-verride
public void inicialiGarD-bject objE F
1ibernate.initialiGeDobjE=
H
!-verride
public void inicialiGar.oleccionD.ollection coleccionE F
tr#
F
1ibernate.initialiGeDcoleccionE=
5terator it$coleccion.iteratorDE=
w&ileDit.&as:extDEE
F
1ibernate.initialiGeDit.nextDEE=
H
H
F
H
H
!-verride
public void mergeD-bject objE F
session.mergeDobjE=
H
H
11.6.2 Acceso desde JSF
CityList1.java:
import javax.faces.bean.RiewScoped=
import dao..it#,ao=
!2anaged4eanDname$%cit#3ist1%E
!RiewScoped
public class .it#3ist1 F
private 3ist<.it#> all=
public 3ist<.it#> getJllDE F
t&is.all $ new .it#,aoDE.buscar"odosD.it#.classE=
return all=
H
public String init.it#DEF
String outcome $ %details%=
return outcome=
H
H
city_list.xhtml:
xmlns*f$%&ttp*//java.sun.com/jsf/core%
xmlns*ui$%&ttp*//java.sun.com/jsf/facelets%>
<&*&ead></&*&ead>
<bod#>
<&*form>
<&*data"able id$%dt1% value$%IFcit#3ist1.allH%
var$%item% bgcolor$%IF1F1F1% border$%19% cellpadding$%T% cellspacing$%7% rows$%8% widt&$%T9%
dir$%ltr% frame$%&sides%
rules$%all% summar#$%'s un codigo >SF para crear un data"able.% >
<&*column >
<&*output"ext value$%.uidad% />
</f*facet>
<&*command3inC value$%IFitem.cit#:ameH% action$%IFcit#3ist1.init.it#H% >
<f*set0ropert#Jction3istener value$%IFitemH%
target$%IFcit#,etails.cit#H%></f*set0ropert#Jction3istener>
</&*command3inC>
</&*column>
<&*column>
<&*output"ext value$%;egion%/>
</f*facet>
<&*output"ext value$%IFitem.regionH%></&*output"ext>
</&*column>
</&*data"able><br />
</&*form>
</bod#>
</&tml>
CityDetails.java:
import javax.faces.event.Jbort0rocessing'xception=
import javax.faces.event.Jction'vent=
import dao..it#,ao=
!2anaged4eanDname$%cit#,etails%E
!;e<uestScoped
public class .it#,etails F
private .it# cit#=
private String cit#:ame=
private int no.it#=
private .it#,ao dao=
public .it#,etailsDE F
dao$new .it#,aoDE=
H
public void onSubmitDJction'vent eE F
S#stem.out.printlnD%submiting +++%E=
if Dcit#:ame.e<uals5gnore.aseD%%EE F
t&row new Jbort0rocessing'xceptionD%.uidad invalida%E=
H
H
public String submitDEF
S#stem.out.printlnD%(pdating +++ no.it#$%Wno.it#E=
cit#$D.it#E dao.findD.it#.classL no.it#E=
cit#.set.it#:ameDcit#:ameE=
dao.guardarDcit#E=
S#stem.out.printlnD%(pdated +++ W %Wcit#:ameE=
S#stem.out.printlnD%submitQQQQ +++%E=
String outcome $ %success%=
return outcome=
H
public .it# get.it#DE F
S#stem.out.printlnD%````` - %Wcit#.get.it#:ameDEE=
return cit#=
H
public void set.it#D.it# cit#E F
S#stem.out.printlnD%AAAAAAAAAA%E=
t&is.cit# $ cit#=
H
public String get.it#:ameDE F
if Dcit#+$nullE
cit#:ame$cit#.get.it#:ameDE=
S#stem.out.printlnD%JJJ %Wcit#:ameE=
//S#stem.out.printlnD%JJJ %Wcit#.get.it#:ameDEE=
return cit#:ame=
H
public void set.it#:ameDString cit#:ameE F
S#stem.out.printlnD%bbb %Wcit#:ameE=
t&is.cit#:ame $ cit#:ame=
H
public int get:o.it#DE F
if Dcit#+$nullE
t&is.no.it#$cit#.get:o.it#DE=
S#stem.out.printlnD%ccc %Wno.it#E=
return no.it#=
H
public void set:o.it#Dint no.it#E F
S#stem.out.printlnD%ddd %Wno.it#E=
t&is.no.it# $ no.it#=
H
H
CityDetails.xhtml:
xmlns*f$%&ttp*//java.sun.com/jsf/core%>
<&*&ead></&*&ead>
<&*bod#>
<&*form >
<&*input1idden value$%IFcit#,etails.no.it#H% id$%no.it#%/>
<&1>,etalle de la cuidad de <&*output"ext value$%IFcit#,etails.cit#:ameH% /></&1>
<&*panelOrid bgcolor$%#ellow% columns$%1%>
<&*column><&*input"ext value$%IFcit#,etails.cit#:ameH% autocomplete$%off% id$%cit#:ame%
re<uired2essage$%3a cuidad no puede estar vacia% >
<f*validate3engt& minimum$%Q% /></&*input"ext>
</&*column>
<&*column><&*command4utton value$%'nviar% action$%IFcit#,etails.submitH%
action3istener$%IFcit#,etails.onSubmitH% /> </&*column>
</&*panelOrid>
</&*form>
</&*bod#>
</&tml>
Agregar a faces-config.xml:
<navigation-rule>
<from-view-id>/cit#,etails.x&tml</from-view-id>
<navigation-case>
<to-view-id>/cit#Plist.x&tml</to-view-id>
</navigation-case>
</navigation-rule>
<navigation-rule>
<from-view-id>/cit#Plist.x&tml</from-view-id>
<navigation-case>
<from-outcome>details</from-outcome>
<to-view-id>/cit#,etails.x&tml</to-view-id>
</navigation-case>
</navigation-rule>
...

Curso de Java Server Faces 2 Con Hibernate 3

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Curso de Java Server Faces 2 Con Hibernate 3

Cargado por

Copyright:

Formatos disponibles

Curso de

Java Server Faces 2

También podría gustarte