El documento describe el patrón de diseño MVC y la framework Apache Struts. Explica el flujo de control en Struts, incluyendo el procesamiento de peticiones, control de errores y manejo de formularios. También cubre conceptos como acciones, form beans, validación y la configuración requerida para desarrollar aplicaciones web con Struts.
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 describe el framework Struts para desarrollar aplicaciones web siguiendo el patrón MVC. Struts separa una aplicación en tres componentes: modelo, vista y controlador. El controlador recibe las peticiones y las dirige al modelo o la vista correspondiente. Struts simplifica la implementación de MVC al proveer clases y tags predefinidos.
Este documento introduce el modelo MVC y la arquitectura Struts. Explica que Struts es un framework que sigue el patrón MVC para construir aplicaciones web Java, separando la lógica, la vista y el controlador. También describe los principales componentes de Struts como las acciones, los formularios, la configuración y cómo enlazan la lógica, la vista y el modelo de datos.
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 introduce el framework Zend. Explica por qué usar un framework, las ventajas de Zend sobre otros frameworks como Symphony y CakePHP. Detalla conceptos básicos de Zend como MVC, excepciones, patrones de diseño singleton e interfaces fluidas. Finalmente, cubre la instalación de Zend, su estructura de directorios y el archivo bootstrap.php.
ASP .NET MVC: Desarrollo web con el patrón MVCriojadotnet
prende a desarrollar aplicaciones web utilizando un framework gratuito.
Descubre todo lo que ofrece ASP .NET.
Conoce el patrón MVC (modelo-vista-controlador).
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 describe el framework Struts para desarrollar aplicaciones web siguiendo el patrón MVC. Struts separa una aplicación en tres componentes: modelo, vista y controlador. El controlador recibe las peticiones y las dirige al modelo o la vista correspondiente. Struts simplifica la implementación de MVC al proveer clases y tags predefinidos.
Este documento introduce el modelo MVC y la arquitectura Struts. Explica que Struts es un framework que sigue el patrón MVC para construir aplicaciones web Java, separando la lógica, la vista y el controlador. También describe los principales componentes de Struts como las acciones, los formularios, la configuración y cómo enlazan la lógica, la vista y el modelo de datos.
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 introduce el framework Zend. Explica por qué usar un framework, las ventajas de Zend sobre otros frameworks como Symphony y CakePHP. Detalla conceptos básicos de Zend como MVC, excepciones, patrones de diseño singleton e interfaces fluidas. Finalmente, cubre la instalación de Zend, su estructura de directorios y el archivo bootstrap.php.
ASP .NET MVC: Desarrollo web con el patrón MVCriojadotnet
prende a desarrollar aplicaciones web utilizando un framework gratuito.
Descubre todo lo que ofrece ASP .NET.
Conoce el patrón MVC (modelo-vista-controlador).
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
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.
Este documento describe la utilidad de JDBC para conectarse a bases de datos desde Java usando SQL. JDBC permite que una aplicación Java se conecte a diferentes bases de datos y las trate de forma uniforme. JDBC consta de dos capas: la capa de aplicación que contiene las clases para interactuar con la base de datos, y la capa de controlador que se encarga de establecer la comunicación con el RDBMS.
La tecnología JavaServer Faces proporciona una arquitectura de componentes rica y flexible. Incluye un conjunto de clases de componentes UI como UICommand, UIForm y UIInput que descienden de UIComponentBase. Estas clases se pueden incluir en páginas usando etiquetas como <h:form>, <h:commandButton> y <h:inputText>.
El documento describe las características de JavaServer Faces (JSF), un framework para el desarrollo de aplicaciones web con interfaz gráfica. JSF permite separar la lógica de negocio de la presentación mediante el uso de componentes, y define un ciclo de vida estandarizado para las peticiones. El documento explica cómo configurar y utilizar JSF en un proyecto.
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.
Arquitectura en aplicaciones Angular y buenas practicas.Germán Küber
Este documento resume buenas prácticas de arquitectura en aplicaciones Angular. Recomienda mantener una estructura plana y simple, organizar funcionalidades en módulos y componentes, usar servicios para compartir lógica e implementar interfaces. También sugiere nomenclaturas claras, comunicación entre componentes mediante observables, y centralizar la lógica compleja en servicios para mantener componentes simples.
Una de las dificultades de programar con JSP son los scriptlets, ya que debes combinar codigo Java y etiquetas HTML.
El uso de etiquetas JSTL es mucho mas fácil que programar scriptlets, es por esa razón que debes considerar utilizarlas, ya que tendrás un codigo mucho mas estructurado y fácil de leer.
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 describe la tecnología Java Server Faces (JSF). JSF es un framework para el desarrollo de interfaces de usuario del lado del servidor para aplicaciones web basadas en Java. El documento explica que JSF se basa en tecnologías como servlets, JavaBeans, JSP y XHTML. También cubre los conceptos clave de JSF como componentes de interfaz de usuario, eventos, beans administrados, validadores y navegación.
Este documento describe varios frameworks J2EE populares como JSF, Struts, Spring y JBoss Seam. Explica los conceptos básicos de cada uno y su arquitectura, ventajas y desventajas. Los frameworks J2EE ayudan a estructurar aplicaciones web siguiendo el patrón MVC y proveen bibliotecas reutilizables para simplificar el desarrollo.
Este documento introduce ASP.NET MVC, comparando Web Forms y MVC. Explica cómo crear proyectos MVC en Visual Studio y describe conceptos como controladores, vistas, modelos, enrutamiento, validación y filtros de acción. También cubre Entity Framework Code First y Razor para generar vistas dinámicas.
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.
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 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.
Conceptos básicos de Ruby on Rails incluyendo:
- Controladores y acciones
- Rutas
- Configuraciones de applicacion
- Generación de modelos y Active Record
- Plantillas y vistas
- REST y recursos
Además de dos ejemplos prácticos:
- Página con mensaje 'Hola Mundo'
- MiniAplicación de blogs
Struts es un framework para aplicaciones web Java que implementa el modelo MVC. Proporciona un servlet controlador que administra las solicitudes y deriva las respuestas a clases de acción y vistas JSP. Ofrece características como validación de formularios, manejo de errores e internacionalización. El controlador analiza las solicitudes y llama a las clases de acción apropiadas, que interactúan con los objetos de negocio y derivan la generación de la interfaz a JSP.
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
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.
Este documento describe la utilidad de JDBC para conectarse a bases de datos desde Java usando SQL. JDBC permite que una aplicación Java se conecte a diferentes bases de datos y las trate de forma uniforme. JDBC consta de dos capas: la capa de aplicación que contiene las clases para interactuar con la base de datos, y la capa de controlador que se encarga de establecer la comunicación con el RDBMS.
La tecnología JavaServer Faces proporciona una arquitectura de componentes rica y flexible. Incluye un conjunto de clases de componentes UI como UICommand, UIForm y UIInput que descienden de UIComponentBase. Estas clases se pueden incluir en páginas usando etiquetas como <h:form>, <h:commandButton> y <h:inputText>.
El documento describe las características de JavaServer Faces (JSF), un framework para el desarrollo de aplicaciones web con interfaz gráfica. JSF permite separar la lógica de negocio de la presentación mediante el uso de componentes, y define un ciclo de vida estandarizado para las peticiones. El documento explica cómo configurar y utilizar JSF en un proyecto.
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.
Arquitectura en aplicaciones Angular y buenas practicas.Germán Küber
Este documento resume buenas prácticas de arquitectura en aplicaciones Angular. Recomienda mantener una estructura plana y simple, organizar funcionalidades en módulos y componentes, usar servicios para compartir lógica e implementar interfaces. También sugiere nomenclaturas claras, comunicación entre componentes mediante observables, y centralizar la lógica compleja en servicios para mantener componentes simples.
Una de las dificultades de programar con JSP son los scriptlets, ya que debes combinar codigo Java y etiquetas HTML.
El uso de etiquetas JSTL es mucho mas fácil que programar scriptlets, es por esa razón que debes considerar utilizarlas, ya que tendrás un codigo mucho mas estructurado y fácil de leer.
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 describe la tecnología Java Server Faces (JSF). JSF es un framework para el desarrollo de interfaces de usuario del lado del servidor para aplicaciones web basadas en Java. El documento explica que JSF se basa en tecnologías como servlets, JavaBeans, JSP y XHTML. También cubre los conceptos clave de JSF como componentes de interfaz de usuario, eventos, beans administrados, validadores y navegación.
Este documento describe varios frameworks J2EE populares como JSF, Struts, Spring y JBoss Seam. Explica los conceptos básicos de cada uno y su arquitectura, ventajas y desventajas. Los frameworks J2EE ayudan a estructurar aplicaciones web siguiendo el patrón MVC y proveen bibliotecas reutilizables para simplificar el desarrollo.
Este documento introduce ASP.NET MVC, comparando Web Forms y MVC. Explica cómo crear proyectos MVC en Visual Studio y describe conceptos como controladores, vistas, modelos, enrutamiento, validación y filtros de acción. También cubre Entity Framework Code First y Razor para generar vistas dinámicas.
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.
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 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.
Conceptos básicos de Ruby on Rails incluyendo:
- Controladores y acciones
- Rutas
- Configuraciones de applicacion
- Generación de modelos y Active Record
- Plantillas y vistas
- REST y recursos
Además de dos ejemplos prácticos:
- Página con mensaje 'Hola Mundo'
- MiniAplicación de blogs
Struts es un framework para aplicaciones web Java que implementa el modelo MVC. Proporciona un servlet controlador que administra las solicitudes y deriva las respuestas a clases de acción y vistas JSP. Ofrece características como validación de formularios, manejo de errores e internacionalización. El controlador analiza las solicitudes y llama a las clases de acción apropiadas, que interactúan con los objetos de negocio y derivan la generación de la interfaz a JSP.
5.- PPT 2022 05 U01 T01 Desarrollo de Servicios Web I (1915).pptxSibilinoAndante
El documento presenta una introducción al desarrollo web con ASP.NET Core MVC. Explica los conceptos clave de ASP.NET Core, ASP.NET Core MVC, la estructura de un proyecto MVC, y los componentes clave como controladores, vistas y modelos. También cubre temas como Razor, scaffolding, transferencia de datos y implementación de acciones.
Este documento presenta un taller de Java avanzado que incluye un tema sobre el framework Struts. El tema explica los conceptos básicos de MVC, las ventajas de Struts, cómo funciona, y cómo configurar e implementar Struts en una aplicación, incluyendo la creación de ActionForms, Actions y el uso de tags.
Java struts2 - 03 componentes de la aplicacionJechu2013
Este documento describe los principales componentes de Struts 2, incluyendo el FilterDispatcher, proceso de peticiones a través de interceptores y acciones, resultados, OGNL, value stack, validaciones y scopes. Explica conceptos como interceptores, acciones, resultados y cómo Struts 2 maneja peticiones y procesa las respuestas.
Introducción al servidor Tomcat.Resumen de conceptos básicos, instalación y configuración. Se repasan conceptos sobre JSPs, JavaBeans, Servicios web sobre Axis2, JNLP, etc.
El documento describe el modelo de diseño MVC y su aplicación en ASP.NET. MVC separa la lógica de la interfaz de usuario, la lógica comercial y la lógica de entrada, permitiendo el desarrollo paralelo y pruebas unitarias más fáciles. ASP.NET MVC proporciona enrutamiento, compatibilidad con pruebas y características como autenticación, además de permitir personalización y reemplazo de componentes.
Este documento describe la arquitectura Java Web utilizando el patrón MVC. Explica que el controlador administra la navegación, el modelo almacena los datos y la vista presenta los datos. Luego introduce los principales frameworks para implementar MVC como Struts, describiendo cómo funciona y cómo se configura para crear formularios, acciones y validaciones. Finalmente, explica las librerías de etiquetas de Struts para generar la interfaz de usuario.
Diapositivas Curso Java J2EE, módulo:
MODULO VI: APLICACIONES WEB CON JAKARTA STRUTS
- Introducción y arquitectura
• FrameWork
• Patrón MVC
• Instalación - Primer programa
• Control de flujo
• Diagrama Clases
• Atención de la petición
- Integración con la capa de datos
• Persistencia,
• JDBC
• Patrón DAO
• Hibernate
- Manejo de Formularios
• Form Beans
• Validación en formulario
- Validación de Formularios
• Framework Validator
• Validación JavaScript
- Tratamiento de Excepciones
• Excepciones Globales
- Internacionalización
- Composición de vistas
• Plantillas
• Tiles
- Biblioteca de etiquetas
• HTML
• BEAN
• LOGIC
El documento habla sobre ASP.NET MVC, un framework para desarrollo web que ofrece separación de preocupaciones, URLs limpias y un modelo de programación más performante. Explica conceptos como modelos, vistas y controladores, y características como Razor, rutas, y jQuery. También cubre SignalR, una biblioteca que permite comunicaciones en tiempo real entre el servidor y el cliente.
Ajax, acrónimo de Asynchronous JavaScript And XML (JavaScript asíncrono y XML), es una técnica de desarrollo web para crear aplicaciones.
Ajax es una tecnología asíncrona, en el sentido de que los datos adicionales se solicitan al servidor y se cargan en segundo plano sin interferir con la visualización ni el comportamiento de la página.
Ajax es una técnica válida para múltiples plataformas y utilizable en muchos sistemas operativos y navegadores dado que está basado en estándares abiertos como JavaScript y Document Object Model
1
(DOM).
Estas aplicaciones se ejecutan en el navegador (cliente) de los usuarios.
Guia de estudio para Oracle Certified Java EE 6 Web Component DeveloperOscar V
Este documento presenta una guía de estudio para el examen Oracle Certified Expert, Java EE 6 Web Component Developer (1Z0-899). Explica que el examen dura 140 minutos y contiene 57 preguntas. Cubre temas como introducción a servlets y JSP, arquitectura MVC, entorno de servlets, seguridad web y más. El documento también incluye una lista detallada de los objetivos de aprendizaje de cada sección para ayudar a los candidatos a prepararse para el examen.
Este documento presenta una agenda para un taller sobre ASP.NET MVC. La agenda incluye secciones sobre jQuery, AJAX, bundling y minificación, uso de CDN para scripts, Web API, soporte asincrónico y SignalR. Cada sección cubre conceptos clave y provee demostraciones para ilustrar los temas.
Este documento presenta una introducción a Spring MVC, incluyendo una descripción del patrón MVC, los componentes clave de Spring MVC como DispatcherServlet y HandlerMapping, y cómo configurar una aplicación Spring MVC. También explica conceptos como controllers, views y binding de datos, e incluye ejemplos de código de controllers simples y MultiActionController.
Este documento compara las versiones 1 y 2 del framework Struts, el cual implementa el patrón MVC para ordenar y facilitar el desarrollo y mantenimiento de aplicaciones web en Java. Struts 1 requiere configurar Actions y ActionForms, mientras que Struts 2 mejora esto al eliminar la necesidad de ActionForms y permitir extender directamente de Action. Ambas versiones siguen el flujo de petición del patrón MVC pero Struts 2 ofrece una arquitectura más simplificada.
Esta fue una pequeña charla que dicté en el Labortatorio de Investigación de Software en la Universidad Tecnológica Nacional - Facultad Regional Córdoba
Introducción al desarrollo de aplicaciones web en JavaEudris Cabrera
Este documento presenta una introducción al desarrollo de aplicaciones web con Java. Explica conceptos clave como servlets, Java Server Pages (JSP), contenedores web y tecnologías estándar para aplicaciones web en Java. El objetivo es proveer una visión general de las tecnologías Java disponibles para el desarrollo de aplicaciones web, destacando normas importantes como servlets, JSP y contenedores web.
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.
El documento habla sobre los frameworks de capa de presentación. Explica que un framework es un conjunto de clases que facilitan y agilizan el desarrollo de aplicaciones web. Describe algunos frameworks como Struts y Spring MVC, indicando sus características principales como el modelo de programación, sistema de navegación, validación, configuración e internacionalización.
Este documento presenta conceptos básicos sobre desarrollo web y arquitecturas MVC. Explica brevemente el patrón MVC, frameworks como Struts y Spring MVC, y cómo implementar una arquitectura MVC utilizando JSP y Servlets, con el Servlet actuando como controlador y el JSP generando la vista. También introduce conceptos de Maven como repositorios, arquetipos y perfiles.
El curso de Texto Integrado de 8vo grado es un programa académico interdisciplinario que combina los contenidos y habilidades de varias asignaturas clave. A través de este enfoque integrado, los estudiantes tendrán la oportunidad de desarrollar una comprensión más holística y conexa de los temas abordados.
En el área de Estudios Sociales, los estudiantes profundizarán en el estudio de la historia, geografía, organización política y social, y economía de América Latina. Analizarán los procesos de descubrimiento, colonización e independencia, las características regionales, los sistemas de gobierno, los movimientos sociales y los modelos de desarrollo económico.
En Lengua y Literatura, se enfatizará el desarrollo de habilidades comunicativas, tanto en la expresión oral como escrita. Los estudiantes trabajarán en la comprensión y producción de diversos tipos de textos, incluyendo narrativos, expositivos y argumentativos. Además, se estudiarán obras literarias representativas de la región latinoamericana.
El componente de Ciencias Naturales abordará temas relacionados con la biología, la física y la química, con un enfoque en la comprensión de los fenómenos naturales y los desafíos ambientales de América Latina. Se explorarán conceptos como la biodiversidad, los recursos naturales, la contaminación y el desarrollo sostenible.
En el área de Matemática, los estudiantes desarrollarán habilidades en áreas como la aritmética, el álgebra, la geometría y la estadística. Estos conocimientos matemáticos se aplicarán a la resolución de problemas y al análisis de datos, en el contexto de las temáticas abordadas en las otras asignaturas.
A lo largo del curso, se fomentará la integración de los contenidos, de manera que los estudiantes puedan establecer conexiones significativas entre los diferentes campos del conocimiento. Además, se promoverá el desarrollo de habilidades transversales, como el pensamiento crítico, la resolución de problemas, la investigación y la colaboración.
Mediante este enfoque de Texto Integrado, los estudiantes de 8vo grado tendrán una experiencia de aprendizaje enriquecedora y relevante, que les permitirá adquirir una visión más amplia y comprensiva de los temas estudiados.
Examen de Selectividad. Geografía junio 2024 (Convocatoria Ordinaria). UCLMJuan Martín Martín
Examen de Selectividad de la EvAU de Geografía de junio de 2023 en Castilla La Mancha. UCLM . (Convocatoria ordinaria)
Más información en el Blog de Geografía de Juan Martín Martín
http://blogdegeografiadejuan.blogspot.com/
Este documento presenta un examen de geografía para el Acceso a la universidad (EVAU). Consta de cuatro secciones. La primera sección ofrece tres ejercicios prácticos sobre paisajes, mapas o hábitats. La segunda sección contiene preguntas teóricas sobre unidades de relieve, transporte o demografía. La tercera sección pide definir conceptos geográficos. La cuarta sección implica identificar elementos geográficos en un mapa. El examen evalúa conocimientos fundamentales de geografía.
ACERTIJO DESCIFRANDO CÓDIGO DEL CANDADO DE LA TORRE EIFFEL EN PARÍS. Por JAVI...JAVIER SOLIS NOYOLA
El Mtro. JAVIER SOLIS NOYOLA crea y desarrolla el “DESCIFRANDO CÓDIGO DEL CANDADO DE LA TORRE EIFFEL EN PARIS”. Esta actividad de aprendizaje propone el reto de descubrir el la secuencia números para abrir un candado, el cual destaca la percepción geométrica y conceptual. La intención de esta actividad de aprendizaje lúdico es, promover los pensamientos lógico (convergente) y creativo (divergente o lateral), mediante modelos mentales de: atención, memoria, imaginación, percepción (Geométrica y conceptual), perspicacia, inferencia y viso-espacialidad. Didácticamente, ésta actividad de aprendizaje es transversal, y que integra áreas del conocimiento: matemático, Lenguaje, artístico y las neurociencias. Acertijo dedicado a los Juegos Olímpicos de París 2024.
Soluciones Examen de Selectividad. Geografía junio 2024 (Convocatoria Ordinar...Juan Martín Martín
Criterios de corrección y soluciones al examen de Geografía de Selectividad (EvAU) Junio de 2024 en Castilla La Mancha.
Soluciones al examen.
Convocatoria Ordinaria.
Examen resuelto de Geografía
conocer el examen de geografía de julio 2024 en:
https://blogdegeografiadejuan.blogspot.com/2024/06/soluciones-examen-de-selectividad.html
http://blogdegeografiadejuan.blogspot.com/
pueblos originarios de chile presentacion twinkl.pptx
Strust
1. Strust
• Patrón de diseño MVC
• La framework Apache Struts
• Instalación
• Flujo de control en Struts
• Procesamiento de peticiones
• Control de errores
• Manejo de Formularios
• Librerías de etiquetas de Struts
• Internacionalización
• Ejemplo de aplicación Struts
• Java Server Faces
• http://javarevolutions.com/site/source/source.jr
• http://www.youtube.com/watch?v=1Vi4UqjjexI video
2. Modelos de desarrollo de aplicaciones web
en Java
• Los servlets son buenos ejecutando lógica de negocio, pero no son tan buenos
presentando información
• JSPs son muy buenos presentando pero pésimos introduciendo lógica
programática en ellos
• La combinación Servlet/JSPs es lo más común hoy en día en el desarrollo de
aplicaciones web
• Dos arquitecturas:
• Model-1: JSPs para presentación y control y JavaBeans para la lógica
• Model-2: Model-View-Controller = JavaBeans-JSPs-Servlets
• MVC es tan común que se han desarrollado varias infraestructuras en torno a este
patrón de diseño:
• Apache Struts
• Java Server Faces
6. Modelo MVC I
• El Controlador (Controller)
• Servlet central recibe peticiones, procesa URL recibida y
delega procesamiento a JavaBeans
• Servlet guarda resultado de procesamiento realizado
por JavaBeans en el contexto de la petición, la sesión o
la aplicación
• Servlet transfiere control a un JSP que lleva a cabo la
presentación de resultados
7. Modelo MVC II
• El Modelo (Model)
• JavaBeans (o EJBs para aplicaciones más escalables)
desempeña el rol de modelo:
• Algunos beans ejecutan lógica
• Otros guardan datos
• Normalmente:
1. Servlet controlador invoca un método en bean lógico y éste
devuelve un bean de datos
2. Autor de JSP tiene acceso a bean de datos
8. Modelo MVC III
• La Vista (View)
• Rol ejecutado por JSPs
• Servlet Controlador transfiere control al JSP después de
haber guardado en un contexto el resultado en forma
de un bean de datos
• JSP usa jsp:useBean y jsp:getProperty para
recuperar datos y formatear respuesta en HTML o XML
9. Modelo MVC IV
• En resumen:
• Los beans o EJBs ejecutan la lógica de negocio y
guardan los resultados
• Los JSPs proveen la información formateada
• Los servlets coordinan/controlan la ejecución de los
beans y los JSPs
10. Frameworks
• Las frameworks pueden ser vistas como implementaciones
de patrones de diseño que facilitan la reutilización de
diseño y código
• Dado que MVC ha sido utilizado en muchas aplicaciones
web, el desarrollo de frameworks que den soporte a áreas
comunes en todas las aplicaciones MVC es necesario
• Apache Struts es una de estas frameworks
• Aplicaciones basadas en Struts consistirán de:
• Código Java
• Deployment descriptors que configuran la framework para el uso
de nuestra aplicación
11. Apache Jakarta Struts
• Implementación del modelo 2/patrón de diseño MVC que facilita la
creación de aplicaciones web en Java
• Creada por Craig McClanahan y donada a la Apache Software
Foundation en el 2000 (pertenece a Apache Jakarta)
12. ¿Qué proporciona Struts?
• Un servlet (ActionServlet) que actúa como controlador MVC
totalmente configurable
• Clases base que son extendidas para implementar la lógica de la
aplicación web:
• Struts Action
• Struts ActionForm
• Un rico conjunto de etiquetas personalizadas JSP que cooperan con el
controlador para su uso en la capa view de MVC
• Varias opciones para la validación de entrada de usuario en formularios
HTML: ActionForm o Validator Framework
• Mecanismos para el manejo y reporte de errores
• Soporte para la internacionalización (i18n) a través de ficheros de
recursos y Java Locales
• Soporte para fuentes de datos
• Y más …..
13. Instalando Apache Struts I
• Instalar Apache Tomcat 4.x o superior
• Bajar la última versión de Apache Struts de: http://struts.apache.org/download.cgi
• Actualmente en la versión 1.2 (fichero jakarta-struts-1.2.4.zip para Windows)
• Crear directorio de aplicación. E.j: myStrutsApp
• Copiar ficheros .tld en directorio {StrutsDirectory}/contrib/struts-el/lib a
myStrutsApp/WEB-INF:
• c.tld
• struts-bean-el.tld
• struts-html-el.tld
• struts-logic-el.tld
14. Instalando Apache Struts II
• Copiar los ficheros .jar files de {StrutsDirectory}/contrib/struts-el/lib a
myStrutsApp/WEB-INF/lib directory:
• commons-beanutils.jar
• commons-collections.jar
• commmons-digester.jar
• commons-logging.jar
• jstl.jar
• standard.jar
• struts-el.jar
• struts.jar
• Lo mejor es tomar la aplicación struts-blank.war como punto de partida.
15. Documentación y ejemplos de Struts
• En el directorio webapps de la distribución de
Struts 1.2 se pueden encontrar varios ficheros .war
muy útiles:
• struts-documentation.war
• En el subdirectorio api/index.html se puede encontrar
JavaDoc de Struts API
• Si se ejecuta esta aplicación web en
http://localhost:8080/struts-documentation/ se puede
también obtener información detallada sobre el uso de Struts
• Ejemplos de uso de Struts:
• struts-examples.war
• struts-blank.war base para la creación de cualquier
aplicación que use Struts
• etc.
18. Flujo de control en Struts III
• La clase org.apache.struts.action.ActionServlet es el eje de Struts. Dada
una petición de entrada HTTP:
• Crea un objeto ActionForm donde guarda y valida los parámetros de entrada
• Decide que objeto Action se debe invocar y le pasa el objeto ActionForm creado
• Transfiere control a la siguiente etapa de procesamiento de la petición (típicamente un JSP).
• El fichero de configuración web.xml contiene los url mappings para enviar las
peticiones de llegada al ActionServlet, mientras que el fichero de configuración
de Struts struts-config.xml contiene los mappings a acciones
• Los form beans creados por ActionServlet deben ser implementados por el
programador, extendiendo org.apache.struts.action.ActionForm.
• El programador deberá definir un conjunto de getters y setter y sobreescribir los métodos
validate() y reset()
• Los objetos Action invocados deben ser desarrollados por el programador y extienden
org.apache.struts.action.Action. Tienen un método execute() o
(perform() en Struts 1.0) que ejecuta la lógica de negocio
• La acción devuelve un objeto ActionForward al servlet que especifica el siguiente
paso a ejecutar, normalmente se transfiere el control a un JSP para que visualice los
resultados.
19. Pasos a seguir en el desarrollo de una
aplicación en Struts
• Diseña la aplicación en términos de las acciones, vistas y estados del modelo
• Añade las librerías Java de Struts y los .tlds de sus etiquetas personalizadas a tu
proyecto
• Configura tu web.xml para que envíe peticiones HTTP al ActionServet
• Configura el ActionServlet definiendo elementos <action-mappings>
y <form-beans> en struts-config.xml
• Define tus clases Action
• Define tus clases ActionForm
• Define clases adicionales Java representando la lógica de negocio
• Define tus páginas de presentación JSP
• Desplegar la aplicación
• La aplicación ejemplo suministrada con Struts, struts-blank.war, es
normalmente un buen punto de partida para desarrollar una nueva aplicación
usando Struts
20. Actions en Struts
• Se crea una acción extendiendo la clase org.apache.struts.action.Action
• El ActionServlet ejecuta acciones invocando el método execute() tu clase Action
• El método execute() contiene código para manipular el modelo
• Dentro del método execute() tienes acceso a:
• Cabeceras y parámetros de peticiones HTTP
• Atributos/beans guardados en los contextos application/session/request scope
• Struts ActionForm asociados con la acción (opcional)
• El ActionMapping associado a esta acción (opcional)
• El objeto httpResponse
• El método execute() devuelve un objeto ActionForward que indica al ActionServlet
a dónde transferir el control a continuación
21. Form Beans
• Un ActionForm es un JavaBean con propiedades que corresponden a los controles
de un formulario HTML. Los parámetros son mapeados a propiedades del bean.
• Proveen un mecanismo de buffer/validate/convert que necesitamos para asegurarnos
que el usuario introduce los datos esperados
• Actúa como puente entre el navegador y el objeto de negocio
• El programador define un form bean extendiendo la clase
org.apache.struts.action.ActionForm (o de forma declarativa
usando org.apache.struts.action.DynaActionForm)
• Hay que definir cada una de las propiedades en la clase y escribir los
getters/setters correspondientes, siguiendo las reglas de JavaBeans
• Después de escribir el código del form bean, es necesario asociarlo con una o más
acciones a través del fichero de configuración de Struts struts-config.xml
• Cada vez que se llama a la acción , el ActionServlet poblará las propiedades
con los valores de los parámetros recibidos en el formulario HTML
• Las propiedades no sólo pueden ser escalares sino que también pueden ser
colecciones de valores
22. ¿Por qué se necesitan Forms Beans?
• ¿Por qué no simplemente se accede a los parámetros de una petición,
en vez de usar un form bean como intermediario?
• Razones:
• Los Form beans pueden ser validados antes de que una acción sea
invocada
• Si la propiedad validate de un elemento Action en el fichero struts-config.
xml contiene el valor true (por defecto), el método validate
será invocado
• Si un form bean falla en la validación puede hacer que Struts envíe al
usuario de vuelta a la vista (JSP) desde la que se realizó el POST en primer
lugar, junto con un mensaje de error
• Es importante asignar a la propiedad input del elemento action en
struts-config.xml una referencia a la vista que entregó el formulario
• Los form beans pueden ser usados por múltiples acciones o incluso una
aplicación completa
• Si se configura al ActionController para que guarde un form bean en el
contexto de sesión se permitirá el uso del form bean en todas las peticiones
web que llegan a la aplicación
23. Dynamic Action Forms
• Son ActionForms creados de manera declarativa en struts-config.xml
• Una o varias propiedades dinámicas pueden ser pasadas a una instancia de
org.apache.struts.action.DynaActionForm
<form-bean name=“checkoutForm”
type=“org.apache.struts.action.DynaActionForm”>
<form-property name=“firstName”
type=“java.lang.String”/>
<form-property name=“lastName”
type=“java.lang.String”/>
<form-property name=“age” type=“java.lang.Integer”
initial=“18”/>
</form-bean>
24. Recursos de String/Manejo de Errores
• Recursos de String
• Todos los strings usados en mensajes en JSPs tanto de datos de aplicación como de
errores puedes ser colocados en un ficheros de recursos
(ApplicationResources.properties)
• Struts proporciona etiquetas personalizadas JSP tags para acceder a estos recursos
<bean:message key="prompt.goodguess.heading"/>
• Manejo de errores
• Se recomienda que el manejo de errores se lleve a cabo dentro del método
execute() y el control se transfiera a la vista apropiada
errors.add("passphrase",new
ActionError("error.passphrase.required"));
• Struts proporciona un mecanismo separado para permitir la implementación de un
manejador global de excepciones
• Struts proporciona etiquetas JSP que ayudan en la visualización de los errores en tu
JSP:
<html:errors property=“passphrase”/>
25. Internationalization i18n
• Struts soporta internacionalización a través de ficheros de recursos, sus librerías de
etiquetas personalizadas y Java Locales
• Se pueden definir strings a visualizar en tu fichero de recursos, y luego ser usados
en tus JSPs
• Los strings del idioma por defecto se guardan en el fichero
ApplicationResources.properties
• Otros ficheros de recursos adicionales pueden ser definidos que incluyen el idioma
a usar en el nombre del fichero.
• Ejemplo:
• ApplicationResources_eu.properties (Contiene mensajes en Euskera)
• ApplicationResources_es.properties (Contiene mensajes en Castellano)
• Para cambiar el idioma preferido en IE: ToolsInternet OptionsLanguages
• Los navegadores envían la cabecera HTTP Accept-Language en cada petición
que indica cuál es el idioma preferido por el usuario
• Los ficheros de recursos deben colocarse en un lugar accesible desde el
CLASSPATH de la aplicación web, por ejemplo, debajo del directorio WEB-INF/
classes
27. Configurando Struts
• Como en toda framework se minimiza el código Java a
escribir y se maximiza la configuración a través de ficheros
XML
• Struts se configura a través struts-config.xml
• Leído por la framework cuando arranca
• Contiene:
• Fuentes de datos (data-sources)
• Form beans, variaciones de JavaBeans.
• Ejecutan una petición basado en una entrega de un formulario.
• Son poblados por el controlador con los datos del formulario
• Llevan a cabo validación de datos
• Son procesados por objetos Action
• Global forwards y
• ActionMappings
• Mapean el nombre de una acción a un objeto Action
30. Procesamiento de una petición en Struts I
• Si el cliente envía la petición:
• http://server/app/GotoReplyToAction.do
• El ActionServlet de Struts quita la extensión (.do) y
mira la acción correspondiente en el fichero de
configuración Struts para la acción
GotoReplyToAction
• Si la encuentra encontrará o creará una instancia del ‘tipo’
(type) indicado:
com.develop.ejsp.struts.actions.GotoMes
sageAction
• El método execute() será invocado en el objeto
GotoMessageAction:
• Este es el lugar donde la lógica de negocio de la petición es
ejecutada
31. Procesamiento de petición en Struts II
public class GotoMessageAction
extends org.apache.struts.action.Action {
public ActionForward execute(
ActionMapping mapping,
ActionForm actionForm,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
// lots of code omitted for clarity, but here the
// business logic should be implemented
ActionForward af = mapping.findForward("succeeded");
return af;
}
}
32. Procesamiento de petición en Struts III
• De los cuatro parámetros recibidos en execute(),
ActionMapping y ActionForm son específicos a Struts
• El objeto ActionMapping contiene información de configuración
proveniente de struts-config.xml file.
• El objeto ActionForm contiene el bean del formulario que fue
inicializado por el ActionServlet al procesar la petición
33. Procesamiento de petición en Struts IV
• En el mapeo de la acción GotoReplyToAction hay dos posibles forward
definidos:
• Uno con el nombre "succeeded" y otro
• "failed“
• Si el método execute() se completa sin errores el método
ActionMapping.findForward() es llamado, pasando el nombre del
siguiente recurso a llamar.
• El método findForward() devuelve un objeto ActionForward que es pasado al
ActionServlet
• El objeto ActionForward contiene detalles de a dónde debería el ActionServlet
enviar la petición (contiene el path del JSP que va a visualizar los resultados)
34. Manejo de errores en Struts I
• Struts define la clase ActionErrors que mantiene una colección de objetos
ActionError.
ActionErrors errors = new ActionErrors();
errors.add (ActionErrors.GLOBAL_ERROR,
new ActionError("error.signing.connect"));
saveErrors(request,errors);
return (new ActionForward (mapping.findForward(“failed")));
• El código añade un sólo objeto ActionError a la colección, pero si se llevase a cabo
validación de los campos de un formulario varios errores podrían ser mostrados.
• Luego devuelve una instancia de ActionForward que redirige a "failed".
• El ActionServlet guardará en el objeto request el objeto ActionErrors bajo un
nombre bien conocido por Struts:
request.setAttribute( Action.ERROR_KEY, errors);
• Este objeto ActionErrors es ahora disponible a cualquier página o acción
consecutiva.
• La página JSP “failed” anterior debería tener un área donde se mostrasen los errores
producidos.
• El string usado para construir un objeto ActionError no es un mensaje de error sino
que un identificador de un recurso (i18n Struts)
35. Manejo de errores en Struts II
public class GotoMessageAction extends org.apache.struts.action.Action {
public ActionForward execute(ActionMapping mapping,
ActionForm actionForm,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
ActionErrors errors = new ActionErrors();
try {
// business logic omitted for clarity
} catch(SQLException e) {
errors.add(ActionErrors.GLOBAL_ERROR,
new ActionError("error.sqlerror"));
}
if (!errors.empty()) {
saveErrors(request, errors);
ActionForward af = mapping.findForward("failed");
return af;
}
request.setAttribute(Message.MESSAGE_NAME, message);
ActionForward af = mapping.findForward("succeeded");
return af;
}
}
36. Manejo de Formularios I
• La otra acción definida en el fichero de configuración de Struts era:
<action path="/SigninAction" type="com.develop.ejsp.struts.
actions.SigninAction" name="SigninForm" scope="session"
input="/signin.jsp">
<forward name="succeeded" path="/groups.jsp"/>
<forward name="failed" path="/groups.jsp"/>
</action>
• Esta acción está asociada con el formulario llamado SigningForm, también definido en el fichero de
configuración:
<form-beans>
<form-bean name="SigninForm" type="com.develop.ejsp.struts.
beans.SigninForm"/>
</form-beans>
37. Manejo de Formularios II
• Si una acción tiene un formulario asociado a ella (atributo name en
action mapping), el ActionServlet crea un form bean
• Todo form bean hereda de
org.apache.struts.action.ActionForm, que es un
JavaBean serializable.
• Dos métodos en ActionForm pueden ser sobreescritos:
• validate() y
• reset()
38. Manejo de Formularios III
public ActionErrors validate(ActionMapping mapping,
HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
if ((username == null) || (username.length() < 1))
errors.add ("username",
new ActionError("error.username.required"));
if ((password == null) || (password.length() < 1))
errors.add("password",
new ActionError("error.password.required"));
return errors;
}
• El FormBean es poblado por el ActionServlet con los parámetros de la petición de entrada
llamando a los métodos setXXX() correspondientes.
• Una vez poblado, el form bean es validado:
• Si el objeto ActionErrors devuelto es null o vacío significa que la validación tuvo éxito y una instancia del
form bean creado, en este caso SigningForm, es pasado al objeto SigningAction
• Si la validación falla, la petición será re-direccionada por Struts a la página que contenía el formulario
inicialmente el formulario, dada por el atributo input del elemento action en struts-config.xml
39. Manejo de Formularios IV
public class SigninForm extends ActionForm {
String userName = null;
String password = null;
public SigninForm() {}
public void setUsername(String userName) {
this.userName = userName;
}
public String getUserName() {
return this.userName;
}
public void setPassword(String password) {
this.password = password;
}
public String getPassword() {
return this.password;
}
...
40. Manejo de Formularios V
// accessors and mutator omitted for clarity
public ActionErrors validate(ActionMapping actionMapping,
HttpServletRequest httpServletRequest) {
ActionErrors errors = new ActionErrors();
if ((password == null) || (password.length() < 1))
errors.add("password", new
ActionError("error.password.required"));
if ((userName == null) || (userName.length() < 1))
errors.add("username", new
ActionError("error.username.required"));
return errors;
}
public void reset(ActionMapping actionMapping,
HttpServletRequest httpServletRequest) {
username = "";
password="";
}
}
41. Manejo de Formularios VI
public class SigninAction
extends org.apache.struts.action.Action {
public ActionForward execute(ActionMapping mapping,
ActionForm form,
HttpServletRequest request,
HttpServletResponse response)
throws IOException, ServletException {
try {
String username = ((SigninForm) form). getUserName();
String password = ((SigninForm) form). getPassword();
// etc.
}
}
}
42. DataSources en Struts
try {
DataSource ds = servlet.findDataSource(“usuarios”);
message = new Message();
message.getMessage(ds,
request.getParameter( Message.MESSAGE_ID)),
request.getParameter( GROUP_ID_NAME))
}
• El código arriba muestra otra característica de Struts, la habilidad de configurar y usar referencias a
javax.jdbc.DataSources
• El extracto de struts-config.xml anteriormente mostrado tiene una sección <data-sources> para configurar
las data sources de la aplicación.
• Struts provee las clases GenericDataSource y GenericConnection que son wrappers sobre los objetos JDBC
Connections y DataSources definidos en el fichero de configuración.
43. Struts Tag Libraries
• Documentadas en http://www.onjava.com/lpt/a/4034
• La framework Struts proporciona un conjunto de 6 librerías
de etiquetas, que asisten en la tarea de la creación de la
vista de MVC para evitar incluir código Java en los JSPs:
• Bean Tags
• HTML Tags
• Logic Tags
• Nested Tags
• Template Tags
• Tiles Tags
• Las funcionalidad de las etiquetas definidas en las librerías
Bean y Logic es también provista por las librerías core
y fmt de JSTL
• Se recomienda el uso de las librerías en JSTL
44. HTML Tags
• Estas etiquetas son principalmente usadas para:
• Crear formularios de entrada de datos y
• Otras utilidades para visualizar interfaces basados en HTML.
• Algunas de las acciones más útiles son:
• base genera un elemento HTML <base>
• errors condicionalmente visualiza un conjunto acumulado de mensajes de error
• form define un formulario de entrada
• text visualiza un campo de entrada de tipo texto
• messages condicionalmente visualiza un conjunto de mensajes acumulados
• submit visualiza un botón de entrega
• Etc.
45. Logic Tags
• Usadas para:
• Iterar sobre colecciones
• Generación condicional de salida, y
• Flujo de aplicación
• Algunas de las acciones más útiles son:
• present genera el contenido de marcado dentro de esta etiqueta si el valor indicado es
encontrado en esta petición
• notPresent lo opuesto a present
• iterate repite el contenido anidado dentro de esta etiqueta al iterar sobre una
colección
• forward transfiere control a la página especificada por la entrada ActionForward.
• Etc.
46. Tiles Tags (Framework)
• La librería de etiquetas Tiles es un super-conjunto de la librería
Templates
• Intenta evitar la duplicación de contenido de lenguaje de marcado
dentro de una aplicación web con respecto al look-and-feel de un
portal:
• Un mecanismo normalmente utilizado es usar la directiva jsp:include
para añadir cabeceras/menús y pies de páginas a un portal web
• Tiles reduce el tamaño de código redundante en una aplicación web y
separa el contenido de la visualización del mismo de manera más
eficiente
• Tiles define Layout Managers para JSPs
• Su objetivo principal es evitar en los JSPs contenido de marcado que
corresponda con el layout del portal factoriza este marcado, de tal
manera que la modificación del layout sea sencilla y eficiente
47. JSP Templates
• Un template es una página JSP que usa una librería
de etiquetas personalizadas para describir la
disposición (layout) de los componentes de la
página
• Define cómo aparecerán las páginas JSP de una
aplicación, sin especificar el contenido
• Esta definición es utilizada por todos los JSPs sin
necesidad de mezclar layout con contenido
48. Ejemplo Tiles: index.jsp I
<%@ taglib uri="/WEB-INF/struts-html.tld" prefix="html" %>
<%@ taglib uri="/WEB-INF/struts-logic.tld" prefix="logic" %>
<%@ taglib uri="/WEB-INF/struts-bean.tld" prefix="bean" %>
<html:html>
<head>
<title><bean:message key="global.title"/></title>
<html:base/>
<script language=javascript src="include/scripts.js"></script>
<link rel="stylesheet" href="stylesheets/format_win_nav_main.css" type="text/css">
</head>
<body topmargin="0" leftmargin="0" bgcolor="#FFFFFF">
<!-- Header Page Information -->
<%@ include file="include/head.inc"%>
<!-- Nav Bar -->
<%@ include file="include/menubar.inc"%>
52. Ejemplo Tiles: index.jsp
<%@ taglib uri=“/WEB-INF/tiles.tld” prefix=“tiles” %>
<%@ include file=“../common/storefront-defs.jsp” %>
<tiles:insert beanName=“storefront.default”
beanScope=“request”>
<tiles:put name=“body-content”
value=“index-body.jsp”/>
</tile:insert>
• Para más información sobre Tiles Framework ir a:
http://www.lifl.fr/~dumoulin/tiles/index.html
• Para instalar Tiles en Struts es necesario añadir una sección plug-in en
struts-config.xml para la clase:
org.apache.struts.tiles.TilesPlugin
53. Mi primera aplicación con Apache Struts
• Aplicación para llevar a cabo login
• Una vez que el usuario ha hecho login las páginas cambian para indicar tal
circunstancia
• Consiste de dos pantallas:
• Página Welcome que saluda al usario y ofrece enlaces a la aplicación
• Página Logon que permite al usuario introducir username y password
• Esta página lleva a cabo la validación que los datos introducidos son correctos
56. Welcome.jsp II
• <html:base/> garantiza que referencias a imágenes o otros recursos son relativas a la localización del JSP
<logic:present name="user">
<H3>Welcome <bean:write name="user" property="username"/>!</H3>
</logic:present>
• Esta etiqueta personalizada asegura que el usuario solamente es saludado si ha efectuado login
• <logic:notPresent> tiene el comportamiento opuesto
<LI><html:link forward="logon">Sign in</html:link></LI>
• Struts reescribe automáticamente los enlaces para mantener la sesión del usuario. También permite dar a
los enlaces un nombre lógico y luego guardar los enlaces reales en un fichero de configuración.
59. Logon.jsp II
<%@ taglib uri="/tags/struts-html" prefix="html"%>
• La librería de etiquetas html definida por Struts es disponible a la página
• <html:errors/> garantiza si ha habido algún error durante el login, que estos errores sean
visualizados
<html:form action="/LogonSubmit" focus="username">
• Produce un formulario HTML para la entrada de datos. También genera JavaScript para mover el
cursor al campo username del formulario
• La propiedad action hace referencia a un componente ActionMapping en el fichero de
configuración de Struts dice al formulario que JavaBean (derivado de ActionForm) debe usar para
poblar los controles de HTML.
60. Logon.jsp III
<html:text property="username"/>
• Crea un control de entrada HTML para un campo de texto. Asignará a este campo
la propiedad username del JavaBean de ayuda antes mencionado.
• <html:password> crea un campo de entrada
• <html:submit> y <html:reset> generan botones HTML Submit y Reset. Dos
objetos serán invocados cuando se usen estos botones:
• ActionForm
• Action
61. Configuración de la acción logon I
• Configuración para la pantalla de logon:
• JSP hace referencia al /LogonSubmit ActionMapping
• ActionMapping hace referencia a los objetos:
• app.LogonForm describe propiedades usadas por el formulario logon
• app.LogonAction lleva a cabo el procesamiento del formulario
62. Configuración de la acción logon II
<html:form action="/LogonSubmit" focus="username">
• La configuración asociada al atributo acción en Struts sería:
<action path="/LogonSubmit"
type="app.LogonAction"
name="logonForm"
scope="request"
validate="true"
input="/pages/Logon.jsp"/>
• path identicador único para el mapping
• type acción a invocar cuando el formulario es entregado
• name el helper JavaBean (ActionForm) a usarse con el formulario HTML
• scope indica en qué contexto debe guardarse el ActionForm
• validate indica si es necesario invocar al método validate del ActionForm antes
de invocar al objeto Action
• input indica a donde ir si validate devuelve falso
<form-bean name="logonForm"
type="app.LogonForm"/>
• Este extracto del fichero de configuración relaciona el nombre lógico logonForm con la clase
app.LogonForm
63. LogonForm: un ejemplo de un ActionForm
public ActionErrors validate(ActionMapping mapping,
HttpServletRequest request) {
ActionErrors errors = new ActionErrors();
if ((username == null) || (username.length() < 1))
errors.add ("username",
new ActionError("error.username.required"));
if ((password == null) || (password.length() < 1))
errors.add("password",
new ActionError("error.password.required"));
return errors;
}
• Si validate no devuelve null, entonces el ActionController servlet guardará el objeto
ActionErrors devuelto en el contexto request, bajo una clave conocida por la etiqueta
html:errors
• Los tokens error.username.required y error.password.required son claves
que son utilizadas para mirar los strings correspondientes en el fichero de recursos de Struts
• Recordar que cada Locale contiene su propio fichero de recursos lo que hace que los mensajes sean
fácilmente localizables.
64. LogonAction: un ejemplo de un LogonAction I
package app;
import java.io.IOException;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpSession;
import javax.servlet.http.HttpServletResponse;
import org.apache.struts.action.Action;
import org.apache.struts.action.ActionError;
import org.apache.struts.action.ActionErrors;
import org.apache.struts.action.ActionForm;
import org.apache.struts.action.ActionForward;
import org.apache.struts.action.ActionMapping;
import org.apache.struts.action.ActionServlet;
public final class LogonAction extends Action {
// Validate credentials with business tier
public boolean isUserLogon (String username,
String password) throws UserDirectoryException {
return (UserDirectory.getInstance().isValidPassword(username,password));
} // end isUserLogon
65. LogonAction: un ejemplo de un LogonAction
II public ActionForward execute(ActionMapping mapping, ActionForm form, HttpServletRequest request, HttpServletResponse response)
throws IOException, ServletException {
// Obtain username and password from web tier
String username = ((LogonForm) form).getUsername();
String password = ((LogonForm) form).getPassword();
// Validate credentials
boolean validated = false;
try {
validated = isUserLogon(username,password);
} catch (UserDirectoryException ude) {
// couldn't connect to user directory
ActionErrors errors = new ActionErrors();
errors.add (ActionErrors.GLOBAL_ERROR, new ActionError("error.logon.connect"));
saveErrors(request,errors);
// return to input page
return (new ActionForward (mapping.getInput()));
}
// Save our logged-in user in the session, because we use it again later.
HttpSession session = request.getSession();
session.setAttribute(Constants.USER_KEY, form);
// Log this event, if appropriate
if (servlet.getDebug() >= Constants.DEBUG) {
StringBuffer message = new StringBuffer("LogonAction: User '");
message.append(username);
message.append("' logged on in session ");
message.append(session.getId());
servlet.log(message.toString);
}
// Return success
return (mapping.findForward (Constants.WELCOME));
} // end perform
} // end LogonAction
66. LogonAction: un ejemplo de un LogonAction
III
// Validate credentials
boolean validated = false;
try {
validated = isUserLogon(username,password);
} catch (UserDirectoryException ude) {
// couldn't connect to user directory
ActionErrors errors = new ActionErrors();
errors.add (ActionErrors.GLOBAL_ERROR,
new ActionError("error.logon.connect"));
saveErrors(request,errors);
// return to input page
return (new ActionForward(mapping.getInput()));
}
• Si un error es encontrado mientras se lleva a cabo la validación de la entrada del usuario y una excepción es lanzada,
entonces el error es transformado en un ActionError y el control es devuelto a la página de entrada. Lo mismo se
lleva a cabo si se puede contactar al servicio de directorio pero el login del usuario no es correcto
return (mapping.findForward (Constants.WELCOME));
• Un objeto de tipo ActionForward será devuelto al ActionServlet si todo va bien. En este caso se envía control al forward
success declarado en el fichero de configuración como:
<forward name=“success”
path=“/pages/Welcome.jsp”/>
67. Modificaciones a realizar en guessing
1. Modificar action /guess en struts-config.xml, haciendo que esa acción esté asociada a la clase
es.deusto.guessing.action.GuessingAction y al formulario es.deusto.guessing.form.GuessingForm.
2. Asegurarse que existe correspondencia entre clase guessing.jsp y GuessingForm
3. Asegurarse que un usuario después de haber hecho login pueda jugar una partida, el usuario podrá realizar
intentos infinitamente, pero esos intentos hay que contabilizarlos y visualizarlos cada vez que el usuario
falla o adivina el número
4. El número a adivinar es asociado a la sesión del usuario y generado la primera vez que la acción execute se
ejecuta para un usuario
5. Idealmente crear una clase llamada Game que contenga el número a adivinar y el número de intentos
fallidos
6. Modificar la aplicación de manera que nuevos usuarios puedan ser definidos y los datos de login de esos
usuarios se salven en un fichero .properties.
68. Más Ejemplos
• Para más ejemplos del uso de Struts visitar:
• http://struts.sourceforge.net/