Este documento describe JavaServer Faces (JSF), un framework para aplicaciones web en Java. JSF facilita el desarrollo de interfaces gráficas de usuario siguiendo el patrón MVC. Utiliza un modelo basado en componentes y dirigido por eventos similar a Swing. JSF también permite diferentes salidas mediante renderers y soporta tecnologías como JSP. Su ciclo de vida incluye seis fases como restaurar la vista, aplicar valores de solicitud y renderizar la respuesta. Las aplicaciones JSF usan beans Java, archivos JSP y XML para
Este documento describe los Enterprise Java Beans (EJB), que son componentes gestionados por un contenedor de aplicaciones que permiten el acceso a recursos como bases de datos y colas de mensajes de forma sistemática. Existen tres tipos de EJB: Session Beans, que gestionan la lógica de negocio; Message-Driven Beans, que permiten la invocación asíncrona de métodos; y Entity Beans, que representan entidades y su relación con bases de datos. Los EJB simplifican el desarrollo de aplicaciones escalables.
Este documento proporciona una introducción a JavaServer Faces (JSF), incluyendo sus versiones, características principales, diferencias entre JSP y Facelets, la estructura de un proyecto JSF, el patrón modelo-vista-controlador, el ciclo de vida de una página, el uso de managed beans, navegación, etiquetas estándares, conversión y validación de datos, y manejo de eventos. También presenta ejemplos de código JSF.
1) La plataforma Java EE consiste en un conjunto de especificaciones que permiten el desarrollo de aplicaciones empresariales multi-capa en Java. 2) Cualquier fabricante puede implementar estas especificaciones para crear un producto como un servidor de aplicaciones. 3) Las aplicaciones Java EE se componen de módulos que se ejecutan dentro de contenedores en un servidor de aplicaciones, como Glassfish de Oracle.
El documento describe el ciclo de vida de petición-respuesta en Java Server Faces. El ciclo de vida consta de 6 fases: 1) reconstruir el árbol de componentes, 2) aplicar valores de la petición, 3) procesar validaciones, 4) actualizar los valores del modelo, 5) invocar la aplicación, y 6) renderizar la respuesta. Además, existen 3 escenarios posibles dependiendo del tipo de petición y respuesta: petición JSF que genera respuesta JSF, petición no-JSF que genera respuesta JSF, y petición JSF
Este documento describe la arquitectura y componentes de JDBC, el estándar de Java para el acceso a datos. JDBC permite la conexión a cualquier fuente de datos mediante SQL y separa la lógica de aplicación de los datos. La arquitectura sigue un modelo de dos o tres capas. Los componentes clave son los drivers, DriverManager, Connection, Statement y ResultSet.
Este documento describe los Enterprise Java Beans (EJB), que son componentes gestionados por un contenedor de aplicaciones que permiten el acceso a recursos como bases de datos y colas de mensajes de forma sistemática. Existen tres tipos de EJB: Session Beans, que gestionan la lógica de negocio; Message-Driven Beans, que permiten la invocación asíncrona de métodos; y Entity Beans, que representan entidades y su relación con bases de datos. Los EJB simplifican el desarrollo de aplicaciones escalables.
Este documento proporciona una introducción a JavaServer Faces (JSF), incluyendo sus versiones, características principales, diferencias entre JSP y Facelets, la estructura de un proyecto JSF, el patrón modelo-vista-controlador, el ciclo de vida de una página, el uso de managed beans, navegación, etiquetas estándares, conversión y validación de datos, y manejo de eventos. También presenta ejemplos de código JSF.
1) La plataforma Java EE consiste en un conjunto de especificaciones que permiten el desarrollo de aplicaciones empresariales multi-capa en Java. 2) Cualquier fabricante puede implementar estas especificaciones para crear un producto como un servidor de aplicaciones. 3) Las aplicaciones Java EE se componen de módulos que se ejecutan dentro de contenedores en un servidor de aplicaciones, como Glassfish de Oracle.
El documento describe el ciclo de vida de petición-respuesta en Java Server Faces. El ciclo de vida consta de 6 fases: 1) reconstruir el árbol de componentes, 2) aplicar valores de la petición, 3) procesar validaciones, 4) actualizar los valores del modelo, 5) invocar la aplicación, y 6) renderizar la respuesta. Además, existen 3 escenarios posibles dependiendo del tipo de petición y respuesta: petición JSF que genera respuesta JSF, petición no-JSF que genera respuesta JSF, y petición JSF
Este documento describe la arquitectura y componentes de JDBC, el estándar de Java para el acceso a datos. JDBC permite la conexión a cualquier fuente de datos mediante SQL y separa la lógica de aplicación de los datos. La arquitectura sigue un modelo de dos o tres capas. Los componentes clave son los drivers, DriverManager, Connection, Statement y ResultSet.
El documento describe diferentes modelos de componentes en Java, incluyendo JavaBeans, EJBs, servlets y mensajes impulsados por eventos. Explica que un componente es una unidad de software reutilizable con un contrato bien definido. Los EJBs, incluidos los beans de sesión y los beans impulsados por mensajes, son los componentes estándar en Java EE. Los servlets permiten desarrollar aplicaciones web dinámicas almacenando estado conversacional en sesiones HTTP.
Este documento presenta información sobre Java Server Faces (JSF) 2.0. Explica brevemente qué es JSF, sus características principales como framework web estándar de Java EE basado en el patrón MVC. También resume la evolución de JSF desde la versión 1.0 hasta la actual 2.0, los frameworks complementarios como ICEfaces, y algunos de los componentes y características de arquitectura de este framework.
Este documento describe cómo crear una aplicación web básica en JavaServer Faces (JSF) utilizando NetBeans. Explica cómo crear un proyecto JSF, agregar un formulario y un bean administrado, y vincularlos mediante reglas de navegación para procesar los datos del formulario.
JBossAS: Desarrollo con Java Server FacesAitor Acedo
JBossAS: Desarrollo con Java Server Faces es un curso en español para introducir la tecnología JSF en el desarrollo de interfaces en aplicaciones web y realizar despliegues en el servidor JBoss AS 4.0.5
En esta lección aprenderá sobre las técnicas de navegación y el lenguaje de expresiones:
Te recomiendo que visites:
http://gcoronelc.blogspot.pe/
http://www.desarrollasoftware.com/
https://www.youtube.com/channel/UC7c3C0Dtr6HnSpxAAWN643A
La jerarquía de clases Java.sql.* proporciona una biblioteca para realizar consultas a bases de datos SQL. Importar esta biblioteca permite conectarse a bases de datos y ejecutar consultas SQL mediante clases como Connection, Statement y ResultSet. Es importante asegurarse de que el controlador JDBC apropiado esté instalado para la base de datos a la que se desea conectar.
Este documento presenta un taller de Java avanzado que incluye temas como Servlets, JSP, Javabeans, EJB y Struts. Una sección explica los Enterprise Java Beans (EJB), sus beneficios, tipos como los beans de sesión y los beans impulsados por mensajes, y las diferencias con los JavaBeans.
El documento describe la arquitectura Java EE y el servidor web Tomcat. Explica que Java EE incluye especificaciones como JDBC, RMI, JavaMail y servicios web que son coordinados por la plataforma. También describe los tipos de contenedores como el contenedor web, contenedor de aplicaciones y contenedor EJB. Finalmente, resume la estructura básica de archivos de una aplicación web en Tomcat.
Este documento describe los componentes fundamentales de Java EE y su arquitectura. Explica que Java EE simplifica la creación de aplicaciones empresariales mediante el uso de componentes como servlets, JSP, EJB y aplicaciones cliente. Además, describe cómo estos componentes se comunican entre sí a través de protocolos como HTTP y cómo se empaquetan y despliegan las aplicaciones Java EE. Finalmente, proporciona detalles sobre cómo Java EE 5 simplifica el desarrollo mediante el uso de anotaciones.
Este documento describe el componente de migas de RUP. Explica cómo funciona, su infraestructura, invocación y configuración a través de propiedades. También cubre temas como la internacionalización, personalización visual y su integración con el módulo de seguridad de UDA para mostrar el usuario autenticado y permitir la desconexión.
Este documento presenta una introducción al framework JavaServer Faces (JSF). Cubre temas como qué es JSF y sus componentes de interfaz de usuario, conceptos de convertidores, validaciones, eventos y listeners, facetas, productores y kits de renderizado, y el ciclo de vida de los componentes JSF.
Java Server Faces (JSF) es un framework que implementa el patrón MVC y está basado en componentes y eventos del lado del servidor. JSF mantiene del lado del servidor una representación del interfaz de usuario presentado en el cliente. El framework incluye vistas (páginas JSF), modelos (managed beans), y un controlador (Faces Servlet). Los managed beans almacenan datos, implementan la lógica de aplicación y controlan la navegación entre páginas a través de métodos de acción.
Este documento presenta el primer módulo de un curso básico sobre JDBC. Explica los conceptos clave de JDBC como la conexión a bases de datos, el uso de drivers JDBC y los métodos principales para ejecutar consultas y actualizaciones SQL. El contenido incluye 4 módulos con prácticas de laboratorio para aprender a implementar JDBC.
Este documento proporciona un tutorial paso a paso para crear un bean EJB simple con Eclipse e implementarlo en un servidor JBoss. Explica cómo instalar los requisitos como Eclipse y JBoss, crear el bean con interfaces, clase y descriptor de despliegue, y desplegarlo en el servidor para probarlo con una aplicación cliente.
Este documento presenta una agenda para un curso sobre Java Server Faces (JSF) 2.0. Cubre conceptos clave como las características y arquitectura de JSF, la declaración de beans, la navegación, el uso de Facelets, parámetros de vista, validaciones y redirecciones. Explica que JSF 2.0 se basa principalmente en anotaciones, hace la navegación más fácil y admite Facelets, Ajax y validaciones basadas en JSR 303.
Este documento presenta un taller de Java avanzado para empresas y profesionales. El taller cubre temas como Servlets, JSP, EJB, Struts y conclusiones. Cada tema introduce conceptos clave del desarrollo web como contenedores, roles, componentes y la estructura de una aplicación web empaquetada.
5. Curso Java Struts I (Framework para Java) - Curso 2005-2006Samuel Marrero
Resumen de Tutorial o Curso de Java Struts (Framework para Java) impartido durante el curso 2005-2006, sobre los principios de este framework para Java.
Este documento presenta una introducción a los servicios web y Java. Explica los fundamentos de XML y su estructura, así como las diferentes formas de validar documentos XML como DTD y esquemas XML. También resume los contenidos del documento, incluyendo conceptos como el modelo SOA, lenguajes y protocolos de servicios web, y cómo crear y consumir servicios web existentes desde Java.
JSF es un framework para aplicaciones Java que simplifica el desarrollo de interfaces de usuario en aplicaciones JEE. JSF busca que el desarrollo de aplicaciones web sea tan sencillo como aplicaciones autónomas mediante capas de abstracción que independizan el código de protocolos subyacentes como HTTP. JSF también permite utilizar una gran variedad de librerías de componentes gráficos más allá de los estándares HTML.
Spring es un framework ligero para el desarrollo de aplicaciones Java que proporciona soporte para todas las capas de una aplicación. Ofrece inyección de dependencias, programación orientada a aspectos y abstracciones para el acceso a datos y servicios web. Spring simplifica el desarrollo mediante la eliminación de código boilerplate y la integración flexible con otros frameworks y tecnologías.
El documento describe diferentes modelos de componentes en Java, incluyendo JavaBeans, EJBs, servlets y mensajes impulsados por eventos. Explica que un componente es una unidad de software reutilizable con un contrato bien definido. Los EJBs, incluidos los beans de sesión y los beans impulsados por mensajes, son los componentes estándar en Java EE. Los servlets permiten desarrollar aplicaciones web dinámicas almacenando estado conversacional en sesiones HTTP.
Este documento presenta información sobre Java Server Faces (JSF) 2.0. Explica brevemente qué es JSF, sus características principales como framework web estándar de Java EE basado en el patrón MVC. También resume la evolución de JSF desde la versión 1.0 hasta la actual 2.0, los frameworks complementarios como ICEfaces, y algunos de los componentes y características de arquitectura de este framework.
Este documento describe cómo crear una aplicación web básica en JavaServer Faces (JSF) utilizando NetBeans. Explica cómo crear un proyecto JSF, agregar un formulario y un bean administrado, y vincularlos mediante reglas de navegación para procesar los datos del formulario.
JBossAS: Desarrollo con Java Server FacesAitor Acedo
JBossAS: Desarrollo con Java Server Faces es un curso en español para introducir la tecnología JSF en el desarrollo de interfaces en aplicaciones web y realizar despliegues en el servidor JBoss AS 4.0.5
En esta lección aprenderá sobre las técnicas de navegación y el lenguaje de expresiones:
Te recomiendo que visites:
http://gcoronelc.blogspot.pe/
http://www.desarrollasoftware.com/
https://www.youtube.com/channel/UC7c3C0Dtr6HnSpxAAWN643A
La jerarquía de clases Java.sql.* proporciona una biblioteca para realizar consultas a bases de datos SQL. Importar esta biblioteca permite conectarse a bases de datos y ejecutar consultas SQL mediante clases como Connection, Statement y ResultSet. Es importante asegurarse de que el controlador JDBC apropiado esté instalado para la base de datos a la que se desea conectar.
Este documento presenta un taller de Java avanzado que incluye temas como Servlets, JSP, Javabeans, EJB y Struts. Una sección explica los Enterprise Java Beans (EJB), sus beneficios, tipos como los beans de sesión y los beans impulsados por mensajes, y las diferencias con los JavaBeans.
El documento describe la arquitectura Java EE y el servidor web Tomcat. Explica que Java EE incluye especificaciones como JDBC, RMI, JavaMail y servicios web que son coordinados por la plataforma. También describe los tipos de contenedores como el contenedor web, contenedor de aplicaciones y contenedor EJB. Finalmente, resume la estructura básica de archivos de una aplicación web en Tomcat.
Este documento describe los componentes fundamentales de Java EE y su arquitectura. Explica que Java EE simplifica la creación de aplicaciones empresariales mediante el uso de componentes como servlets, JSP, EJB y aplicaciones cliente. Además, describe cómo estos componentes se comunican entre sí a través de protocolos como HTTP y cómo se empaquetan y despliegan las aplicaciones Java EE. Finalmente, proporciona detalles sobre cómo Java EE 5 simplifica el desarrollo mediante el uso de anotaciones.
Este documento describe el componente de migas de RUP. Explica cómo funciona, su infraestructura, invocación y configuración a través de propiedades. También cubre temas como la internacionalización, personalización visual y su integración con el módulo de seguridad de UDA para mostrar el usuario autenticado y permitir la desconexión.
Este documento presenta una introducción al framework JavaServer Faces (JSF). Cubre temas como qué es JSF y sus componentes de interfaz de usuario, conceptos de convertidores, validaciones, eventos y listeners, facetas, productores y kits de renderizado, y el ciclo de vida de los componentes JSF.
Java Server Faces (JSF) es un framework que implementa el patrón MVC y está basado en componentes y eventos del lado del servidor. JSF mantiene del lado del servidor una representación del interfaz de usuario presentado en el cliente. El framework incluye vistas (páginas JSF), modelos (managed beans), y un controlador (Faces Servlet). Los managed beans almacenan datos, implementan la lógica de aplicación y controlan la navegación entre páginas a través de métodos de acción.
Este documento presenta el primer módulo de un curso básico sobre JDBC. Explica los conceptos clave de JDBC como la conexión a bases de datos, el uso de drivers JDBC y los métodos principales para ejecutar consultas y actualizaciones SQL. El contenido incluye 4 módulos con prácticas de laboratorio para aprender a implementar JDBC.
Este documento proporciona un tutorial paso a paso para crear un bean EJB simple con Eclipse e implementarlo en un servidor JBoss. Explica cómo instalar los requisitos como Eclipse y JBoss, crear el bean con interfaces, clase y descriptor de despliegue, y desplegarlo en el servidor para probarlo con una aplicación cliente.
Este documento presenta una agenda para un curso sobre Java Server Faces (JSF) 2.0. Cubre conceptos clave como las características y arquitectura de JSF, la declaración de beans, la navegación, el uso de Facelets, parámetros de vista, validaciones y redirecciones. Explica que JSF 2.0 se basa principalmente en anotaciones, hace la navegación más fácil y admite Facelets, Ajax y validaciones basadas en JSR 303.
Este documento presenta un taller de Java avanzado para empresas y profesionales. El taller cubre temas como Servlets, JSP, EJB, Struts y conclusiones. Cada tema introduce conceptos clave del desarrollo web como contenedores, roles, componentes y la estructura de una aplicación web empaquetada.
5. Curso Java Struts I (Framework para Java) - Curso 2005-2006Samuel Marrero
Resumen de Tutorial o Curso de Java Struts (Framework para Java) impartido durante el curso 2005-2006, sobre los principios de este framework para Java.
Este documento presenta una introducción a los servicios web y Java. Explica los fundamentos de XML y su estructura, así como las diferentes formas de validar documentos XML como DTD y esquemas XML. También resume los contenidos del documento, incluyendo conceptos como el modelo SOA, lenguajes y protocolos de servicios web, y cómo crear y consumir servicios web existentes desde Java.
JSF es un framework para aplicaciones Java que simplifica el desarrollo de interfaces de usuario en aplicaciones JEE. JSF busca que el desarrollo de aplicaciones web sea tan sencillo como aplicaciones autónomas mediante capas de abstracción que independizan el código de protocolos subyacentes como HTTP. JSF también permite utilizar una gran variedad de librerías de componentes gráficos más allá de los estándares HTML.
Spring es un framework ligero para el desarrollo de aplicaciones Java que proporciona soporte para todas las capas de una aplicación. Ofrece inyección de dependencias, programación orientada a aspectos y abstracciones para el acceso a datos y servicios web. Spring simplifica el desarrollo mediante la eliminación de código boilerplate y la integración flexible con otros frameworks y tecnologías.
Este documento presenta una introducción a la plataforma Java, incluyendo frameworks como JavaServer Faces y Spring, así como herramientas de desarrollo como NetBeans y Eclipse. Explica conceptos clave de Java como servlets, beans y contenedores, y describe características y funcionalidades de NetBeans y Eclipse para el desarrollo de aplicaciones web Java.
Este documento describe los pasos para crear, desplegar y probar una aplicación simple con EJB. Incluye escribir el código del bean, el descriptor de despliegue, desplegar el bean en un servidor de aplicaciones, y crear un cliente que invoque al bean.
Los JavaBeans son componentes reutilizables e independientes de la plataforma que permiten trabajar en equipo de forma eficiente al ocultar la implementación y mostrar solo los servicios que ofrecen. Los JavaBeans se pueden usar como controles de interfaz o para representar entidades y reglas de negocio en aplicaciones web. En JSP, las etiquetas <jsp:useBean>, <jsp:setProperty> y <jsp:getProperty> permiten instanciar y configurar JavaBeans y acceder a sus propiedades y métodos.
DISEÑO DE APLICACIONES WEB (INTRODUCCION)René Pilataxi
El documento presenta una agenda para un taller sobre el diseño de aplicaciones web con JavaServer Faces (JSF) 2.0. La agenda incluye los requisitos de software, una introducción a JSF 2.0, el desarrollo de un taller de ejemplo y un resumen. En la introducción a JSF 2.0, se explica que es una tecnología para construir interfaces de usuario en aplicaciones Java EE que separa el comportamiento de la presentación. La sección de desarrollo de ejemplo muestra cómo crear un proyecto web simple en JSF con una clase gestionada
El documento presenta una agenda para un curso de diseño de aplicaciones web con JSF 2.0. Incluye los requisitos de software, una introducción a JSF 2.0 describiendo sus características principales, y un ejemplo de desarrollo de una aplicación que muestra la configuración, codificación y resumen.
Este documento presenta una guía estratégica para migrar de IBM WebSphere a JBoss Enterprise. Detalla los beneficios comunes de cambiar de tecnología como menor complejidad, costes reducidos y mejor rendimiento. Explica los 6 pasos esenciales de planificación para una migración exitosa y cubre temas como la migración de aplicaciones web, Java EE, configuraciones y clusters entre otros.
Netbeans es una plataforma de desarrollo Java de código abierto que ofrece una arquitectura rica para crear aplicaciones. Usa una plataforma RCP que proporciona APIs para extenderla mediante módulos, los cuales son paquetes de código que se pueden instalar dinámicamente. El IDE de Netbeans se construye sobre esta plataforma mediante módulos específicos para proporcionar funcionalidades de desarrollo. Los módulos se registran en el sistema de archivos de Netbeans y se comunican entre sí a
Este documento presenta un resumen básico del framework Struts. Explica que Struts implementa el patrón MVC en Java y cómo funciona en aplicaciones web mediante solicitudes del navegador al controlador. También describe cómo Struts simplifica el desarrollo MVC separando la lógica del negocio, la vista y el controlador. El documento luego resume los componentes clave de Struts como el modelo, la vista y el controlador.
Este documento proporciona una introducción a la plataforma Java 2 Enterprise Edition (J2EE). Explica los componentes y capas de una aplicación J2EE, incluidas las capas de cliente, web, negocio y sistema de información empresarial. También describe los tipos de Enterprise JavaBeans, incluidos los beans de sesión, entidad y manejados por mensajes, así como los servicios de seguridad, transacciones y directorio que provee la plataforma J2EE.
Este documento presenta una introducción a la plataforma Java 2 Enterprise Edition (J2EE), describiendo sus componentes y capas, los tipos de Enterprise JavaBeans, y los servicios provistos por la plataforma J2EE como seguridad, manejo de transacciones, servicio de directorio y ensamblaje de aplicaciones.
El documento describe los pasos para instalar y desplegar una aplicación JSF 2.0 simple. Incluye instalar software como JDK, Netbeans, Glassfish y Microsoft SQL Server. Explica crear un proyecto web con Netbeans y agregar una clase Java con la anotación @ManagedBean para actuar como bean administrado. También cubre agregar archivos XHTML y configurar faces-config.xml y web.xml para desplegar la aplicación en Glassfish con urls que terminan en .jsf.
Este documento describe las características clave de EJB 3.0, incluyendo el uso de anotaciones para definir EJB, la simplificación de la persistencia mediante JPA y la eliminación de interfaces requeridas. También resume los tipos principales de EJB y cómo los clientes pueden acceder a ellos de forma local o remota.
Este documento describe el desarrollo web con Java usando JSP y Servlets. Explica que JSP y Servlets son parte de la plataforma Java EE y permiten crear aplicaciones web dinámicas. También describe diferentes patrones de arquitectura como MVC y cómo usar beans, sesiones, cookies y EL para estructurar aplicaciones web.
Este documento resume los conceptos clave de la plataforma Java 2 Platform, Enterprise Edition (J2EE). Explica los componentes y capas de J2EE, incluidos los clientes, la capa web, la capa de negocio y la capa de sistema de información empresarial. También describe los tipos principales de Enterprise JavaBeans (EJBs), incluidos los beans de sesión, beans de entidad y beans manejados por mensajes. Además, resume los servicios clave que provee el contenedor J2EE, como la seguridad, las transacciones
Este documento describe las principales características de Enterprise JavaBeans (EJB) 3.0. EJB 3.0 simplifica el desarrollo de aplicaciones Java eliminando la necesidad de interfaces home y de componente, permitiendo que los EJBs sean POJOs y utilizando anotaciones en lugar de descriptores XML. También introduce mejoras en el API de persistencia como el uso de EntityManager y mapeo objeto-relacional mediante anotaciones.
Este documento describe JBoss, un servidor de aplicaciones Java de código abierto. JBoss implementa los estándares J2EE y ofrece servicios como EJB, Hibernate y JMS. Usa directorios como bin, deploy y conf para ejecutarse y administrarse. Los desarrolladores pueden implementar EJBs, servicios web y aplicaciones JSF en JBoss.
Este documento presenta las principales características de Spring 3.0. Spring 3.0 incluye mejoras como una nueva implementación del lenguaje de expresiones de Spring, soporte para configuración basada en Java, extensiones para soportar REST y negociación de contenido, y abstracciones para mapeo de objetos a XML. Spring 3.0 también actualiza la API para aprovechar las características de Java 5 como generics.
Java Server Faces es una tecnología estándar para construir interfaces de usuario del lado del servidor en Java. Se han lanzado varias versiones de JSF a lo largo de los años, siendo la versión actual la 2.2. JSF proporciona APIs y tags para crear componentes UI, manejar eventos y estado, y definir reglas de navegación. Las aplicaciones JSF típicas incluyen managed beans, archivos XHTML, y mapeo del servlet Faces en web.xml.
El uso de las TIC en la vida cotidiana.pptxjgvanessa23
En esta presentación, he compartido información sobre las Tecnologías de la Información y la Comunicación (TIC) y su aplicación en diversos ámbitos de la vida cotidiana, como el hogar, la educación y el trabajo.
He explicado qué son las TIC, las diferentes categorías y sus respectivos ejemplos, así como los beneficios y aplicaciones en cada uno de estos ámbitos.
Espero que esta información sea útil para quienes la lean y les ayude a comprender mejor las TIC y su impacto en nuestra vida cotidiana.
Catalogo general tarifas 2024 Vaillant. Amado Salvador Distribuidor Oficial e...AMADO SALVADOR
Descarga el Catálogo General de Tarifas 2024 de Vaillant, líder en tecnología para calefacción, ventilación y energía solar térmica y fotovoltaica. En Amado Salvador, como distribuidor oficial de Vaillant, te ofrecemos una amplia gama de productos de alta calidad y diseño innovador para tus proyectos de climatización y energía.
Descubre nuestra selección de productos Vaillant, incluyendo bombas de calor altamente eficientes, fancoils de última generación, sistemas de ventilación de alto rendimiento y soluciones de energía solar fotovoltaica y térmica para un rendimiento óptimo y sostenible. El catálogo de Vaillant 2024 presenta una variedad de opciones en calderas de condensación que garantizan eficiencia energética y durabilidad.
Con Vaillant, obtienes más que productos de climatización: control avanzado y conectividad para una gestión inteligente del sistema, acumuladores de agua caliente de gran capacidad y sistemas de aire acondicionado para un confort total. Confía en la fiabilidad de Amado Salvador como distribuidor oficial de Vaillant, y en la resistencia de los productos Vaillant, respaldados por años de experiencia e innovación en el sector.
En Amado Salvador, distribuidor oficial de Vaillant en Valencia, no solo proporcionamos productos de calidad, sino también servicios especializados para profesionales, asegurando que tus proyectos cuenten con el mejor soporte técnico y asesoramiento. Descarga nuestro catálogo y descubre por qué Vaillant es la elección preferida para proyectos de climatización y energía en Amado Salvador.
para programadores y desarrolladores de inteligencia artificial y machine learning, como se automatiza una cadena de valor o cadena de valor gracias a la teoría por Manuel Diaz @manuelmakemoney
Infografia TCP/IP (Transmission Control Protocol/Internet Protocol)codesiret
Los protocolos son conjuntos de
normas para formatos de mensaje y
procedimientos que permiten a las
máquinas y los programas de aplicación
intercambiar información.
Todo sobre la tarjeta de video (Bienvenidos a mi blog personal)AbrahamCastillo42
Power point, diseñado por estudiantes de ciclo 1 arquitectura de plataformas, esta con la finalidad de dar a conocer el componente hardware llamado tarjeta de video..
1. Capítulo 3. JavaServer Faces
3.1. Introducción
JavaServer Faces (JSF) es el framework para aplicaciones Web en Java de Sun
Microsystems, liberado apenas en Marzo del 2004, que busca tomar su lugar como estándar
entre los muchos de su clase.
JSF es un framework orientado a la interfaz gráfica de usuario (GUI), facilitando el
desarrollo de éstas, y que sin embargo, realiza una separación entre comportamiento y
presentación, además de proporcionar su propio servlet como controlador, implementando
así los principios del patrón de diseño Model-View-Controller (MVC), lo que da como
resultado un desarrollo más simple y una aplicación mejor estructurada.
El enfoque mencionado anteriormente no es nada nuevo. Lo que hace a JSF tan
atractivo, entre muchas otras cosas más, es que brinda un modelo basado en componentes y
dirigido por eventos para el desarrollo de aplicaciones Web, que es similar al modelo usado
en aplicaciones GUI standalone durante años [Bergsten, 2004], como es el caso de Swing,
el framework estándar para interfaces gráficas de Java.
Otra característica muy importante de JavaServer Faces es que, a pesar de que
HTML es su lenguaje de marcado por default, no está limitado a éste ni a ningún otro, pues
tiene la capacidad de utilizar diferentes renderers para los componentes GUI y obtener así
diferentes salidas para mandar al cliente [Bergsten, 2004]. Así mismo, JSF es
suficientemente flexible para soportar diversas tecnologías de presentación [Bergsten,
2004], destacando entre éstas JSP, ya que es una tecnología soportada, requerida y
especificada para toda implementación de JavaServer Faces.
14
2. 3.1.1. Ciclo de vida
Otro aspecto muy importante dentro de JavaServer Faces es su ciclo de vida, el cual
es similar al de una página JSP: el cliente hace una petición HTTP y el servidor responde
con la página en HTML. Sin embargo, debido a las características que ofrece JSF, el ciclo
de vida incluye algunos pasos más [Ball, 2003].
El proceso de una petición estándar incluye seis fases, como se muestra en la Figura
3.1.1, representadas por los rectángulos blancos:
Figura 3.1.1 Ciclo de Vida de JavaServer Faces
Los rectángulos grises etiquetados con la leyenda “Process Events” representan la
ejecución de cualquier evento producido durante el ciclo de vida.
El funcionamiento de cada etapa se describe brevemente a continuación.
1. Restore View: también llamada Reconstitute Component Tree, es la primera etapa que
se lleva a cabo, e inicia cuando se hace una petición. Su objetivo es la creación de un
árbol con todos los componentes de la página en cuestión.
2. Apply Request Values: cada uno de los componentes del árbol creado en la fase anterior
obtiene el valor que le corresponde de la petición realizada y lo almacena.
15
3. 3. Process Validations: después de almacenar los valores de cada componente, estos son
validados según las reglas que se hayan declarado.
4. Update Model Values: durante esta fase los valores locales de los componentes son
utilizados para actualizar los beans que están ligados a dichos componentes [Geary &
Geary, 2004]. Esta fase se alcanzará únicamente si todas las validaciones de la etapa
anterior fueron exitosas.
5. Invoke Application: se ejecuta la acción u operación correspondiente al evento inicial
que dio comienzo a todo el proceso.
6. Render Response: la respuesta se renderiza y se regresa al cliente.
Dependiendo del éxito o fracaso de las tareas en cada una de las fases del ciclo de
vida, el flujo normal descrito puede cambiar hacia caminos alternos según sea el caso.
3.1.2. Estructura de una aplicación JSF
Se necesitan dos cosas para correr aplicaciones con JavaServer Faces: un
contenedor Web para Java y una implementación de la especificación de JSF [Bergsten,
2004]. Debido a esto, la estructura del directorio de una aplicación JSF podría verse de la
manera como lo muestra la Figura 3.1.2.
Los elementos propios de JavaServer Faces que conforman una aplicación son
típicamente los siguientes:
1. Archivos JSP, que constituyen la interfaz gráfica de la aplicación y que contienen
las diversas funcionalidades de JSF, como los tags que representan los componentes
GUI. Un archivo de este tipo puede verse como lo muestra la Figura 3.1.3.
16
4. 2. Archivos XML, específicamente el archivo faces-comfig.xml que almacena las
diferentes configuraciones y elementos a utilizar en la aplicación. Un ejemplo de
este archivo se muestra en la Figura 3.1.4.
3. Archivos Java, típicamente desempeñando el rol de beans.
4. Archivos de paquetes de mensajes (message bundles).
Figura 3.1.2 Estructura de Directorio de una Aplicación JSF
17
6. Figura 3.1.4 Archivo faces-config.xml
3.2. JavaBeans
De acuerdo a la especificación de JavaBeans, estos se definen como “componentes de
software reusables que pueden ser manipulados en una herramienta de desarrollo”
[JavaBeans, 2006]. De una manera más simple, un JavaBean se puede ver como una clase
Java tradicional o un POJO (Plain Old Java Object) que sigue ciertas especificaciones de
programación.
19
7. Las características más importantes de un bean son las propiedades que ofrece. Una
propiedad es cualquier atributo de un bean que tiene:
▪ un nombre;
▪ un tipo;
▪ métodos para obtener (leer) y/o establecer (escribir) el valor de la propiedad.
Enseguida se muestra un ejemplo de un JavaBean, con dos atributos (nombre,
apellido) y sus correspondientes métodos para obtener sus valores (getNombre,
getApellido) y para establecer nuevos valores (setNombre, getApellido).
package com.jsf;
public class BeanUsuario {
private String nombre;
private String apellido;
// PROPERTY: nombre
public String getNombre() { return nombre; }
public void setNombre(String nuevoValor) { nombre = nuevoValor; }
// PROPERTY: apellido
public String getApellido() { return apellido; }
public void setApellido(String nuevoValor){ apellido = nuevoValor; }
}
En JavaServer Faces se usan beans cuando se necesita conectar clases Java con
páginas Web; en otras palabras, se utilizan para los datos que necesitan ser accedidos desde
una página. Los beans son el medio para conectar la interfaz gráfica con la lógica aplicativa
[Geary, 2004].
En JSF los beans son utilizados en las páginas que representan la interfaz gráfica,
típicamente JSP, específicamente en los componentes. Para poder hacer uso de estos beans,
se deben declarar en el archivo faces-config.xml. A continuación se muestra el ejemplo
para el caso del bean presentado anteriormente.
20
8. <managed-bean>
<managed-bean-name>usuario</managed-bean-name>
<managed-bean-class>com.jsf.BeanUsuario</managed-bean-class>
<managed-bean-scope>session</managed-bean-scope>
</managed-bean>
Lo anterior se puede traducir de la siguiente manera: construye un objeto de la clase
com.jsf.BeanUsuario, llámalo usuario y mantenlo activo mientras dure la sesión.
Una vez declarado el bean, éste puede ser utilizado por los componentes JSF a
través de expresiones de referencia de valor, mejor conocidas como value binding
expressions, y cuya sintaxis es la siguiente:
<h:inputText id=nombre value="#{NombreBean.NombrePropiedad}"/>
Lo que se logra con estas expresiones es que el valor del componente estará
mapeado a la propiedad especificada del bean en cuestión. De esta manera, cuando el
componente sea renderizado, se llamará al método get respectivo; y cuando la respuesta al
usuario sea procesada, se invocará al método set [Geary, 2004], de manera automática
ambas operaciones. Es decir, el valor del componente será almacenado en la variable de la
clase del bean, y así se podrá utilizar para las diversas operaciones que deban realizarse en
la lógica aplicativa, y el valor a desplegar en la página Web será a su vez obtenido de la
misma fuente (la variable de la clase del bean).
21
9. 3.3. Paquetes de Mensajes
Mejor conocidos como message bundles, estos paquetes agrupan todos los mensajes a
desplegar en una página Web, es decir, la parte estática de éstas, con el objetivo de facilitar
la internacionalización.
Los mensajes de la aplicación deberán ser guardados en un archivo con el formato
“properties” mostrado en la Figura 3.3.1.
Figura 3.3.1 Archivo .properties
El archivo deberá guardarse en el mismo directorio de las clases para mayor
comodidad, aunque puede almacenarse en cualquiera, sin embargo, la extensión tendrá que
ser siempre .properties.
Para poder hacer uso de los mensajes, se debe cargar el archivo correspondiente en
la página JSF a través de la sentencia siguiente:
<f:loadBundle basename="com.jsf.messages" var="msgs"/>
22
10. Una vez cargados los mensajes, estos se podrán utilizar a través de value binding
expressions, haciendo referencia a la variable en la que se guardaron:
<h:outputText value="#{msgs.nombre}"/>
De esta manera, todos los mensajes que se quieran desplegar de manera estática,
estarán almacenados en un archivo, reduciendo así las modificaciones a nuestras páginas
JSF.
La página resultante que hace uso de los ejemplos presentados, se muestra en la
Figura 3.3.2.
Figura 3.3.2 Página Resultante
23
11. 3.4. Navegación
La navegación se refiere a la forma en que se desplegarán las diferentes páginas de la
aplicación a través de los eventos producidos por el usuario.
La navegación se determina por medio de reglas declaradas en el archivo faces-
config-xml, que serán evaluadas con la respuesta obtenida del evento generado en la
página actual para determinar la siguiente vista a desplegar. Es decir, cuando el usuario
hace clic en un botón, y éste origina un submit de la forma, la aplicación debe analizar los
datos mandados y determinar qué página desplegar a continuación. Para determinar la vista
a mostrar, la aplicación toma la respuesta generada por el atributo action del componente
que originó el evento, y en base a ésta y a las reglas establecidas, selecciona la página
adecuada.
A continuación se muestra el uso del atributo action en un componente, en este
caso un botón:
<h:commandButton value="#{msgs.enviar}" action="exito" />
En este caso se ejemplifica la navegación estática, ya que el valor de action es
simplemente una cadena de texto que no será afectada por los datos que ingrese el usuario.
Sin embargo esto no es muy útil, ya que lo ideal sería analizar la información
proporcionada por el usuario y en base a esto generar una respuesta adecuada para
determinar la siguiente página a mostrar, lo que se conoce como navegación dinámica. Por
lo tanto, para lograr lo mencionado, en lugar de asignarle una cadena de texto al atributo
action, se hará referencia a un método de un bean a través de un value binding expression,
de tal forma que dicho método analice los datos del usuario y genere una respuesta:
24
12. <h:commandButton value="#{msgs.enviar}" action="#{control.verificar}" />
Todo método utilizado con el atributo action deberá regresar un String y no tener
parámetros. El método verificar utilizado tendría la siguiente estructura:
String verificar () {
if (...)
return "exito";
else
return "fracaso";
}
Como se mencionó anteriormente, las reglas de navegación serán declaradas en el
faces-config.xml, siguiendo el siguiente formato:
<navigation-rule>
<from-view-id>/index.jsp</from-view-id>
<navigation-case>
<from-outcome>login</from-outcome>
<to-view-id>/welcome.jsp</to-view-id>
</navigation-case>
</navigation-rule>
Este ejemplo se puede traducir de la siguiente manera: si estando en la página
/index.jsp se obtiene de un evento la respuesta “logout”, se desplegará entonces la página
llamada /logout.jsp.
Se pueden modificar las reglas y hacer diferentes combinaciones para que se ajusten
a nuestras necesidades; por ejemplo, en el ejemplo anterior si se omite la línea <from-
view-id>/index.jsp</from-view-id>, entonces todas las páginas que generen en su
atributo action una salida “logout” mandarán el flujo a /logout.jsp, ya que no se ha
definido ninguna página inicial.
25
13. Así mismo, se pueden definir varias reglas para una misma vista inicial, de tal
manera que de una misma vista se puedan obtener varias rutas diferentes:
<navigation-rule>
<from-view-id>/index.jsp</from-view-id>
<navigation-case>
<from-outcome>login</from-outcome>
<to-view-id>/welcome.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-outcome>signup</from-outcome>
<to-view-id>/newuser.jsp</to-view-id>
</navigation-case>
</navigation-rule>
Otro elemento importante en la definición de las reglas de navegación es from-
action, el cual se emplea cuando diferentes métodos utilizados en el atributo action
arrojan una misma respuesta y se hace necesario identificar cuál de ellos se ha invocado
para obtener la página adecuada a desplegar, como se ejemplifica a continuación:
<navigation-case>
<from-action>#{quiz.answerAction}</from-action>
<from-outcome>again</from-outcome>
<to-view-id>/again.jsp</to-view-id>
</navigation-case>
<navigation-case>
<from-action>#{quiz.startOverAction}</from-action>
<from-outcome>again</from-outcome>
<to-view-id>/index.jsp</to-view-id>
</navigation-case>
En estos casos los value binding expression (#{quiz.answerAction},
#{quiz.startOverAction}) no son invocados, pues ya se han llamado desde el atributo
action, sino que funcionan a modo de llave para encontrar la regla de navegación
adecuada [Geary, 2004].
26
14. 3.5. Conversión y Validación
Antes de que los datos ingresados por el usuario sean almacenados en los beans
correspondientes del modelo, estos deben pasar por dos procesos necesarios de JSF:
conversión y validación, siempre en este orden.
La conversión es el proceso a través del cual se transforman los datos ingresados
por el usuario en la forma Web en los tipos de datos que mapean en sus correspondientes
variables de su bean. Es decir, los datos que proporciona el usuario, manejados como
cadenas de texto, se transforman en int, Date o según sea el tipo de dato que se ha
definido para cada uno de ellos en el bean especificado.
La validación es el proceso mediante el cual JSF analiza los datos del usuario de
manera semántica, de acuerdo a ciertas reglas especificadas para cada uno de estos, como
pueden ser la longitud mínima y máxima para un campo de la forma.
Ambos procesos tienen como objetivo filtrar los datos del usuario, de tal manera
que los valores que se guardan en los beans sean coherentes y aceptados por el proceso
llevado en la lógica aplicativa.
3.5.1. Conversión estándar
JavaServer Faces proporciona algunos convertidores para los tipos de datos básicos.
Así mismo, JSF realiza la conversión de manera automática para los tipos de datos
Boolean, Byte, Character, Double, Float, Integer, Long, Short, BigDecimal,
BigInteger, y para sus tipos primitivos, donde apliquen.
JSF permite realizar la conversión a números, independientemente del tipo,
pudiendo darles el formato deseado, como cantidad de dígitos en la parte entera o decimal.
27
15. Para lograr esto, lo único que debe hacerse es añadir al componente GUI el convertidor
adecuado con sus diferentes atributos, según se necesite, como lo muestra el siguiente
ejemplo, donde se usa el convertidor f:convertNumber y su atributo minFractionDigits
para determinar el número mínimo de dígitos en la parte decimal:
<h:inputText value="#{bean.cantidad}">
<f:convertNumber minFractionDigits="2"/>
</h:inputText>
El otro convertidor que proporciona JSF, además de los que realiza de manera
automática, se encuentra f:convertDateTime, encargado de convertir y formatear datos de
tipo Date:
<h:inputText value="#{bean.fechadate}">
<f:convertDateTime pattern="MM/yyyy"/>
</h:inputText>
Así mismo se ha utilizado además su atributo pattern para determinar el formato
que debe seguir.
Tanto f:convertNumber como f:convertDateTime disponen de varios atributos
con diferentes propósitos para darle formato a los datos deseados; para conocer más acerca
de ellos es recomendable consultar la librería de tags de JSF, disponible en la página
http://java.sun.com/j2ee/javaserverfaces/1.1/docs/tlddocs/.
Para dar a conocer los errores que se han generado en el proceso de conversión, se
debe añadir al componente GUI en cuestión el tag apropiado con el nombre del
componente a manera de llave:
28
16. <h:inputText id=cantidad value="#{bean.cantidad }"/>
<h:message for="cantidad "/>
La página con el mensaje desplegado se presenta en la Figura 3.5.1.
Figura 3.5.1 Mensaje Desplegado Cuando la Conversión Falla
3.5.2. Validación estándar
JavaServer Faces proporciona validación para longitud de cadenas de texto y para
rangos de números.
Para el caso de validación de longitud, JSF utiliza el elemento f:validateLength:
<h:inputText value="#{bean.direccion}">
<f:validateLength minimum="13"/>
</h:inputText>
Para rangos de números hace uso de f:validateLongRange:
<h:inputText value="#{bean.cantidad }">
<f:validateLongRange minimum="10" maximum="10000"/>
29
17. </h:inputText>
Así mismo, JSF permite realizar validación para campos que son necesarios o
requeridos, añadiendo únicamente el atributo required al componente GUI deseado:
<h:inputText id=nombre value="#{bean.nombre}" required="true"/>
En algunos casos podría desearse que el proceso de validación fuera omitido; por
ejemplo, si se agrega un botón “Cancelar” a una página que contiene campos requeridos, al
hacer clic en éste, la página mandará un error, pues no se han llenado los campos necesarios
[Geary, 2004]. Para solucionar esto, JSF utiliza el atributo immediate en el componente
GUI deseado con el objetivo de dejar a un lado la validación y pasar a la página requerida
por el componente.
<h:commandButton value="Cancel" action="cancel" immediate="true"/>
Para desplegar los errores de validación se procede exactamente de la misma forma
que en la conversión. El ejemplo se muestra en la Figura 3.5.2.
30
18. Figura 3.5.2 Mensaje de Error que se Despliega Cuando la Validación Falla
3.5.3. Conversión personalizada
La conversión personalizada se refiere a la creación de clases para que realicen
dicho proceso, lo cual puede ser necesario cuando la aplicación desarrollada haga uso de
tipos de datos complejos, como clases mismas.
Las clases destinadas a realizar conversiones deberán implementar la interfaz
Converter, que tiene dos métodos:
▪ Object getAsObject(FacesContext context, UIComponent component,
String newValue)
▪ String getAsString(FacesContext context, UIComponent component,
Object value)
El primer método convierte una cadena de texto en un objeto del tipo deseado,
arrojando una excepción del tipo ConverterException si el proceso falla:
if (foundInvalidCharacter) {
FacesMessage message = com.jsf.util.Messages.getMessage(
"com.jsf.messages", "badCharacter",
new Object[]{ new Character(invalidCharacter) });
31
19. message.setSeverity(FacesMessage.SEVERITY_ERROR);
throw new ConverterException(message);
}
El segundo método convierte el objeto en una cadena de texto para que pueda
desplegarse al usuario [Geary, 2004].
Una vez creada la clase, se debe registrar en el archivo faces-config.xml:
<converter>
<converter-id>com.jsf.Rfc</converter-id>
<converter-class>com.jsf.RfcConverter</converter-class>
</converter>
Y para utilizarla:
<h:inputText value="#{bean.rfc}">
<f:converter converterId=”com.jsf.Rfc”/>
</h:inputText>
3.5.4. Validación personalizada
Al igual que en la conversión personalizada, en la validación personalizada las
clases deberán extender de una interfaz, sólo que ahora ésta será
javax.faces.validator.Validator, la cual define un único método: void
validate(FacesContext context, UIComponent component). Así mismo, si el
proceso falla, se arrojará una excepción, ahora del tipo ValidatorException:
if (validation fails) {
FacesMessage message = ...;
message.setSeverity(FacesMessage.SEVERITY_ERROR);
throw new ValidatorException(message);
}
Al igual que en la conversión personalizada, las nuevas clases deberán ser
declaradas en el faces-comfig.xml:
<validator>
32
20. <validator-id>com.jsf.Rfc/validator-id>
<validator-class>com.jsf.RfcValidator</validator-class>
</validator>
Y para hacer uso de ellas se hará de la misma forma:
<h:inputText value="#{bean.rfccard}" required="true">
<f:converter converterId=”com.jsf.Rfc”/>
<f:validator validatorId=”com.jsf.Rfc”/>
</h:inputText>
3.6. Manejo de Eventos
Los eventos juegan un papel muy importante dentro de JavaServer Faces, como se ha
mencionado. Los componentes GUI de JSF responden a las acciones del usuario disparando
eventos, que serán manejados por código de la aplicación, llamados listeners, que han sido
registrados para ser notificados de la ocurrencia del evento [Bergsten, 2004].
Java Server Faces soporta dos tipos de eventos para los componentes GUI:
▪ eventos Value Change y
▪ eventos Action.
La idea central del manejo de eventos es registrar los listeners adecuados para cada
componente GUI, de tal manera que se realicen las operaciones apropiadas y deseadas.
3.6.1. Eventos Value Change
Estos eventos son generados por componentes de entrada, tales como h:inputText,
h:selectManyMenu y h:selectOneRadio, cuando su valor cambia y la forma en que están
contenidos es mandada (submit).
Para agregar un listener del tipo Value Change, además de asociarlo con el
correspondiente componente GUI y a través de un value binding expression indicar el
33
21. método que se invocará al dispararse el evento, debe añadirse el atributo onchange para
forzar que se haga el submit de la forma [Geary, 2004], ya que el cambio de valor no realiza
esta acción:
<h:selectOneMenu value="#{bean.pais }" onchange="submit()"
valueChangeListener="#{bean.cambioPais}">
<f:selectItems value="#{bean.nombresPaises }"/>
</h:selectOneMenu>
De esta forma, cuando el usuario cambia el valor del componente GUI, se hace un
submit de la forma y posterioemente se llama al método countryChanged del bean form;
este método debe tener como parámetro una variable ValueChangeEvent, con la cual podrá
obtener el nuevo valor del componente GUI:
private static final String US = "United States";
...
public void cambioPais (ValueChangeEvent event) {
FacesContext context = FacesContext.getCurrentInstance();
if(US.equals((String)event.getNewValue()))
context.getViewRoot().setLocale(Locale.US);
else
context.getViewRoot().setLocale(Locale.CANADA);
}
En el ejemplo anterior el listener se ha agregado como un atributo del
componente, y el método que invoca pertenece a un bean. Existe otra alternativa que ofrece
JSF y consiste en añadir el listener como un tag, en lugar de un atributo:
<h:selectOneMenu value="#{bean.pais}" onchange="submit()">
<f:valueChangeListener type="com.jsf.PaisListener"/>
<f:selectItems value="#{form. nombresPaises }"/>
</h:selectOneMenu>
Y como se puede observar, en este caso se hace referencia a una clase Java, en
lugar de un método de un bean, la cual debe implementar la interfaz
34
22. ValueChangeListener y definir únicamente el método void
processValueChange(ValueChangeEvent):
public class PaisListener implements ValueChangeListener {
private static final String US = "United States";
public void processValueChange(ValueChangeEvent event) {
FacesContext context = FacesContext.getCurrentInstance();
if (US.equals((String) event.getNewValue()))
context.getViewRoot().setLocale(Locale.US);
else
context.getViewRoot().setLocale(Locale.CANADA);
}
}
3.6.2. Eventos Action
Estos eventos son disparados por componentes tipo command, tales como
h:commandButton y h:commandLink, cuando el botón o el link son activados [Geary,
2004].
A diferencia de los eventos Value Change, los eventos Action realizan el submit de
manera automáticamente, por lo cual sólo debe agregarse el atributo actionListener, y la
referencia al método a invocar, al componente GUI deseado, sin necesidad del atributo
onchange:
<h:commandLink actionListener="#{bean.linkUsado}">
</h:commandLink>
Así mismo, el método linkUsado debe ahora tener como parámetro una variable
de tipo ActionEvent.
Para agregar el listener a manera de tag, se procede de la misma forma que para
los eventos Value Change, con sus cambios respectivos:
35
23. <h:commandButton image="mountrushmore.jpg" action="#{rushmore.act}">
<f:actionListener type="com.jsf.ImagenListener"/>
</h:commandButton>
La clase a la que hace referencia, RushmoreListener, ahora implementa la
interfaz ActionListener y el método void processAction(ActionEvent e):
public class ImagenListener implements ActionListener {
public void processAction(ActionEvent e) {
FacesContext context = FacesContext.getCurrentInstance();
Map requestParams =
context.getExternalContext().getRequestParameterMap();
String locale = (String) requestParams.get("locale");
if ("english".equals(locale))
context.getViewRoot().setLocale(Locale.UK);
else if("german".equals(locale))
context.getViewRoot().setLocale(Locale.GERMANY);
}
}
36