Introducción JSF
Framework
La
palabra inglesa "framework" (marco de trabajo) define, en
términos generales, un conjunto estandarizado de conceptos,
prácticas y criterios para enfocar un tipo de problemática
particular que sirve como referencia, para enfrentar y resolver
nuevos problemas de índole similar.
En
el desarrollo de software, un framework o infraestructura digital, es
una estructura conceptual y tecnológica de soporte definido,
normalmente con artefactos o módulos de software concretos, con base
a la cual otro proyecto de software puede ser más fácilmente
organizado y desarrollado. Típicamente, puede incluir soporte de
programas, bibliotecas, y un lenguaje interpretado, entre otras
herramientas, para así ayudar a desarrollar y unir los diferentes
componentes de un proyecto.
Representa
una arquitectura de software que modela las relaciones generales de
las entidades del dominio, y provee una estructura y una especial
metodología de trabajo, la cual extiende o utiliza las aplicaciones
del dominio.
Son
diseñados con la intención de facilitar el desarrollo de software,
permitiendo a los diseñadores y programadores pasar más tiempo
identificando requerimientos de software que tratando con los
tediosos detalles de bajo nivel de proveer un sistema funcional. Por
ejemplo, un equipo que usa Apache Struts para desarrollar un sitio
web de un banco, puede enfocarse en cómo los retiros de ahorros van
a funcionar en lugar de preocuparse de cómo se controla la
navegación entre las páginas en una forma libre de errores.
MVC
Modelo
Vista Controlador (MVC) es un patrón de arquitectura de software que
separa los datos de una aplicación, la interfaz de usuario, y la
lógica de control en tres componentes distintos. El patrón MVC se
ve frecuentemente en aplicaciones web, donde la vista es la página
HTML y el código que provee de datos dinámicos a la página (por
ejemplo JSP). El modelo es el Sistema de Gestión de Base de Datos y
la Lógica de negocio (por ejemplo java), y el controlador es el
responsable de recibir los eventos de entrada desde la vista (por
ejemplo Servlet).
- Modelo: Esta es la representación específica de la información con la cual el sistema opera. La lógica de datos asegura la integridad de estos y permite derivar nuevos datos; por ejemplo, no permitiendo comparar un número de unidades negativo, calculando si hoy es el cumpleaños del usuario o los totales, impuestos o importes en un carrito de la compra.
- Vista: Este presenta el modelo en un formato adecuado para interactuar, usualmente la interfaz de usuario.
- Controlador: Este responde a eventos, usualmente acciones del usuario e invoca cambios en el modelo y probablemente en la vista.
Muchos
sistemas informáticos utilizan un Sistema de Gestión de Base de
Datos para gestionar los datos: en MVC corresponde al modelo. La
unión entre capa de presentación y capa de negocio conocido en el
paradigma de la Programación por capas representaría la integración
entre Vista y su correspondiente Controlador de eventos y acceso a
datos, MVC no pretende discriminar entre capa de negocio de
capa de presentación pero si pretende separar la capa visual gráfica
de su correspondiente programación y acceso a datos, algo
que mejora el desarrollo y mantenimiento de la Vista y el Controlador
en paralelo, ya que ambos cumplen ciclos de vida muy distintos entre
si.
Aunque
se pueden encontrar diferentes implementaciones de MVC, el flujo que
sigue el control generalmente es el siguiente:
- El usuario interactúa con la interfaz de usuario de alguna forma (por ejemplo, el usuario pulsa un botón, enlace, etc.)
- El controlador recibe (por parte de los objetos de la interfaz-vista) la notificación de la acción solicitada por el usuario. El controlador gestiona el evento que llega, frecuentemente a través de un gestor de eventos (handler) o callback.
- El controlador accede al modelo, actualizándolo, posiblemente modificándolo de forma adecuada a la acción solicitada por el usuario (por ejemplo, el controlador actualiza el carro de la compra del usuario). Los controladores complejos están a menudo estructurados usando un patrón de comando que encapsula las acciones y simplifica su extensión.
- El controlador delega a los objetos de la vista la tarea de desplegar la interfaz de usuario. La vista obtiene sus datos del modelo para generar la interfaz apropiada para el usuario donde se refleja los cambios en el modelo (por ejemplo, produce un listado del contenido del carro de la compra). El modelo no debe tener conocimiento directo sobre la vista. Sin embargo, el patrón de observador puede ser utilizado para proveer cierta indirección entre el modelo y la vista, permitiendo al modelo notificar a los interesados de cualquier cambio. Un objeto vista puede registrarse con el modelo y esperar a los cambios, pero aun así el modelo en sí mismo sigue sin saber nada de la vista. El controlador no pasa objetos de dominio (el modelo) a la vista aunque puede dar la orden a la vista para que se actualice. Nota: En algunas implementaciones la vista no tiene acceso directo al modelo, dejando que el controlador envíe los datos del modelo a la vista.
- La interfaz de usuario espera nuevas interacciones del usuario, comenzando el ciclo nuevamente.
Modelo 1
Variante
en la cual no existe ninguna comunicación entre el Modelo y la Vista
y esta última recibe los datos a mostrar a través del Controlador.
Variante
en la cual se desarrolla una comunicación entre el Modelo y la
Vista, donde esta última al mostrar los datos los busca directamente
en el Modelo, dada una indicación del Controlador, disminuyendo el
conjunto de responsabilidades de este último.
Struts
Struts
es una herramienta de soporte para el desarrollo de aplicaciones Web
bajo el patrón MVC bajo la plataforma Java EE (Java Enterprise
Edition). Struts se desarrollaba como parte del proyecto Jakarta de
la Apache Software Foundation, pero actualmente es un proyecto
independiente conocido como Apache Struts
(http://struts.apache.org/).
- Struts permite reducir el tiempo de desarrollo.
- Su carácter de "software libre" y su compatibilidad con todas las plataformas en las que Java Entreprise esté disponible lo convierten en una herramienta altamente disponible.
- Con la versión 2 del framework se introdujeron algunas mejoras sobre la primera versión, de cara a simplificar las tareas más comunes en el desarrollo de aplicaciones web, así como mejorar su integración con AJAX.
- Struts se basa en el patrón de arquitectura de software Modelo-Vista-Controlador (MVC) el cual se utiliza ampliamente y es considerado de gran solidez. De acuerdo con este Framework, el procesamiento se separa en tres secciones diferenciadas llamadas el modelo, las vistas y el controlador.
- Trabajo del controlador es mapear peticiones HTTP entrantes (Action). Los mapas se definen mediante XML (struts.xml) o anotaciones Java.
- Modelo en Struts 2 son las acciones (Action). Cada acción se definirán y aplicarán siguiendo el contrato marco definido (por ejemplo, consisten en un método execute ()). Componente del modelo consiste en el almacenamiento de datos y la lógica de negocio. Cada acción es una encapsulación de solicitudes y se coloca ValueStack.
- View es el componente de presentación de patrón MVC (archivos JSP comunes).
Spring MVC
Es
uno de los módulos del Framework de Spring, y como su propio nombre
nos indica implementa una arquitectura Modelo – Vista –
Controlador.
Cuando
se envía una solicitud a la Spring Framework MVC la siguiente
secuencia de eventos así.
- El DispatcherServlet recibe por primera vez la solicitud.
- El DispatcherServlet consulta la HandlerMapping e invoca el controlador asociado a la solicitud.
- El proceso del controlador de la solicitud llama a los métodos de servicio apropiadas y devuelve un objeto ModeAndView al DispatcherServlet. El objeto ModeAndView contiene los datos del modelo y el nombre de la vista.
- El DispatcherServlet envía el nombre de la vista a un ViewResolver para encontrar la vista actual a invocar.
- Ahora el DispatcherServlet pasará el modelo de objetos a la vista. La vista con la ayuda de los datos del modelo hará que el resultado de vuelta al usuario.
JSF
Primer
que nada JavaServes Faces no es un Framework sino que una
especificación. De esta manera, pueden existir varias
implementaciones que deben cumplir con las especificaciones.
Especificaciones
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.
JSF
1.2 (11-05-2006) - lanzamiento con mejoras y corrección de errores.
JSF
2.0 (12-08-2009) - lanzamiento con mejoras de funcionalidad y
performance y facilidad de uso.
JSF
2.1 (22-10-2010) - versión actual. Lanzamiento de mantenimiento, con
mínimos cambios.
Implementaciones
- JSF Reference Implementation (Oracle)
- MyFaces (Apache)
- ICEfaces (ICEsoft )
- RichFaces (Jboss)
- ADF Faces (Oracle)
Características
Simplifica
el desarrollo de interfaces de usuario en aplicaciones Java EE. 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 navegación de las páginas y dar soporte para internacionalización y accesibilidad.
- Un conjunto por defecto de componentes para la interfaz de usuario.
- Bibliotecas de etiquetas personalizadas que permiten expresar una interfaz JavaServer Faces dentro de una página JSP.
- Un modelo de eventos en el lado del servidor.
- Administración de estados.
- Beans administrados.
Observaciones:
- Diseñado para ser flexible, la tecnología JavaServer Faces aprovecha los conceptos existentes, estándar de interfaz de usuario web y no limita a los desarrolladores en un determinado lenguaje de marcado, protocolo o dispositivo cliente.
- Las clases de componentes JavaServer Faces e interfaz de usuario (UI) incluidas con la tecnología encapsulan la funcionalidad de los componentes, no la presentación específica del cliente, permitiendo a estos componentes generar prestaciones en diferentes dispositivos cliente.
- Mediante la combinación de la funcionalidad de los componentes de UI con renderizadores personalizados, que definen los atributos de representación de un componente de interfaz de usuario específico, los desarrolladores pueden construir etiquetas personalizadas a un dispositivo de cliente en particular.
- La facilidad de uso es el objetivo principal, la arquitectura JavaServer Faces define claramente una separación entre lógica y presentación al tiempo que facilitan la conexión de la capa de presentación para el código de la aplicación. Este diseño permite a cada miembro de un equipo de desarrollo de aplicaciones web para centrarse en su pieza del proceso de desarrollo, y también proporciona un modelo de programación sencillo para unir las piezas.
JavaServer
Faces incluye las siguientes partes:
- Un conjunto de páginas en las cuales se disponen los componentes.
- Un conjunto de etiquetas para agregar componentes a una página web.
- Un conjunto de beans de apoyo o de respaldo (backing beans), que son JavaBeans que definen las propiedades y funciones para los componentes en la página.
- Un descriptor de despliegue web (web.xml)
- Opcionalmente, uno o mas archivos de configuración de la aplicación, tales como el archivo faces-config.xml, el cual es usado para definir reglas de navegación y configurar beans y otros objetos, como componentes personalizados.
- Opcionalmente, un conjunto de objetos personalizados, los cuales pueden incluir componentes personalizados, validadores, convertidores, creados por el desarrollador de la aplicación.
Beneficios de la tecnología JSF
Una
de las grandes ventajas de la tecnología JavaServer Faces es que
ofrece una separación limpia entre el comportamiento y la
presentación de una aplicación web. Una aplicación JavaServer
Faces puede mapear peticiones http hacia manejadores de eventos y
manejar componentes como objetos de estado en el servidor. La
tecnología JavaServer Faces permite construir aplicaciones web que
implementan la separación entre el comportamiento y la presentación,
que es tradicionalmente resuelta en las arquitecturas UI del lado del
cliente. La separación de la capa de lógica de la presentación
permite además, que cada miembro del equipo de desarrollo se enfoque
en una simple pieza de el proceso de desarrollo y provee de un modelo
simple de programación para ligar las piezas. Por ejemplo,
desarrolladores de paginas con poca experiencia para programar pueden
usar etiquetas de JavaServer Faces en una página web que se vinculen
a objetos del lado del servidor sin la ayuda de scripts.
Facelets
La
tecnología Facelets, disponible como parte de JavaServer Faces 2.0,
es ahora la tecnología de presentación recomendada para construir
aplicaciones web basadas en JavaServer Faces. La tecnología Facelets
ofrece varias ventajas:
- El código puede ser reutilizado y ampliado para los componentes a través de la plantilla y características compuestas de componentes.
- Cuando se usan las anotaciones de JavaServer Faces, es posible registrar el bean de respaldo como un recurso disponible para aplicaciones JavaServer Faces. Además, las reglas de navegación implícita permiten a los desarrolladores configurar rápidamente la navegación de la aplicación. Estas características reducen el proceso de configuración manual para aplicaciones.
- Mas importante, JavaServer Faces provee una arquitectura rica para manejar el estado de los componentes, procesando datos de los componentes, validando entradas de usuarios y manejando eventos.
Managed Beans
Para
el framework las vistas de la aplicación son páginas web (.XHTML)
que es lo que ve el cliente y por detrás de cada una de estas
páginas tenemos una variedad de Beans Administrados (ManagedBeans).
Cada uno de estos managedBeans contiene diferentes propiedades de
acuerdo a la necesidad del desarrollo. Por ejemplo, se puede definir
un managedBean llamado FacturaBean.java, que tendrá todas las
propiedades de una factura.
import
java.io.Serializable;
import
java.util.Date;
import
javax.faces.bean.ManagedBean;
import
javax.faces.bean.RequestScoped;
@ManagedBean(name="facturaBean")
@RequestScoped
public
class FacturaBean implements Serializable{
private String
cliente;
private Date fecha;
private Double
monto;
private Integer
consecutivo;
public String
getCliente() { return cliente; }
public void
setCliente(String cliente) { this.cliente = cliente; }
public Integer
getConsecutivo() { return consecutivo; }
public void
setConsecutivo(Integer consecutivo) { this.consecutivo = consecutivo;
}
public Date
getFecha() { return fecha; }
public void
setFecha(Date fecha) { this.fecha = fecha; }
public Double
getMonto() { return monto; }
public void
setMonto(Double monto) { this.monto = monto; }
}
Lo
anterior es un Bean; las características que lo hacen de este tipo
son las siguientes:
- @ManagedBean : Esta anotación indica que la clase FacturaBean es de tipo MangedBeans; por otro lado, deben de llevar un nombre de acceso, en este caso “facturaBean” el cual no tiene que coincidir con el nombre de la clase estrictamente hablando.
- @RequestScoped : El Scope de un Mangedbeans define cual va a ser el ciclo de vida, si el scope es request, este vivirá unicamente con hacer una petición y regresar los datos a la vista, terminadas estas tareas el bean y todas las propiedades que tenía mueren con la instancia del bean.
Por
otra parte, el Managedbeans debería contener una o mas propiedades,
estas son las que se mostrarán en pantalla, y ademas de estas
propiedades, acciones que serán ejecutadas al presionar un botón,
seleccionar un combobox, porque sino solo estaría mostrando datos
mas no podría interactuar con ellos.
Resumen:
- El servidor de aplicaciones los crea en tiempo de ejecución cuando son necesarios para la aplicación.
- Cualquier Java Bean (constructor sin argumentos + acceso con getXXX() y setXXX()) definido como public puede ser configurado como Managed Beans.
- También se permiten listas (java.util.List) y tablas Hash (java.util.Map).
- Son responsables del Modelo y:
- Almacenan los datos a mostrar en las vistas o los recuperadas de la entrada de usuario.
- Implementan la lógica de la aplicación directamente o delegada (por ejemplo, un EJB) .
- Manejan la nevagación entre las vistas.
- Pueden ser compartidos por varias vistas (dependerá de su alcance).
- Se vinculan a las vistas empleando el EL (expression language).
Hola Mundo
Seleccionar
una “Web Application”.
 |
Indicar
un nombre al proyecto.
Seleccionar
un servidor de aplicaciones.
Seleccionar
el framework
Crear
los package “control” y “modelo”
Crear
dentro del package “modelo” la interface “Datos”.
Crear
dentro del package “modelo” la clase java “DatosImpl”, que
dará implementación al método de la interface “Datos”.
Crear
el archivo muestra.xhtml, el cual muestra el saludo.
Crear
en archivo faces-config.xml que permite configurar, por ejemplo, el
acceso a páginas.
Vamos
configurar el enlace entre las páginas. Desde la hoja “PageFlow”,
apuntar desde Index.xhtml a muestra.xhtml.
Reemplazar
“case1” por “OK”.
Se
tiene:
Crear
dentro del package “control” la clase java “Controlador”.
Indicar
el nombre
Crear
dentro del package “modelo”el ManagedBean “SaludaBean”
Observar
que la referencia para acceder es “saludaBean”.
Código
asociado a la Interface “Datos”.
package
modelo;
public
interface Datos {
public String
enviarMensaje();
}
Código
asociado a la clase “DatosImpl” que implementa la interface
“Datos”.
package
modelo;
public
class DatosImpl implements Datos{
@Override
public String
enviarMensaje() {
return "Hola
Mundo...";
}
}
Código
asociado a la clase “Controlador” que llama al método
enviarMensaje().
package
control;
import
modelo.Datos;
import
modelo.DatosImpl;
public
class Controlador {
Datos o = new
DatosImpl();
public String
muestra(){
return
o.enviarMensaje();
}
}
Código
asociado a la clase “SaludaBean” que llama al método mensaje()
de la clase “Controlador”.
package
modelo;
import
control.Controlador;
import
javax.faces.bean.ManagedBean;
import
javax.faces.bean.RequestScoped;
@ManagedBean
@RequestScoped
public
class SaludaBean {
String mensaje;
public SaludaBean()
{ }
//Sin esta
definición en ManagedBean no funciona
public String
getMensaje() { return mensaje; }
public void
setMensaje(String mensaje) { this.mensaje = mensaje; }
public String
muestra(){
Controlador c =
new Controlador();
mensaje =
c.muestra();
return "OK";
//Envía el control a saluda.xhtml
}
}
Código
asociado a “index.xhtml” implementa un botón que llama al método
saluda() de la clase “SaludaBean”.
xmlns:h="http://java.sun.com/jsf/html"
xmlns:f="http://java.sun.com/jsf/core">
Código
asociado a “saluda.xhtml” implementa un Label que permite
recuperar el valor de la variable “mensaje” de la clase
“SaludaBean”.
xmlns:h="http://java.sun.com/jsf/html">
La
ejecución produce.
Pasos
- Crear las interface y clase implementadora de acceso a datos usando DAO.
- Crear las páginas XHTML.
- Crear el faces-config.xml y relacionas las páginas XHTML.
- Crear la clase Controladora que accede a los servicios proporcionados por las Interfaces.
- Crear los ManagedBean.
- Incluir el código en las páginas XHTML.
No hay comentarios:
Publicar un comentario