Este documento proporciona una introducción a las páginas Java Server Page (JSP). Explica las características y funcionalidades clave de JSP, incluidas las diferencias con los servlets. También presenta ejemplos de código JSP simple que ilustran el uso de expresiones, scriplets, directivas y otros elementos básicos de JSP. Finalmente, cubre temas como la gestión de excepciones y el uso de páginas de error en JSP.
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.
El documento introduce JavaServer Pages (JSP), que combina HTML y fragmentos de Java para generar páginas web dinámicas. Cuando un cliente solicita una página JSP, esta es compilada a un servlet por el motor JSP, ejecutado, y los resultados son devueltos al cliente. JSP proporciona una forma más conveniente de escribir y modificar páginas web dinámicas que usar sólo servlets.
El documento proporciona información sobre el uso de JavaBeans en JSP. Explica cómo declarar e instanciar JavaBeans usando <jsp:useBean>, establecer y obtener propiedades de los beans con <jsp:setProperty> y <jsp:getProperty>, y los diferentes ámbitos de alcance que pueden tener los beans como page, request, session y application.
Este documento proporciona una introducción básica a JavaServer Pages (JSP). Explica que JSP permite incluir código Java en páginas web, y que el contenedor JSP se encarga de ejecutar ese código y enviar la página resultante al cliente. Describe los diferentes elementos que se pueden incluir en una página JSP, como expresiones, scriptlets, declaraciones, directivas y acciones. Explica cómo el contenedor JSP traduce internamente una página JSP a un servlet Java, y cómo JSP y servlets ofrecen
1) Las páginas JSP combinan HTML con fragmentos de Java para producir páginas web dinámicas. 2) Cuando un cliente solicita una página JSP, esta es compilada a un servlet Java que es ejecutado y devuelve el contenido al cliente. 3) El documento explica conceptos como directivas, declaraciones, expresiones y etiquetas en JSP, así como el uso de JavaBeans.
Este documento introduce los conceptos básicos de JavaServer Pages (JSP). Explica que las páginas JSP combinan HTML, etiquetas especiales y fragmentos de código Java. Describe los diferentes elementos que pueden incluirse en una página JSP como directivas, código Java, acciones y objetos implícitos. También presenta conceptos como la inclusión de páginas, transferencia de control, parámetros de petición y comunicación con formularios HTML.
Este documento presenta un taller de Java avanzado que incluye temas como Servlets, JSP, Javabeans, EJB y Struts. Una sección detalla los conceptos de JSP, incluyendo sus beneficios sobre otras tecnologías como ASP y PHP, así como ejemplos de uso de expresiones, scriptlets y declaraciones en JSP.
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.
El documento introduce JavaServer Pages (JSP), que combina HTML y fragmentos de Java para generar páginas web dinámicas. Cuando un cliente solicita una página JSP, esta es compilada a un servlet por el motor JSP, ejecutado, y los resultados son devueltos al cliente. JSP proporciona una forma más conveniente de escribir y modificar páginas web dinámicas que usar sólo servlets.
El documento proporciona información sobre el uso de JavaBeans en JSP. Explica cómo declarar e instanciar JavaBeans usando <jsp:useBean>, establecer y obtener propiedades de los beans con <jsp:setProperty> y <jsp:getProperty>, y los diferentes ámbitos de alcance que pueden tener los beans como page, request, session y application.
Este documento proporciona una introducción básica a JavaServer Pages (JSP). Explica que JSP permite incluir código Java en páginas web, y que el contenedor JSP se encarga de ejecutar ese código y enviar la página resultante al cliente. Describe los diferentes elementos que se pueden incluir en una página JSP, como expresiones, scriptlets, declaraciones, directivas y acciones. Explica cómo el contenedor JSP traduce internamente una página JSP a un servlet Java, y cómo JSP y servlets ofrecen
1) Las páginas JSP combinan HTML con fragmentos de Java para producir páginas web dinámicas. 2) Cuando un cliente solicita una página JSP, esta es compilada a un servlet Java que es ejecutado y devuelve el contenido al cliente. 3) El documento explica conceptos como directivas, declaraciones, expresiones y etiquetas en JSP, así como el uso de JavaBeans.
Este documento introduce los conceptos básicos de JavaServer Pages (JSP). Explica que las páginas JSP combinan HTML, etiquetas especiales y fragmentos de código Java. Describe los diferentes elementos que pueden incluirse en una página JSP como directivas, código Java, acciones y objetos implícitos. También presenta conceptos como la inclusión de páginas, transferencia de control, parámetros de petición y comunicación con formularios HTML.
Este documento presenta un taller de Java avanzado que incluye temas como Servlets, JSP, Javabeans, EJB y Struts. Una sección detalla los conceptos de JSP, incluyendo sus beneficios sobre otras tecnologías como ASP y PHP, así como ejemplos de uso de expresiones, scriptlets y declaraciones en JSP.
Este documento presenta una introducción a las páginas JavaServer (JSP) y sus principales características. Explica que los JSP se traducen internamente a servlets Java y cubre elementos como código Java, objetos implícitos, directivas como page e include, y acciones como include y forward.
Java Server Pages (JSP) es una tecnología que permite crear páginas web dinámicas usando Java como lenguaje de programación. JSP combina la potencia de Java en el servidor con la flexibilidad de HTML en el navegador. El código JSP se compila en código Java de servlets que generan páginas HTML dinámicas en respuesta a solicitudes del cliente.
El documento describe los conceptos básicos de JSP, incluyendo que es JSP, sus ventajas, objetos implícitos, variables predefinidas, etiquetas, elementos como expresiones, declaraciones, comentarios y scriptlets, y acciones como include y forward. JSP permite crear páginas web dinámicas combinando HTML con fragmentos de código Java a través del uso de estas características.
Un JSP es un documento basado en etiquetas HTML y etiquetas propias de JSP. Los servlets y JSP son dos métodos para crear páginas web dinámicas en servidor usando Java. Los JSP se compilan a clases de Java en el servidor y se ejecutan como servlets, la diferencia principal es que un JSP contiene etiquetas y código Java incrustado mientras que un servlet genera la página web a partir de peticiones.
El documento introduce las JavaServer Pages (JSP), una tecnología que permite separar la lógica de negocio de la presentación en aplicaciones web. JSP utiliza etiquetas para incrustar código Java en páginas HTML y generar contenido dinámico. Las páginas JSP se compilan en servlets Java para procesar solicitudes y responder con páginas HTML, lo que mejora la velocidad y escalabilidad con respecto a otras tecnologías como ASP. El documento también explica cómo manejar formularios y crear componentes reutiliz
Este documento introduce los conceptos básicos de JavaServer Pages (JSP). JSP permite crear páginas web dinámicas mediante la incorporación de código Java en archivos con extensión .jsp. Al solicitar una página JSP, el servidor ejecuta el código Java y genera una página HTML estática para el cliente. El documento explica los componentes de JSP como expresiones, declaraciones, etiquetas y directivas, y provee un ejemplo sencillo de una página JSP.
Este documento describe los diferentes elementos que se pueden insertar en una página JSP, incluyendo código Java mediante expresiones, scriptlets y declaraciones, directivas que proporcionan información al motor JSP, y acciones que permiten incluir páginas y transferir el control.
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 un taller de Java avanzado que incluye temas como Servlets, JSP, Javabeans, EJB y Struts. El tema 2 se enfoca en Servlets, explicando qué son los servlets, su ciclo de vida y cómo se pueden utilizar para procesar peticiones HTTP y generar respuestas dinámicas. También cubre conceptos como ServletRequest, ServletResponse, HttpServletRequest, sesiones, cookies y filtros. El documento incluye ejemplos prácticos de cómo implementar funcionalidades comunes con servlets.
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.
1) Los servlets y JSPs son módulos que amplían las capacidades de los servidores web orientados a petición-respuesta, permitiendo generar páginas dinámicas en Java.
2) Los servlets usan los métodos doGet y doPost para procesar solicitudes HTTP y devolver respuestas, mientras que las JSPs permiten combinar código estático y dinámico en un mismo archivo para generar contenido.
3) Tanto los servlets como las JSPs pueden acceder a la solicitud, sesión, y otros objetos para proces
Para usar JSP se necesita un servidor web con hardware y software. Una vez instalado el servidor, los archivos JSP se agregan y se distinguen por su extensión .jsp. Las clases Java referenciadas por los documentos JSP deben instalarse en la ruta de clases del contenedor Java. Los servlets son programas basados en Java que procesan solicitudes URL, mientras que las páginas JSP contienen etiquetas como directivas, elementos de scripting y acciones que se ejecutan cuando se solicita la página.
JSP (JavaServer Pages) es una tecnología que ayuda a crear páginas web dinámicas basadas en HTML y Java. Los objetos de JSP son creados por el contenedor de servlets e incluyen REQUEST, RESPONSE, OUT, CONFIG, PAGE, EXCEPTION, SESSION, PAGE CONTEXT y APPLICATION. REQUEST encapsula la petición del cliente, RESPONSE la respuesta, y OUT permite imprimir la salida.
Este documento discute cómo construir aplicaciones web combinando diferentes tecnologías como servlets, JSP y JavaBeans. Presenta dos arquitecturas principales: una centrada en páginas que coloca la lógica en las páginas JSP, y otra basada en MVC que separa la lógica, la vista y el controlador, asignando servlets al controlador, JSP a la vista y JavaBeans al modelo. Esta segunda arquitectura es más escalable y modular.
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.
JSP (JavaServer Pages) permite incluir código Java en páginas web. El contenedor JSP toma la página, ejecuta el código Java, y envía la página resultante al cliente. Esto facilita crear páginas con partes estáticas y dinámicas. El proceso implica que el cliente solicite una página JSP, el servidor ejecute el código Java en la página y envíe el resultado en HTML al cliente.
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.
Este documento presenta una introducción a las tecnologías Java EE, incluyendo servidores y contenedores, componentes como servlets y JSP, y patrones como DTO, MVC y DAO. El objetivo es entender el contexto de las aplicaciones Java EE. Se explican brevemente conceptos como servidores, servlets, JSP, y los patrones DTO, MVC y DAO.
Este curso enseña el desarrollo de aplicaciones web usando la plataforma Java 2 Enterprise Edition (J2EE). Cubre temas como servlets, JSP, Struts, JavaServer Faces, Enterprise JavaBeans y AJAX. El objetivo es que los estudiantes aprendan a crear grandes soluciones de software empresarial usando Java. El curso dura 260 horas y es presencial.
Este documento presenta una introducción a la implementación de una aplicación de carrito de compras utilizando Java Enterprise Edition (JEE) con PostgreSQL, Eclipse, Hibernate, EJB3 y Struts en el servidor JBoss. Se explica cómo configurar el entorno de desarrollo, incluida la instalación de las herramientas, la base de datos, los plugins y el servidor de aplicaciones. Luego, se muestra un ejemplo práctico de una aplicación JEE completa con la creación de entidades, sesiones y pruebas de los componentes EJB. Finalmente
Este documento describe los diferentes elementos y acciones JSP que permiten insertar código Java, incluir otros archivos, definir beans y manipular sus propiedades, redirigir peticiones y más. Algunos de los elementos clave son <jsp:expression> para mostrar el resultado de una expresión, <jsp:scriptlet> para insertar código Java, <jsp:include> para incluir otros archivos, y <jsp:useBean> para definir y manipular beans Java.
Este documento presenta una introducción a las páginas JavaServer (JSP) y sus principales características. Explica que los JSP se traducen internamente a servlets Java y cubre elementos como código Java, objetos implícitos, directivas como page e include, y acciones como include y forward.
Java Server Pages (JSP) es una tecnología que permite crear páginas web dinámicas usando Java como lenguaje de programación. JSP combina la potencia de Java en el servidor con la flexibilidad de HTML en el navegador. El código JSP se compila en código Java de servlets que generan páginas HTML dinámicas en respuesta a solicitudes del cliente.
El documento describe los conceptos básicos de JSP, incluyendo que es JSP, sus ventajas, objetos implícitos, variables predefinidas, etiquetas, elementos como expresiones, declaraciones, comentarios y scriptlets, y acciones como include y forward. JSP permite crear páginas web dinámicas combinando HTML con fragmentos de código Java a través del uso de estas características.
Un JSP es un documento basado en etiquetas HTML y etiquetas propias de JSP. Los servlets y JSP son dos métodos para crear páginas web dinámicas en servidor usando Java. Los JSP se compilan a clases de Java en el servidor y se ejecutan como servlets, la diferencia principal es que un JSP contiene etiquetas y código Java incrustado mientras que un servlet genera la página web a partir de peticiones.
El documento introduce las JavaServer Pages (JSP), una tecnología que permite separar la lógica de negocio de la presentación en aplicaciones web. JSP utiliza etiquetas para incrustar código Java en páginas HTML y generar contenido dinámico. Las páginas JSP se compilan en servlets Java para procesar solicitudes y responder con páginas HTML, lo que mejora la velocidad y escalabilidad con respecto a otras tecnologías como ASP. El documento también explica cómo manejar formularios y crear componentes reutiliz
Este documento introduce los conceptos básicos de JavaServer Pages (JSP). JSP permite crear páginas web dinámicas mediante la incorporación de código Java en archivos con extensión .jsp. Al solicitar una página JSP, el servidor ejecuta el código Java y genera una página HTML estática para el cliente. El documento explica los componentes de JSP como expresiones, declaraciones, etiquetas y directivas, y provee un ejemplo sencillo de una página JSP.
Este documento describe los diferentes elementos que se pueden insertar en una página JSP, incluyendo código Java mediante expresiones, scriptlets y declaraciones, directivas que proporcionan información al motor JSP, y acciones que permiten incluir páginas y transferir el control.
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 un taller de Java avanzado que incluye temas como Servlets, JSP, Javabeans, EJB y Struts. El tema 2 se enfoca en Servlets, explicando qué son los servlets, su ciclo de vida y cómo se pueden utilizar para procesar peticiones HTTP y generar respuestas dinámicas. También cubre conceptos como ServletRequest, ServletResponse, HttpServletRequest, sesiones, cookies y filtros. El documento incluye ejemplos prácticos de cómo implementar funcionalidades comunes con servlets.
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.
1) Los servlets y JSPs son módulos que amplían las capacidades de los servidores web orientados a petición-respuesta, permitiendo generar páginas dinámicas en Java.
2) Los servlets usan los métodos doGet y doPost para procesar solicitudes HTTP y devolver respuestas, mientras que las JSPs permiten combinar código estático y dinámico en un mismo archivo para generar contenido.
3) Tanto los servlets como las JSPs pueden acceder a la solicitud, sesión, y otros objetos para proces
Para usar JSP se necesita un servidor web con hardware y software. Una vez instalado el servidor, los archivos JSP se agregan y se distinguen por su extensión .jsp. Las clases Java referenciadas por los documentos JSP deben instalarse en la ruta de clases del contenedor Java. Los servlets son programas basados en Java que procesan solicitudes URL, mientras que las páginas JSP contienen etiquetas como directivas, elementos de scripting y acciones que se ejecutan cuando se solicita la página.
JSP (JavaServer Pages) es una tecnología que ayuda a crear páginas web dinámicas basadas en HTML y Java. Los objetos de JSP son creados por el contenedor de servlets e incluyen REQUEST, RESPONSE, OUT, CONFIG, PAGE, EXCEPTION, SESSION, PAGE CONTEXT y APPLICATION. REQUEST encapsula la petición del cliente, RESPONSE la respuesta, y OUT permite imprimir la salida.
Este documento discute cómo construir aplicaciones web combinando diferentes tecnologías como servlets, JSP y JavaBeans. Presenta dos arquitecturas principales: una centrada en páginas que coloca la lógica en las páginas JSP, y otra basada en MVC que separa la lógica, la vista y el controlador, asignando servlets al controlador, JSP a la vista y JavaBeans al modelo. Esta segunda arquitectura es más escalable y modular.
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.
JSP (JavaServer Pages) permite incluir código Java en páginas web. El contenedor JSP toma la página, ejecuta el código Java, y envía la página resultante al cliente. Esto facilita crear páginas con partes estáticas y dinámicas. El proceso implica que el cliente solicite una página JSP, el servidor ejecute el código Java en la página y envíe el resultado en HTML al cliente.
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.
Este documento presenta una introducción a las tecnologías Java EE, incluyendo servidores y contenedores, componentes como servlets y JSP, y patrones como DTO, MVC y DAO. El objetivo es entender el contexto de las aplicaciones Java EE. Se explican brevemente conceptos como servidores, servlets, JSP, y los patrones DTO, MVC y DAO.
Este curso enseña el desarrollo de aplicaciones web usando la plataforma Java 2 Enterprise Edition (J2EE). Cubre temas como servlets, JSP, Struts, JavaServer Faces, Enterprise JavaBeans y AJAX. El objetivo es que los estudiantes aprendan a crear grandes soluciones de software empresarial usando Java. El curso dura 260 horas y es presencial.
Este documento presenta una introducción a la implementación de una aplicación de carrito de compras utilizando Java Enterprise Edition (JEE) con PostgreSQL, Eclipse, Hibernate, EJB3 y Struts en el servidor JBoss. Se explica cómo configurar el entorno de desarrollo, incluida la instalación de las herramientas, la base de datos, los plugins y el servidor de aplicaciones. Luego, se muestra un ejemplo práctico de una aplicación JEE completa con la creación de entidades, sesiones y pruebas de los componentes EJB. Finalmente
Este documento describe los diferentes elementos y acciones JSP que permiten insertar código Java, incluir otros archivos, definir beans y manipular sus propiedades, redirigir peticiones y más. Algunos de los elementos clave son <jsp:expression> para mostrar el resultado de una expresión, <jsp:scriptlet> para insertar código Java, <jsp:include> para incluir otros archivos, y <jsp:useBean> para definir y manipular beans Java.
El documento describe las características principales del modelo Java Enterprise Edition (JEE), incluyendo las capas web, de negocios y cliente. Explica los conceptos clave de servlets, JavaServer Pages (JSP) y Enterprise JavaBeans (EJB), así como sus ciclos de vida y ejemplos de código.
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.
This document discusses Java API specifications for WebSockets (JSR 356) and JSON processing (JSR 353) in Java EE 7. It provides an overview of creating and consuming WebSocket endpoints and messages on both the client and server sides using annotations and message encoder/decoder classes. Code examples are given for defining server and client WebSocket endpoints, sending messages between endpoints, and using Java objects with WebSocket messages. The document also lists some artifacts like the Tyrus reference implementation and GlassFish promoted builds for working with these APIs.
Sesion 3. desarrollo de aplicaciones jeeHéctor Santos
Este documento cubre el desarrollo de aplicaciones Java EE. Incluye secciones sobre requisitos de aplicaciones empresariales, tecnologías de infraestructura Java EE, elementos y funciones de Java EE, arquitecturas de N capas, patrones Java EE, componentes Java EE, comunicación asíncrona, roles en el desarrollo Java EE, configuración y empaquetado de aplicaciones, y componentes web como servlets y JSP. El documento proporciona una introducción general al desarrollo de aplicaciones Java EE.
Desarrollo de aplicaciones empresariales con Java EEFernando Montaño
Este documento presenta una introducción a Java EE, incluyendo sus componentes principales como Servlets, JavaServer Faces, Enterprise JavaBeans y Java Persistence API. También describe cómo Jatun utiliza la arquitectura Java EE para desarrollar aplicaciones empresariales flexibles y escalables.
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.
1. El documento presenta un tutorial sobre JavaServer Pages (JSP). 2. Explica conceptos básicos de JSP como elementos, directivas, declaraciones y scripts. 3. También introduce conceptos relacionados como servlets y JavaBeans que se usan junto con JSP.
Este documento describe los conceptos básicos de JavaServer Pages (JSP). Explica que JSP permite incluir código Java en páginas web, y que el contenedor JSP traduce las páginas JSP a servlets Java que luego ejecuta. Describe los tres tipos principales de elementos que se pueden incluir en JSP: código, directivas y acciones. Finalmente, explica cómo insertar código Java en JSP mediante expresiones, scriptlets y declaraciones, y los objetos implícitos disponibles en JSP.
1) El documento presenta un tutorial sobre JavaServer Pages (JSP), incluyendo introducciones a JSP, servlets, JavaBeans y acceso a datos. 2) Explica los conceptos básicos de JSP como directivas, declaraciones, scripts y expresiones. 3) El tutorial está dividido en varias partes que cubren diferentes temas relacionados con el desarrollo web dinámico usando JSP.
El documento describe las páginas JSP (JavaServer Pages), que permiten combinar plantillas HTML estáticas con contenido dinámico generado por Java. Las páginas JSP se compilan automáticamente en servlets cuando se solicitan por primera vez. Ofrecen ventajas sobre los servlets al facilitar la separación de la presentación del contenido y la lógica.
Este documento describe las características principales de Java Server Pages (JSP). Los JSP combinan código HTML y código Java para separar la lógica de negocio de la presentación. El código JSP se traduce a clases Java (Servlets) que manejan las solicitudes. Los JSP ofrecen ventajas como facilidad de mantenimiento y desarrollo rápido.
Esta presentación es sobre JavaSerber Page (JSP) en la cual se detalla sus principales características.
✅ CURSOS VIRTUALES EN UDEMY
⏺ FUNDAMENTOS DE PROGRAMACIÓN: Aprende las mejores practicas
https://www.udemy.com/course/fund-java/?referralCode=59EF4456EC0F433C641E
⏺ PROGRAMACIÓN DE BASE DE DATOS ORACLE CON PL/SQL
https://www.udemy.com/course/lenguaje-plsql/?referralCode=3B8A67CA0AADFCFB930C
⏺ CURSO PROFESIONAL DE JAVA ORIENTADO A OBJETOS
https://www.udemy.com/course/java-orientado-a-objetos/?referralCode=ED949D58C79D27158E8D
⏺ PROGRAMACIÓN DE BASE DE DATOS ORACLE CON JAVA JDBC
https://www.udemy.com/course/java-jdbc-oracle/?referralCode=C518C8D3028403F7F6DF
✅ ENLACES DE INTERES
⏺ Cursos virtuales: https://gcoronelc.github.io
⏺ Canal de YouTube: https://www.youtube.com/DesarrollaSoftware
⏺ Blog: http://desarrollasoftware.com/
⏺ Contacto: gcoronelc@gmail.com
[ES] Introdución al desarrollo de aplicaciones web en javaEudris Cabrera
Este documento introduce los conceptos básicos de desarrollo web con Java, incluyendo servlets y Java Server Pages (JSP). Explica que los servlets son objetos que generan contenido dinámico y corren en un contenedor como Tomcat, mientras que las JSP permiten usar código Java en páginas web para generar contenido dinámico. También incluye demostraciones de cómo crear y desplegar servlets y JSP simples.
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.
Este documento describe las herramientas JavaServer Pages (JSP) y Java Media Framework (JMF). JSP permite crear páginas web dinámicas separando la interfaz de usuario de la lógica de la aplicación, mientras que JMF agrega funcionalidad multimedia a aplicaciones Java. También compara JSP con otras tecnologías como ASP y Servlets, y proporciona ejemplos de aplicaciones como motores de búsqueda y tiendas virtuales que pueden desarrollarse con JSP.
Este documento proporciona una introducción a las páginas JSP (JavaServer Pages). Explica que las JSP permiten combinar código HTML estático con código generado dinámicamente. Describe las ventajas de las JSP y las compara con otras tecnologías como ASP, ASP.NET y servlets. Además, explica la sintaxis básica de las JSP, incluyendo expresiones, scriptlets, declaraciones y directivas.
JSP (Java Server Pages) permite crear páginas web dinámicas mediante la ejecución de código Java en un servidor. Las páginas JSP separan la lógica de la aplicación de la presentación al traducirse a servlets antes de su ejecución. El proceso fundamental implica que un servlet procesa una petición, almacena datos en un objeto de sesión y envía la respuesta a la página JSP para su presentación al cliente.
[ES] Introducción a las Aplicaciones Web con JavaEudris Cabrera
Este documento presenta una introducción a las aplicaciones web con Java. Explica conceptos clave como el ecosistema Java, aplicaciones web, contenedores web y tecnologías como servlets, Java Server Pages y scriptlets. El objetivo es proveer una visión general de las tecnologías Java disponibles para el desarrollo de aplicaciones web, destacando las normas importantes. El documento también incluye la biografía y contactos del autor.
El documento describe los diferentes elementos que pueden contener una página JSP, incluyendo directivas, declaraciones, scriptlets, expresiones y etiquetas. Se pueden insertar código Java en una página JSP a través de expresiones, scriptlets y declaraciones. Las directivas proporcionan información al motor JSP y afectan la estructura del servlet generado.
Este documento discute los servidores y contenedores de servlets/JSP que se utilizan para crear páginas web dinámicas en Java. Describe varios contenedores como Resin, JRun y Tomcat, siendo este último el más popular y de código abierto. Explica cómo instalar un contenedor como Tomcat y crear la primera página JSP, incluyendo algunas directivas y atributos básicos.
Este documento describe las principales tecnologías para el desarrollo de aplicaciones web en Java, incluyendo servlets, JSP, JSF y JavaBeans. Explica que los servlets y JSP permiten generar contenido dinámico en el servidor y manejar peticiones HTTP, mientras que JSF simplifica el diseño de la interfaz de usuario separándola de la lógica del negocio. También describe el procesamiento de eventos en JSF y la interacción entre el cliente web y la aplicación web a través de objetos HTTPServletRequest y HTTPServletResponse
El documento presenta conceptos clave sobre programación web con Java, incluyendo arquitectura REST, métodos HTTP como GET y POST, Java Server Pages (JSP), servlets, y sockets. Explica cómo JSP permite incluir código Java en páginas web y cómo los servlets interactúan con las solicitudes de clientes y respuestas de servidores. También describe el ciclo de vida de los servlets y métodos comunes como doGet() y doPost().
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.
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.
Las páginas JSP permiten crear aplicaciones web multiplataforma mediante el uso de etiquetas Java mezcladas con código HTML/XML. El motor JSP traduce las páginas JSP a servlets de Java antes de que sean funcionales. Para usar JSP, se requiere conocimiento de HTML, Java y programación orientada a objetos.
El documento introduce la tecnología Java Server Pages (JSP), la cual permite crear páginas web dinámicas mediante la mezcla de código HTML, XML y etiquetas de Java. JSP permite separar la lógica de negocio de la presentación al ejecutarse en servidores web multiplataforma. El documento también compara JSP con ASP de Microsoft y explica brevemente los requisitos y el funcionamiento básico de JSP.
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..
La inteligencia artificial sigue evolucionando rápidamente, prometiendo transformar múltiples aspectos de la sociedad mientras plantea importantes cuestiones que requieren una cuidadosa consideración y regulación.
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.
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.
Infografia TCP/IP (Transmission Control Protocol/Internet Protocol)
Practica jsp
1. 1 de 13
Práctica 4
PROGRAMACIÓN WEB CON SERVLETS Y JSP
Tabla de contenidos
1. Introducción a JSP ..................................................................................... 2
1.1. Que es Java Server Page (JSP)? ..................................................................................................................2
1.2. Diferencias entre JSP y Servlet......................................................................................................................2
1.3. Características de JSP...................................................................................................................................2
1.4. Funcionamiento de JSP .................................................................................................................................2
2. Programando con JSP ................................................................................ 3
2.1. Tipos de construcciones JSP .........................................................................................................................3
2.2. Elementos de scriptº.......................................................................................................................................3
2.3. Directivas........................................................................................................................................................4
3. La primera página JSP................................................................................ 4
3.1. Requisitos para probar JSP...........................................................................................................................4
3.2. Objetos Implícitos...........................................................................................................................................5
3.3. Ejemplos de páginas JSP sencillas................................................................................................................6
Ejemplo de Expresiones (Expresiones.jsp) .........................................................................................................6
Ejemplo de Scriplets (Color.jsp)...........................................................................................................................6
Ejemplo de declaraciones y directiva page (Contador.jsp)..................................................................................7
Ejemplo de directiva include (Empresa.jsp).........................................................................................................7
4. Utilización de Páginas de Error .................................................................. 7
4.1. Excepciones en JSP.......................................................................................................................................7
4.2. Ejemplo de utilización de páginas de error.....................................................................................................8
5. Ejemplo completo de Servlets y JSP con acceso a datos......................... 9
5.1. Requisitos previos ..........................................................................................................................................9
5.2. Página HTML que realiza la petición al servlet ..............................................................................................9
5.3. Servlet que se encarga de actualizar la base de datos................................................................................10
5.4. Servlet que muestra los datos......................................................................................................................11
6. Utilización de JSP..................................................................................... 13
7. Ampliación de la práctica......................................................................... 13
2. 2 de 13
1. Introducción a JSP
1.1. Que es Java Server Page (JSP)?
Es una interfaz de programación de aplicaciones de servidores Web. En una página jsp se
entremezclan bloques de HTML estáticos, y HTML dinámico generados con Java que se ejecutan en el
servidor.
Una página jsp puede procesar formularios Web, acceder a bases de datos y redireccionar a otras
páginas. Las páginas jsp son transformadas a un servlet y después compiladas.
El contenedor JSP proporciona un motor que interpreta y procesa una página JSP como un servlet (en
tomcat, dicho motor se llama jasper). Al estar basadas en los servlets, las distintas peticiones a una
misma página jsp son atendidas por una única instancia del servlet.
1.2. Diferencias entre JSP y Servlet
En JSP, el código de presentación está separado de la lógica del programa, mientras que en un
servlet, el código de presentación se compila dentro de la clase.
En una página JSP el código de presentación puede ser actualizado por un diseñador web que no
conozca Java.
Los servlets se encuentran ya compilados, mientras que las páginas JSP se compilan bajo
petición, lo que hace que la ejecución del servlet sea algo más rápida (en la primera petición).
1.3. Características de JSP
Permiten separar la parte dinámica de la estática en una página web
Las páginas jsp se almacenan en el servidor en archivos con extensión .jsp.
El código JSP es java y se encierra entre: <% y %>, por ejemplo:
<H1>Hora: <%= new java.util.Date() %></H1>
La sintaxis también se puede expresar en formato XML
<jsp:xxx> ... </jsp:xxx>
En una página jsp hay varios objetos implícitos (predefinidos):
request, response, out, session, application, config, pageContext,
page y exception
Cada página JSP es compilada automáticamente hacia un servlet por el motor JSP la primera vez
que se accede a esa página.
Desde una página JSP se puede llamar a un componente JavaBean donde se puede implementar
la lógica de negocio.
1.4. Funcionamiento de JSP
Una página JSP es básicamente una página Web con HTML tradicional y código Java incrustado. La
extensión de fichero de una página JSP es ".jsp" en vez de ".html" o ".htm", y eso le indica al servidor
que esta página requiere un tratamiento especial que se conseguirá con una extensión del servidor o
un plug-in.
El servidor web comprueba si la página ha sido solicitada con anterioridad. En ese caso el servlet
correspondiente ya estará cargado en memoria. Si no es así, se notifica al motor de jsp y se generará
un servlet para la página.
3. 3 de 13
Cuando un cliente solicita una página jsp, se ejecuta en el servidor el código JSP de la página, dando
como resultado una página HTML que se fusiona con el HTML original, generando una página HTML
de respuesta que será enviada al cliente.
2. Programando con JSP
2.1. Tipos de construcciones JSP
Elementos de script:
o Permiten especificar código Java
o Encerrados entre <%= y %>, <% y %>, <%! y %>
Directivas
o Permiten controlar la estructura general del servlet
o Encerradas entre <%@ y %>
Comentarios
o Permiten insertar comentarios
o Encerrados entre <%-- y --%>
Acciones
o Permiten especificar los componentes JavaBean que va a utilizar la JSP
o Encerradas entre <jsp:xxx> y </jsp:xxx>
2.2. Elementos de scriptº
Expresiones: las expresiones permiten insertar valores Java en la salida. La sintaxis es:
<%= expresión Java %>
<jsp:expr> ... </jsp:expr>
Por ejemplo:
hora:<%= new java.util.Date() %>
Las expresiones tienen acceso a los objetos implícitos. Por ejemplo:
<%= "Método envío formulario: " + request.getMethod() %>
Ejemplo con XML:
<jsp:expr>
"Método envío formulario: " + request.getMethod()
</jsp:expr>
Scriptlets: Permiten insertar código Java directamente en la página JSP.
<% codigo Java; %>
<jsp:scriptlet> ... </jsp:scriptlet>
Por ejemplo:
<% i = 7; %>
Los scriplets tienen acceso a los objetos implícitos. Por ejemplo:
<% String str = “hola”;
out.println(str); %>
Ejemplo con XML:
<jsp:scriptlet>
String str = “hola”;
out.println(str);
</jsp:scriptlet>
4. 4 de 13
Declaraciones: Permiten definir las variables o métodos que serán utilizados en la página. No tienen
acceso a los objetos implícitos. La sintaxis es:
<%! declaración Java; %>
<jsp:decl> ... </jsp:decl>
Por ejemplo:
<%! private int i = 5; %>
<%= i %>
Ejemplo con XML:
<jsp:decl>
int i = 5;
</jsp:decl>
<jsp:expr>
“i: " + i
</jsp:expr>
2.3. Directivas
Directiva page: Permite definir uno o más atributos.
<%@ page attributo=“valor” %>
<jsp:directive.page attributo=“valor”/>
Los atributos serían:
import="paquete.clase"
contentType="MIME-Type"
isThreadSafe="true|false"
session="true|false"
buffer="sizekb|none"
autoFlush="true|false"
extends="package.class"
info="message"
errorPage="url"
isErrorPage="true|false"
nlanguage="java“
Por ejemplo:
<%@ page import=“java.util.*” %>
Ejemplo con XML:
<jsp:directive.page import=“java.util.*”/>
Directiva include: Permite incluir ficheros en la pagina JSP. Inserta el fichero en tiempo de
compilación. La sintaxis es:
<%@ include file=“url” %>
<jsp:directive.include file=“url”/>
Por ejemplo:
<%@ include file=“pagina.html” %>
Ejemplo con XML:
<jsp:directive.include file=“pagina.html”/>
3. La primera página JSP
3.1. Requisitos para probar JSP
Cualquier servidor web que soporte Servlets (Apache Tomcat 5.X, se encuentra en la dirección
http://tomcat.apache.org/)
Instalar Web Tools Platform (WTP) plugin a eclipse, o descargar la versión de eclipse que o incluye
(http://www.eclipse.org/webtools/main.php)
Poner el API de los servlets y JSP en el CLASSPATH. Si estamos trabajando con el Eclipse, es
necesario poner los como jars externos del proyecto (verificar que jsp-api y servlet-api están
incluidos como jar externos).
5. 5 de 13
3.2. Objetos Implícitos
Los objetos implícitos también son llamados variables predefinidas y se utilizan directamente, sin
crearlos. A continuación se muestra una tabla con los objetos implícitos que pueden ser utilizados
desde las páginas JSP:
La mayoría de los objetos implícitos provienen de la clase abstracta javax.servlet.jsp.PageContext.
Cuando se compila la JSP, el servlet que se obtiene, contiene la creación de estos objetos implícitos
dentro del método _jspService:
public void _jspService
( HttpServletRequest request,
HttpServletResponse response ) throws IOException, ServletException
{
PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
...
pageContext =
_jspxFactory.getPageContext(this, request, response, "", true,
8192, true);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
...
}
java.lang.Object
javax.servlet.jsp.PageContext
javax.servlet.ServletConfig
java.lang.Throwable
javax.servlet.jsp.JspWriter
javax.servlet.http.HttpServletRespon
se
javax.servlet.http.HttpServletReques
t
javax.servlet.http.HttpSession
javax.servlet.ServletContext
Tipo
pageEnvía datos al cliente
pageLa propia página JSPpage
pageEs de donde se obtienen
algunos objetos implícitos
pageConte
xt
pageRepresenta la configuración del
Servlet
config
pageInformación último errorexception
pageEnvía la salida al clienteout
requestExtrae datos del clienterequest
sessionSesión de un clientesession
applicationRepresenta el contexto en el
que se ejecutan las JSPapplication
ÁmbitoDescripciónObjeto
6. 6 de 13
3.3. Ejemplos de páginas JSP sencillas
En estos ejemplos se mostrará la utilización de las distintas construcciones JSP vistas anteriormente.
Para la realización de las pruebas crearemos un nuevo proyecto Web Dinámico llamado jsp, en el cuál
crearemos los estos ejemplos.
Ejemplo de Expresiones (Expresiones.jsp)
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Expresiones JSP</title>
</head>
<body>
<H1>Ejemplo de expresiones JSP</H1>
<UL>
<LI>Fecha actual: <%=new java.util.Date()%>
<LI>Nombre del host: <%=request.getRemoteHost()%>
<LI>ID de la sesión: <%=session.getId()%>
<LI>El parámetro es: <%=request.getParameter("nombre")%>
</UL>
</body>
</html>
Para probarlo, publicar la página en el servidor web e invocarla desde el navegador:
http://localhost:8080/jsp/Expresiones.jsp
http://localhost:8080/jsp/Expresiones.jsp?nombre=Alumnos_Felices
Ejemplo de Scriplets (Color.jsp)
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Scriptlets JSP</title>
<%
String bgColor=request.getParameter("bgColor");
boolean hayColor;
if (bgColor!=null) hayColor=true; else
{
hayColor=false;
bgColor="WHITE";
}
%>
</head>
<body BGCOLOR="<%=bgColor%>">
<H1>Ejemplo de scriptlets JSP</H1>
<%
if (hayColor) out.println("Se ha utilizado el color: " + bgColor);
else out.println("Se ha utilizado el color por defecto: WHITE");
%>
</body>
</html>
Para probarlo, publicar la página en el servidor web e invocarla desde el navegador:
http://localhost:8080/jsp/Color.jsp
http://localhost:8080/jsp/Color.jsp?bgColor=RED
7. 7 de 13
Ejemplo de declaraciones y directiva page (Contador.jsp)
<%@page import="java.util.*"%>
<%-- Esto en un comentario de JSP --%>
<%!
private int cont=0;
private Date fecha= new Date();
private String host="<I>Sin acceso previo</I>";
%>
<p>Esta página ha sido accedida <b><%= ++cont%></b> veces desde que
se inició el servidor.</p>
<p>El último acceso ha sido desde: <b><%=host%></b> con fecha
<b><%=fecha%></b></p>
<%
host=request.getRemoteHost();
fecha=new Date();
%>
Para probarlo, publicar la página en el servidor web e invocarla desde el navegador:
http://localhost:8080/jsp/Contador.jsp
Ejemplo de directiva include (Empresa.jsp)
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Ejemplo de uso de un contador incluido en un JSP</title>
</head>
<body>
<H1>Ejemplo de uso de un contador incluido en un JSP</H1>
<%@include file="Contador.jsp"%>
</body>
</html>
Para probarlo, publicar la página en el servidor web e invocarla desde el navegador:
http://localhost:8080/jsp/Empresa.jsp
4. Utilización de Páginas de Error
4.1. Excepciones en JSP
La gestión de excepciones en JSP se lleva a cabo a través del objeto exception. Para manejar las
excepciones en las JSP se deben seguir los siguientes pasos:
Escribir un Servlet, JSP u otro componente para que lance excepciones en determinadas
condiciones. Por ejemplo desde una JSP podría indicarse como:
public Object metodo() throws NullPointerException { ... }
Escribir una JSP que será la página de error usando la directiva page con isErrorPage=“true”. Es
decir que si ocurre un error en otras JSP que usen el componente, se ejecutará esta página:
<%@ page isErrorPage=“true” import=“java.util.*” %>
En la página de error usar el objeto exception para obtener información de la excepción
<%= exception.toString() %>
<% exception.printStackTrace(); %>
En las JSP que usan el componente, indicar qué página se ejecutará si se produce algún error,
mediante la directiva page, estableciendo errorPage a la página de error.
<%@ page isThreadSafe=“false” import=“java.util.*” errorPage=“error.jsp” %>
8. 8 de 13
4.2. Ejemplo de utilización de páginas de error
A continuación mostramos un ejemplo en el que intervienen dos páginas, la página que puede provocar
la excepción o lanzar el error (Division.jsp) y la página que saldrá como tratamiento de la excepción
(ErrDiv.jsp). La página Division.jsp podría quedar codificada de la siguiente forma:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Manejo de errores de JSP</title>
</head>
<body >
<%@page errorPage="ErrDiv.jsp"%>
<H1>Ejemplo de manejo de errores en JSP</H1>
<%!
private double toDouble(String value)
{
return(Double.valueOf(value).doubleValue());
}
%>
<%
double op1 = toDouble(request.getParameter("op1"));
double op2= toDouble(request.getParameter("op2"));
double res = op1/op2;
%>
<TABLE border=1>
<TR><TH></TH><TH>División</TH></TR>
<TR><TH>Operando 1: </TH><Td><%=op1%></Td></TR>
<TR><TH>Operando 2: </TH><Td><%=op2%></Td></TR>
<TR><TH>Resultado: </TH><Td><%=res%></Td></TR>
</TABLE>
</body>
</html>
La página de error ErrDiv.jsp quedaría como:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<title>Página de errores en JSP</title>
</head>
<body >
<%@page isErrorPage="true"%>
<H1>Página de errores en JSP</H1>
<P>Division.jsp ha reportado el siguiente error:
<b><%=exception%></b>
</P>
<P>El error que ha ocurrido es: <pre>
<% exception.printStackTrace(new java.io.PrintWriter(out)); %>
</pre>
</P>
</body>
</html>
Para probarlo, publicar la página en el servidor web e invocarla desde el navegador:
http://localhost:8080/jsp/Division.jsp?op1=12&op2=6
http://localhost:8080/jsp/Division.jsp?op1=12&op2=0
Para que salga la página de error, uno de los operándoos tiene que ser una letra o no pasar
parámetros:
http://localhost:8080/jsp/Division.jsp?op1=12&op2=
http://localhost:8080/jsp/Division.jsp?op1=12&op2=a
9. 9 de 13
5. Ejemplo completo de Servlets y JSP con acceso a datos
Partiendo del ejemplo de los jugadores de fútbol de la práctica anterior, vamos a desarrollar un ejemplo
en el que utilizaremos primeramente la página web Futbol.html que se ampliará para permitir votar por
un jugador. Luego esta información se procesará con un servlet intermedio Futbol.java que se va a
encargar de actualizar la tabla de Jugadores (actualizando los votos de jugadores existentes o
insertando nuevos jugadores). Por último desde este servlet se dará paso al servlet de TablaVotos para
mostrarle al cliente cómo han quedado las estadísticas de votos.
5.1. Requisitos previos
Es necesario tener disponible los ejemplos de la práctica anterior y la siguiente base de datos en
MySQL:
Se debe crear esta BD y sus tablas en MySQL con la siguiente estructura:
BDJugadores
Tabla Jugadores:
Campo Tipo
Nombre Varchar (50)
Votos Integer
Tabla Registro:
Campo Tipo
Nombre Varchar (50)
Correo Varchar (30)
Visitas Integer
La tabla de Jugadores se rellenará inicialmente con datos de algunos jugadores y se pondrán a 0 los
votos de cada uno. Por ejemplo:
Nombre Votos
Roberto Carlos 0
Raul 0
Torres 0
Ronaldinho 0
Ronaldo 0
Figo 0
Zidane 0
5.2. Página HTML que realiza la petición al servlet
La página HTML Futbol.html permitirá que un cliente introduzca su nombre y correo y pueda emitir su
voto por algún jugador de los que se visualizan. Si no le gusta ninguno, podrá añadir un nuevo jugador.
Esta página enviará su petición al servlet Futbol.java para que éste se encargue de actualizar la base
de datos. La página tendría el siguiente código:
<html>
<head>
<title>Estadísticas de Futbol</title>
</head>
<body>
<center><H1>Estadísticas de Jugadores de Futbol</H1></center>
<p align="center"><font color="#002424" size="7"><u>VOTE POR EL MEJOR
JUGADOR</u></font></p>
<p align="center"><font color="#002424" size="7"><u>DE FUTBOL DE
10. 10 de 13
2003</u></font></p>
<form action="./Futbol" method="POST" left>
<p align="left">Nombre del Visitante: <input type="text" size="20"
name="txtNombre">
eMail: <input type="text" size="20" name="txtMail"></p>
<p align="left"><input type="radio" name="R1" value="Roberto Carlos">Roberto
Carlos</p>
<p align="left"><input type="radio" name="R1" value="Raul">Raul</p>
...
<p align="left"><input type="radio" name="R1" value="Otros">Otros <input
type="text" size="20" name="txtOtros"></p>
<p align="left"><input type="submit" name="B1" value="Votar"> <input
type="reset" name="B2" value="Reset"></p>
</form>
</body>
</html>
5.3. Servlet que se encarga de actualizar la base de datos
A continuación mostramos el código del servlet Futbol.java que atenderá la petición
de Futbol.html, conectándose a la Base de Datos BDJugadores y actualizando la
tabla Jugadores. En caso del que el jugador por el que se ha votado ya se encuentre
en la tabla, se incrementará su voto en 1, si no está, se insertará el nuevo jugador y
se le pondrán sus votos a 1.
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
public class Futbol extends HttpServlet
{
private Connection con;
private Statement set;
private ResultSet rs;
String cad;
public void init(ServletConfig cfg) throws ServletException
{
String sURL="jdbc:mysql://localhost/BDJugadores";
super.init(cfg);
String userName = "root";
String password = "admin";
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
con = DriverManager.getConnection(sURL, userName, password);
System.out.println("Se ha conectado");
}
catch(Exception e)
{
System.out.println( "No se ha conectado");
}
}
public void doPost(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
{
// Obtener la sesion
HttpSession s = req.getSession(true);
// Guardar el nombre del cliente en la sesión
// para poderlo utilizar en el siguiente servlet
String nombreP=(String)req.getParameter("txtNombre");
s.putValue("nombreCliente", nombreP);
String nombre=(String)req.getParameter("R1");
if (nombre.equals("Otros"))
nombre=(String)req.getParameter("txtOtros");
boolean existe = false;
try
11. 11 de 13
{
set = con.createStatement();
rs = set.executeQuery("SELECT * FROM Jugadores");
while (rs.next())
{
cad = rs.getString("Nombre");
cad = cad.trim();
if (cad.compareTo(nombre.trim())==0)
existe = true;
}
rs.close();
set.close();
}
catch(Exception e)
{
System.out.println("No lee de la tabla");
}
try
{
set = con.createStatement();
if (existe)
set.executeUpdate( "UPDATE Jugadores SET votos=votos+1 " +
"WHERE nombre LIKE '%" + nombre + "%'");
else
set.executeUpdate( "INSERT INTO Jugadores " +
"(nombre,votos) VALUES ('" + nombre + "',1)");
rs.close();
set.close();
}
catch(Exception e)
{
System.out.println( "No inserta ni modifica la tabla");
}
// Llamada al servlet que nos visualiza
// las estadísticas de jugadores
res.sendRedirect(res.encodeRedirectURL("./TablaVotos.jsp"));
}
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
{
try{doPost(req,res);}catch (Exception e)
{
}
}
public void destroy()
{
try
{
con.close();
}
catch (Exception e)
{
}
super.destroy();
}
}
5.4. Servlet que muestra los datos
Por último tendríamos la codificación del servlet que se encarga de mostrar las estadísticas de votos al
cliente. Este es el TablaVotos.java que quedaría:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import java.sql.*;
12. 12 de 13
public class TablaVotos extends HttpServlet
{
private Connection con;
private Statement set;
private ResultSet rs;
public void init(ServletConfig cfg) throws ServletException
{
String sURL="jdbc:mysql://localhost/BDJugadores";
super.init(cfg);
String userName = "root";
String password = "admin";
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
con = DriverManager.getConnection(sURL, userName, password);
System.out.println("Se ha conectado");
}
catch(Exception e)
{
System.out.println("No se ha conectado");
}
}
public void doPost(HttpServletRequest req,HttpServletResponse res)
throws ServletException, IOException
{
HttpSession s = req.getSession(true);
//Leer el nombre del cliente de la sesión para darle las
//gracias al final
String nombreP = (String)s.getValue("nombreCliente");
PrintWriter out = res.getWriter();
res.setContentType("text/html");
out.println("<html><head><title>JDBC</title></head>");
out.println("<body><font size=10>");
out.println("<h1>Ejemplo de JDBC</h1>");
out.println("<table border=1>");
out.println("<tr><td><b>Jugador</b></td><td><b>Votos" +
"</b></td></tr>");
try
{
String nombre;
int votos;
set = con.createStatement();
rs = set.executeQuery("SELECT * FROM Jugadores");
while (rs.next())
{
nombre = rs.getString("Nombre");
votos = rs.getInt("Votos");
out.println("<tr><td>"+ nombre + "</td><td>" +
votos + "</td></tr>");
}
rs.close();
set.close();
}
catch(Exception e)
{
System.out.println("No lee de la tabla");
}
out.println("</table>");
out.println("<h3>Muchas gracias " + nombreP + " por su visita</h3>");
out.println("</form></font></body></html>");
out.close();
}
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException
{
try{doPost(req,res);}catch (Exception e){}
}
public void destroy()
{
try {con.close();}
catch (Exception e){}
super.destroy();
}
}
13. 13 de 13
6. Utilización de JSP
Convertiremos el servlet TablaVotos.java en una página JSP, puesto que es la que más se adecua, ya
que la mayor parte de su código es la confección de la pagina HTML de respuesta y quedaría mucho
más claro como página JSP que como servlet. Se llamará TablaVotos.jsp y su código sería:
<%@ page language="java" contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN"
"http://www.w3.org/TR/html4/loose.dtd">
<%@page import="java.io.*"%>
<%@page import="java.util.*"%>
<%@page import="java.sql.*"%>
<%@page import="java.util.*"%>
<html>
<head><title>JDBC</title></head>
<body><font size=10>
<h1>Ejemplo de JDBC</h1>
<table border=1>
<tr><td><b>Jugador</b></td><td><b>Votos</b></td></tr>
<%
Connection con;
Statement set;
ResultSet rs;
String sURL="jdbc:mysql://localhost/BDJugadores";
String userName = "root";
String password = "admin";
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
con = DriverManager.getConnection(sURL, userName, password);
System.out.println("Se ha conectado");
String nombre;
int votos;
set = con.createStatement();
rs = set.executeQuery("SELECT * FROM Jugadores");
while (rs.next())
{
nombre = rs.getString("Nombre");
votos = rs.getInt("Votos");
out.println("<tr><td>"+ nombre + "</td><td>" + votos
+ "</td></tr>");
}
rs.close();
set.close();
con.close();
}
catch(Exception e)
{
System.out.println("Error en acceso a BD");
}
%>
</table>
<h3>Muchas gracias por su visita</h3>
</form></font></body>
</html>
7. Ampliación de la práctica
Para culminar la práctica se debe desarrollar por parte de los estudiantes las siguientes tareas:
Crear páginas JSP para controlar los posibles errores de acceso a bases de datos.
Convertir Futbol.html en una página JSP que dinámicamente se actualice teniendo en cuenta los
nuevos jugadores que se van añadiendo. Es decir, que aparezcan los nuevos jugadores de la
misma forma que los iniciales y que se siga permitiendo añadir nuevos por medio del cuadro de
texto.