tutorial jsf
TRANSCRIPT
JAVA SERVER FACES Y EL USO DE PATRONES DE DISEÑO
II CONGRESO DE COMPUTACIÓN PARA EL DESARROLLO
John Oliver Quesada Chaves.
Estudiante activo de la carrera de Informática Empresarial.
Universidad de Costa Rica, UCR-Puntarenas, Costa Rica.
8826-99-77
Resumen
En esta ponencia se desarrolla una breve introducción a la implementación de la tecnología Java Server Faces (JSF), se indicarán los requisitos para su utilización, así como las funcionalidades que ofrece.
La tecnología Java Server Faces es un marco de trabajo de interfaces de usuario del lado de servidor para aplicaciones Web basadas en tecnología Java. Útil con aplicaciones basadas en la arquitectura MVC (Model-View-Controller).
Fig. 1, Modelo Vista Controlador.
Este modelo de programación bien definido y la librería de etiquetas para componentes GUI facilita de forma significativa la tarea de la construcción y mantenimiento de aplicaciones Web con GUIs del lado del servidor.
Las aplicaciones JSF son como cualquier otra aplicación Java, se ejecutan en un contenedor Servlet java, y típicamente contienen JavaBeans (llamados objetos del modelo en tecnología JSF) conteniendo datos y funcionalidades especificas de la aplicación, paginas como las JSP, clases de utilidad del lado del servidor, como beans para acceder a las bases de datos.
1. ¿Qué es JSF?
JSF es un marco de trabajo para crear aplicaciones java J2EE basadas en el
patrón MVC de tipo 1. JSF tiene como características principales:
• Utiliza páginas JSP para generar las vistas, añadiendo una biblioteca de
etiquetas propia para crear los elementos de los formularios HTML.
• Asocia a cada vista con formularios un conjunto de objetos java
manejados por el controlador (managed beans) que facilitan la
recolección, manipulación y visualización de los valores mostrados en
los diferentes elementos de los formularios.
• Introduce una serie de etapas en el procesamiento de la petición, como
por ejemplo la de validación, reconstrucción de la vista, recuperación de
los valores de los elementos, etc.
• Utiliza un sencillo fichero de configuración para el controlador en formato
XML.
• Es extensible, pudiendo crearse nuevos elementos de la interfaz o
modificar los ya existentes.
• Y lo que es más importante: forma parte del estándar J2EE. En efecto,
hay muchas alternativas para crear la capa de presentación y control de
una aplicación web java, como Struts y otros frameworks, pero solo JSP
forma parte del estándar.
1.1. Requisitos de implementación. • Las librerías propias de JSF: jsf-api.jar y jsf-impl.jar. La primera contiene
el paquete javax.faces.* y la segunda com.sun.faces.*.
• Las librerías comunes de Apache-Jacarta.
• Además las librerías adicionales standard.jar y jstl.jar.
• Java EE.
2. Implementación.
Las principales implementaciones de JSF son:
• JSF Reference Implementation de Sun Microsystems.
• MyFaces proyecto de Apache Software Foundation.
• Rich Faces
• ICEfaces Contiene diversos componentes para interfaces de usuarios
más enriquecidas, tales como editores de texto enriquecidos,
reproductores de multimedia, entre otros.
En la investigación que eh realizado, me encontrado con diferentes editores
para trabajar JSF, entre los cuales cabe destacar:
• NetBean.
• Eclipse.
• MyEclipse.
• JDeveloper.
Como se menciona anterior mente JSF, permite utilizar diferentes tecnologías
para la capa de presentación en mi caso ADF.
Implementando JSF junto con ADF (es un framework comercial de Java para la
creación de aplicaciones empresariales. Es una herramienta del tipo RAD que
se basa en patrones de diseño listos para usar), encontramos un sin número de
componentes listos para trabajar en flujo constante y ágil con bases de datos.
2.1. Riesgos.
Antes de comenzar el desarrollo con JSF debemos conocer aquellos puntos
que nos pueden perjudicar y hacer más largo el desarrollo de lo realmente es
necesario. Con la poca experiencia que tengo en el tema e indagando, se
pueden mencionar los siguientes puntos:
• Utilizar el alicate para clavar. JSF es una herramienta y como tal tiene
una forma de uso. Si nos empeñamos en seguir desarrollando las
páginas como siempre, intentando adaptar JSF al modo al que
habitualmente desarrollamos en vez de adaptarnos a JSF
complicaremos el desarrollo
• Abuso del javascript. JSF permite utilizar javascript para hacer más
rápida una página HTML, evitando peticiones al servidor. Sin embargo la
introducción de javascript en la página complica y alarga los desarrollos
con JSF, y en general con jsp. La capa javascript añade etapas
adicionales a la aplicación, que hace más difícil su depurado. Un
consejo: la página debería poderse ejecutar sin pérdida de funcionalidad
(sólo de rendimiento si se desactiva el javascript).
• La maquetación compleja también complica el desarrollo ya que obliga a
utilizar muchas etiquetas y atributos, especialmente en los datatables. Si
la maquetación de nuestras páginas es compleja deberíamos pensar en
crear componentes JSF a medida que simplifiquen dicho trabajo.
2.2. ¿Cómo funciona?
Normalmente las aplicaciones web se construyen como un conjunto de
pantallas con las que va interactuando el usuario. Estas pantallas contienen
textos, botones, imágenes, tablas y elementos de selección que el usuario
modifica.
Todos estos elementos estarán agrupados en formularios HTML, que es la
manera en que las páginas web envían la información introducida por el
usuario al servidor.
La principal función del controlador JSF es asociar a las pantallas, clases java
que recogen la información introducida y que disponen de métodos que
responden a las acciones del usuario. JSF nos resuelve de manera muy
sencilla y automática muchas tareas:
• Mostrar datos al usuario en cajas de texto y tablas.
• Recoger los datos introducidos por el usuario en los campos del
formulario.
• Controlar el estado de los controles del formulario según el estado de la
aplicación, activando, ocultando o añadiendo y eliminando controles y
demás elementos
• Realizando validaciones y conversiones de los datos introducidos por el
usuario
• Rellenando campos, listas, combos y otros elementos a medida que el
usuario va interactuando con la pantalla
• Controlando los eventos que ocurren en los controles (pulsaciones de
teclas, botones y movimientos del ratón).
Las aplicaciones JSF están formadas por los siguientes elementos principales:
• Páginas JSP que incluyen los formularios JSF. Estas páginas generarán
las vistas de la aplicación
• Beans java que se conectan con los formularios JSF
• Clases java para la lógica de negocio y utilidades.
• Ficheros de configuración, componentes a medida y otros elementos del
framework.
• Resto de recursos de la aplicación web: recursos estáticos, java script y
otros elementos.
3. Estructura de JSF.
3.1. Los Backbeans.
A las clases java que se asocian a los formularios JSF se les denomina
backend beans ya que son los beans (clases java) que están detrás del
formulario. Estos beans se referencian en el fichero de configuración de JSF en
el apartado de managed beans, ya que son beans gestionados por el
controlador JSF. Este se encarga de su construcción y destrucción automáticas
cuando es necesario.
3.2. Estructura de las páginas.
En su versión más sencilla, cada página JSF está formada por una página JSP
que contiene un formulario (HTML FORM) y un backbeans.
El controlador JSF registra en el servidor de aplicaciones un tipo especial de
petición, típicamente *.jsf, que estará asociado a estas páginas.
El primer caso comienza cuando el usuario realiza en su navegador una
petición de navegación a una url de tipo *.jsf. Cuando al servidor web llega una
petición del tipo pagina JSF, el controlador JSF entra en funcionamiento.
Primero comprueba si es la primera vez que se accede a dicha página. Si es
así, carga la página jsp asociada pagina.jsp y la procesa construyendo en
memoria la representación de los controles de la página. Tras esta etapa JSF
sabe cómo construir el código HTML de salida y la lista de controles de usuario
que la cumplen, es decir, sabe lo que contiene y cómo pintarla.
El siguiente paso es asociarle los backbeans. Para ello, del procesamiento de
la página jsp, el controlador ha obtenido la lista de backbeans asociados, por lo
que procede a buscarlos en sus correspondientes ámbitos de la aplicación
como la request y la session. Los beans que no existan se crean llamando a los
constructores de sus clases, definidos en la session de managed beans del
fichero de configuración de JSF.
El tercer paso es dar valores a las propiedades de los elementos JSF de la
página. Aquí juega un papel fundamental el lenguaje de expresiones de JSF,
que es parecido al lenguaje de expresiones que se permite en las páginas jsp
normales.
En su versión más sencilla una expresión JSF sería del tipo
#{mibackbean.propiedad}.
Finalmente el servidor devuelve al usuario una página creada a partir de una
página JSP que incluye normalmente etiquetas JSF, cuyos valores se
extraerán del backbean asociado.
3.3. Navegación.
Cuando se ejecuta una petición que incluye una acción, se ejecuta el
mecanismo de navegación de JSF. Tras la ejecución de la acción, el
controlador determina cómo se debe mostrar al usuario el resultado de la
petición. Hay varias posibilidades:
• Finalizar la petición mostrando la página jsp que originó la petición, que
es la opción por defecto.
• Mostrando otra página jsp diferente.
• Enviar al usuario una petición de redirección, por lo que el navegador del
usuario se dirigirá automáticamente a otra página cuando reciba la
respuesta a su petición.
Este mecanismo de navegación se implementa de manera sencilla en la página
JSF. Cuando el controlador JSF llama al método asociado a la acción, este
devuelve un valor de tipo String. Este valor es utilizado junto con las reglas de
navegación creadas en el fichero de configuración de JSF para determinar la
página que se debe enviar como respuesta al usuario.
• La página de origen. Indica el jsp que originó la petición.
• La etiqueta de destino. Es la cadena que identifica el destino. Esta
cadena es devuelta por el método del backbean que procesa la acción.
• La página de destino para cada etiqueta. Normalmente es el jsp el que
procesará la petición de salida, utilizando los datos que hay en la
request y en la sesión.
• Si es un envío directo interno o una redirección externa. En el primer
caso la respuesta se generará en la misma petición mediante una
redirección interna a otro jsp o servlet. En el segundo caso se enviará
como respuesta al navegador una instrucción de redirección para que el
navegador realice una nueva petición de otra página.
Además las direcciones de origen admiten el * para que una misma regla sirva
para múltiples páginas. También se pueden poner reglas por defecto que se
aplican a todas las peticiones.
4. Gestión de beans.
JSF gestiona automáticamente la creación y el acceso a los beans que utilizan
las páginas jsp. Para ello el controlador determina qué beans utiliza la página y
dónde debe almacenarlos. El fichero de configuración JSF mapea los nombres
cortos de los beans utilizados en las páginas con las clases java que los
definen.
¿Cuando se crean los beans? JSF busca el bean cada vez que se menciona
en la página, en el orden en que aparecen en la página. Si el bean no existe en
el ámbito, lo crea. Por tanto el orden de las expresiones lo determina el orden
de la creación de los beans, si usamos más de un bean en la página.
¿Cómo se hace esto internamente? Al procesar la página JSP, las etiquetas
JSF añaden código que busca el bean mencionado en cada expresión. Si el
bean no existe en el ámbito elegido (request, session o application) se crea uno
nuevo, llamando a su constructor por defecto, y se asocia al ámbito requerido.
Este mecanismo es fundamental para la comprensión del procesamiento de la
página, sobre todo si trabajamos con beans de ámbito request.
4. Resultados Preliminares.
Personalmente me incline, por JDeveloper en su última versión (11g), los
motivos de esta elección se debe a que es una herramienta gratuita y la gente
Oracle tiene una comunidad muy grande que trabaja con JSF los cuales
brindan una serie de ejemplos, demos y tutoriales del uso de esta tecnología,
para el desarrollo de aplicaciones Web.
Profundicemos un poco más en los resultados que hasta el momento eh
logrado.
Por ejemplo: La duración para desarrollar una aplicación Web que permita el
registro de información a una Base de Datos, tiene un tiempo alto de desarrollo
considerando todos los procesos que conlleva elaborarla, ahora como seria
esto utilizando JSF con ADF.
Los tiempos de elaboración se puede reducir aproximadamente en un 20%,
teniendo un nivel muy básico como el que mi persona a podido alcanzar, esto
sin duda beneficia satisfactoriamente a cualquier entidad o organización que se
dedique a este campo.
La creación de un proyecto de esta índole, en el editor seleccionado es muy
simple solo basta con seleccionar el tipo de proyecto y las librerías que
queramos implementar en él. Además permite la creación de una conexión con
la base de datos de una forma muy sencilla, esto para facilitar el uso de los
componentes de ADF.
En este punto sería muy útil, realizar la creación de un caso de desarrollo pero
nos extenderíamos mucho en el tamaño del documento, la idea fundamental en
este momento es conocer en sí que es JSF y para qué sirve y como trabaja.
Para no dejar la parte práctica de lado en este artículo tratare de ilustrar la
creación de un proyecto en JSF implementado ADF en JDeveloper 11g.
Primero que todo iniciaremos nuestro editor:
Fig. 2, Página de inicio de JDeveloper.
Luego crearíamos una aplicación nueva la cual debe contener en la capa de
vista los componentes de ADF, estos componentes tienen la versatilidad de
manipular las estructuras de la base de datos, pero primero para esto se realiza
una conexión previa con la misma.
Fig. 3, Creación de conexión con base de datos.
Fig. 4, creación de un proyecto con JSF-ADF.
En este momento se ha creado una nueva aplicación de JSF implementado la
tecnología de ADF, estos permitirá la creación de páginas en las cuales
podemos implementar de una forma muy ágil y rápida estos componentes que
nos harán el trabajo más rápido en el momento de desarrollar.
Para utilizar las estructuras de la base de datos (tablas, vistas, etc.),
necesitamos crear un control de datos, esto tiene como función realizar una
especie de persistencia con la base de datos seleccionada, crear una entidad
de cada tabla o vista y un objeto vista de la misma. Aquí es donde se
implementan los componentes de ADF, los cuales realizaran la tarea
anteriormente mencionada.
Fig. 5, utilización de componentes de ADF.
Hasta el momento eh tratado de ilustrar los pasos a seguir para la creación de
una conexión con la base de datos desde el editor, la creación de un nuevo
proyecto con la agregación de la tecnología ADF, la utilización de componentes
ADF para utilizar las estructuras existente en la base de datos. Recalcando que
nos hemos brincado pasados para no extender nuestro articulo.
Con todo esto podemos en este punto plantearnos algunos puntos importantes:
• La creación y agregación de tecnologías técnicamente fácil.
• La creación de un proyecto Web con JSF, se realiza de una forma
sencilla y no presenta ninguna configuración complicada hasta el
momento.
• La creación de entidades para utilizar en las páginas se efectúa
siguiendo un par de siguientes y teniendo una BS bien depurada y lista.
AL mencionar estos puntos llegamos a la conclusión que el trabajo realizado a
sido sencillo y entendible, lo que sigue es entender que nos permite esto en el
desarrollo de aplicaciones y cómo podemos implementar lo hecho hasta el
momento. Para esto continuaremos mostrando ejemplos sobre opciones
sencillas pero muy útiles.
Podemos crear una página la cual tiene una extensión .jsp, en la misma
podremos agregar la funcionalidad deseada.
Fig. 6, creación de página JSF.
Al crear una página y tener nuestro objetos con solo arrastrar algún
componente en cuestión de segundos podemos crear formularios de búsqueda,
mantenimientos, tablas de lectura, lista de valores para opciones de búsqueda
y un sin número de opciones que puede agilizar nuestro desarrollo de una
forma increíble.
Algunos ejemplos
Fig. 7, formulario con in listado de valores.
Fig. 8, formulario de búsqueda.
Fig. 9, Mantenimientos.
5. Discusión
Algunos temas en los que podemos entrar en discusión, para mi humilde punto
de vista serian:
• La disponibilidad de información sobre este tema no es que sea escasa
pero si no es muy sencilla para principiantes a la hora de querer iniciar
en el tema.
• En Costa Rica, no conozco ninguna entidad que trabaje utilizando estas
tecnología lo que impide la búsqueda de ayuda para poder capacitarse.
• Al inicio el conocimiento están básico que el uso o entendimiento es
suma mente difícil, pero a medida que se profundiza en el tema el
desarrollo se agiliza y es impresionante el aprovechamiento que se
puede obtener.
• Para poder hablar de este tema podría llevarme más de un artículo
tratando de explicar componentes y funciones. Sin dejar de lado que mis
conocimientos son auto adquiridos lo que significa que son básicos, pero
con el trabajo que entendido un poco la estructura de trabajo.
6. Conclusion.
El framework JSF forma parte importante del estándar java J2EE. De hecho se
está preparando una nueva versión que traerá numerosas novedades, sobre
todo en lo que se refiere a su integración con AJAX. También se está
comenzando a utilizar en numerosas aplicaciones empresariales, ya que
permite crear pantallas de usuario bastante complejas con una cierta facilidad,
aunque desde luego no es sencillo la primera vez que te enfrentas a este
framework. En la nueva versión se espera una mejora sobre el control de las
fases del ciclo de vida de la petición que faciliten la creación de componentes
JSF complejos que se usan de manera simple.
Este documento es una pequeña introducción al framework JSF. El cual no
abarca completamente todo lo que ofrece la creación de aplicaciones JSF. Se
espera que con este se entienda y se aclaren algunas dudas sobre esta
tecnología para que se sienta el interés de echar un vistazo a JSF y se pueda
hacer una idea de su potencia.
7. Bibliografía.
www.eclipse.org
www.oracle.com
www.java.sun.com