Java Empresarial v2

Java Empresarial I
Código del Curso: CY760

Versión 5.0
Guía de Estudiante
Libro 2: Java
Empresarial
IBM IT Education Services

Worldwide Certified Material
Información Sobre la Publicación
Esta publicación ha sido producida usando Microsoft Word 2000 y Microsoft PowerPoint
2000 para Windows.
Marcas Registradas
IBM ® es una marca registrada por International Business Machines Corporation.
Otras compañías, productos, y nombre de servicios pueden ser marcas registradas o

marcas de servicios de otros.
Trademarks of International Business Machines Corporation
DB2 Informix
Lotus Script Net.data
Marcas Registradas de otras Compañías
Windows, Microsoft Visual Studio Microsoft Corporation
Sybase Sybase Inc.
Edición Febrero 2008
La información contenida en este documento no ha sido sometida a ninguna prueba

formal de IBM y es distribuida básicamente “como es" sin ninguna garantía ya sea
expresa o implícita. El uso de esta información o la implementación de cualquiera de
estas técnicas es responsabilidad del comprador y dependerá de la habilidad de éste
para su evaluación e integración en el ambiente operacional del comprador. A pesar de
que cada tema ha sido revisado por IBM para su exactitud en una situación específica,
no hay garantía de obtener el mismo resultado o uno similar a éste en otra situación.
Los compradores que intenten adaptar estas técnicas a sus propios ambientes lo hacen
bajo su propio riesgo.
Copyright International Business Machines Corporation, 2008. All rights reserved.

Este documento no puede ser reproducido en su totalidad o en parte sin el previo
permiso escrito de IBM.
Instrucciones Especiales para la Impresión de este Curso:
No elimine páginas en blanco que puedan aparecer al final de cada unidad o entre
unidades. Estas páginas fueron insertadas intencionalmente.
.
Guía de Estudiante Java Empresarial I
Contenido
Volumen 3: Introducción a la Computación Empresarial y JavaBeans ........ 1
Unidad 1: Introducción a JSP............................................................................ 3
Objetivos de Aprendizaje 3
1. Visión General del JSP 4
2. Tecnología JSP 5
3. Arquitectura JSP 13
4. Acerca del Contenedor para el Servlet Generado 14
5. Ciclo de Vida JSP 16
6. Beneficios del JSP 17
7. Comparación entre JSP y ASP 18
Resumen 20
Unidad 1: Examen de Autoevaluación 21
Respuestas a la Unidad 1: Examen de Autoevaluación 23
Unidad 2: Laboratorio Introducción a JSP..................................................... 25
Ejercicios de Laboratorio 26
Unidad 3: Etiquetas JSP .................................................................................. 27
1. Tipos de Elementos JSP 28
2. Objetos Implícitos 28
3. Reglas a Seguirse Cuando se Escriben JSPs 30
4. Contenido de Plantilla 31
5. Directivas JSP 33
6. Elemento de Script 41
7. Comentarios en JSP 52
8. Resumen de la Sintaxis del Elemento JSP 53
Resumen 54
Unidad 4: Laboratorio de Etiquetas JSP ........................................................ 59
Unidad 5: Etiquetas de Acción Estándar en JSP........................................... 61
i
© Copyright IBM Corp. 2008
Los materiales del curso no pueden ser reproducidos en su
totalidad o parcialmente sin el permiso escrito previo de IBM.
Java Empresarial I Guía de Estudiante
1. Etiquetas de Acción Estándar 62
2. Usar JavaBeans en JSP 62
3. Acciones que Controlan la Inclusión y el Reenvío en Tiempo de Ejecución75
Resumen 84
Unidad 6: Lab. Etiquetas de Acción Estándar en JSP .................................. 89
Unidad 7: Escribir Etiquetas Personalizadas en JSP................................... 91
1. Vista Previa de Etiquetas Personalizadas y Librerías de Etiquetas 92
2. Componentes de una Etiqueta Personalizada 94
3. Construir una Etiqueta Personalizada Simple 94
4. Interfaz Tag y la Clase TagSupport 102
5. Asignar Atributos y Contenido de Cuerpo a las Etiquetas Personalizadas105
6. Manipular el Contenido del Cuerpo 112
Resumen 120
Unidad 8: Lab. Escribir Etiquetas JSPs Personalizadas............................. 125
ii
Volumen 3: Introducción a la
Computación Empresarial y JavaBeans
Libro 2: Java Empresarial Unidad 1: Introducción a JSP 1

Los materiales del curso no pueden ser reproducidos total o
parcialmente sin el previo permiso escrito de IBM.
Unidad 1: Introducción a JSP

Objetivos de Aprendizaje
Al final de esta unidad, ud. será capaz de:
• Explicar la tecnología JSP y sus usos en aplicaciones empresariales basadas en
la Web.
• Describir el rol de los JSPs en la arquitectura MVC.
• Discutir el uso de los JSPs y Servlets en la construcción de aplicaciones Web.
• Describir la arquitectura JSP.
• Explicar la jerarquía del Servlet generado.
• Explicar el ciclo de vida del JSP.
• Discutir los beneficios que proporciona el uso de la tecnología JSP.
• Discutir la diferencia entre JSP y ASPs.

1. Visión General del JSP

En el Volumen 2, sobre Componentes Web –1, se discutió en detalle sobre el uso de
Servlets. En este volumen se aprenderá acerca de la tecnología del lado del servidor,
llamado Java Server Page (JSP).
En un típico sitio Web, las páginas entregadas al cliente están compuestas tanto de
contenido dinámico como de contenido estático. La Figura 1.1 es una página Web que
muestra el reporte de las ventas semanales de la compañía Soluciones ABC.
August 17, 2002
Contenido
Estático
Contenido
Dinámico
Figura 1.1: Una Típica Página Web
El contenido estático de una página Web se puede generar fácilmente con las diferentes
herramientas disponibles de diseño de páginas HTML. Los Java Servlets pueden usarse
para generar el contenido dinámico. Dado que los Servlets son programas Java, es
esencial el conocimiento del lenguaje Java para escribirlos. Siempre que algún
contenido dinámico tenga que ser generado, es conveniente para un diseñador de
páginas Web que algunas de las etiquetas especiales puedan ser embebidas dentro de
las páginas HTML. Esto puede hacerse con el soporte a los scripts en el servidor, el
cual puede ejecutar los scripts marcados con etiquetas especiales. Las tecnologías de
script del lado del servidor surgen para lograr este requerimiento.
En los script del lado del servidor, algunas etiquetas especiales pueden ser embebidas
dentro de las páginas HTML. Un traductor en el lado del servidor procesa el contenido
encerrado dentro de las etiquetas especiales y genera la salida. La salida será
Unidad 1: Introducción a JSP Libro 2: Java Empresarial 4

embebida en la página HTML y enviada al navegador. Actualmente, un gran número de

tecnología de script del lado del servidor está disponible y uno de ellos es el Java
Server Page (JSP). La tecnología JSP permite los scripts del lado del servidor, donde el
contenido estático es generado usando HTML, mientras que el contenido dinámico es
generado usando código script
2. Tecnología JSP
La tecnología JSP es parte de la plataforma de solución integrada de Java para la
programación del lado del servidor y proporciona una alternativa portable a otras
tecnologías del lado del servidor, tales como CGI.
La tecnología JSP se extiende desde HTML a snippets embebidos de código Java de

forma transparente dentro de las páginas HTML. Estos bits de código Java generan
contenido dinámico, el cual es embebido dentro del contenido HTML. En esta
tecnología, los programadores de aplicación pueden embeber código Java usando
etiquetas estándar. Los diseñadores de páginas Web, también pueden utilizar etiquetas
personalizadas y componentes JavaBean en sus páginas Web para generar contenido
dinámico. Esto les permite a los diseñadores que no conocen el lenguaje Java generar
contenido dinámico en sus páginas Web.
La tecnología JSP ofrece también beneficio a los programadores de Java, ya que

provee una forma mejorada y más eficiente de escribir los Servlets. Las páginas HTML
se pueden escribir con el código Java embebido en ellos, en lugar de escribir
directamente las clases Servlets y luego generar código HTML de ellos, con la ayuda
de la tecnología JSP. El entorno de los JSP toma la página y lo compila dinámicamente,
y genera un Servlet. Siempre que un cliente solicita esa página, el Servlet que fue
generado para el código JSP es ejecutado y el resultado retornado al navegador Web.
La tecnología JSP también separa la información de presentación de la lógica de la

aplicación y determina un modelo de programación de componente reutilizable. Por lo
tanto, la tecnología JSP es una de las herramientas más poderosas y fácil de usar.
2.1 JSPs vs. Servlets
Los JSP tienen la capacidad de procesar solicitudes HTTP y generar como respuesta
contenido dinámico. Sin embargo, esto también puede ser hecho por los Servlets. La
única diferencia entre los JSPs y los Servlets es que los Servlets son escritos como
programas Java, mientras que los JSPs son documentos basados en texto que incluyen
una combinación de HTML, etiquetas JSP y código Java.
Como consecuencia, surge la pregunta ¿Por qué los JSPs son requeridos cuando
pueden usarse los Servlets para el mismo propósito?
Aunque los JSPs y los Servlets pueden usarse para resolver un problema, cada uno ha
sido designado para cumplir tareas específicas. Se ha visto que los Servlets aceptan
solicitudes del cliente, recuperan los datos requeridos interactuando con bases de datos
o JavaBeans, ejecutan la lógica de la aplicación en los datos y le dan el formato a los

datos para la presentación en el navegador, generalmente en formato HTML. Un Servlet

utiliza sentencias de impresión para presentar tanto los datos estáticos como los
dinámicos al cliente.
Existen algunas desventajas descritas a continuación, por el hecho de que los Servlets
incluyen etiquetas HTML usando sentencias de impresión, estas son:
• No se podrá obtener una vista previa de la página Web antes de la ejecución
del programa, cuando las etiquetas HTML estáticas están embebidas en el
Servlet.
• Debido a que los datos no están separados de la presentación, si hay algún
cambio en alguno de ellos, es difícil localizar las áreas donde los cambios deben
ser reflejados.
• Por cada cambio en el contenido, el Servlet tiene que ser recompilado y
recargado en el servidor Web.
• El programador de Servlet debe tener destreza en programación para desarrollar
páginas Web que generen contenido dinámico.
Los JSPs ayudan a resolver este problema de la siguiente forma:
• Debido a que los JSPs están basados en texto, un diseñador Web podrá diseñar
páginas utilizando herramientas de diseño gráfico, de esta forma podrá obtener
la apariencia de las páginas antes del momento de ejecución.
• En JSPs, las etiquetas claramente demarcan el contenido dinámico del
contenido HTML estático. De esta forma se puede localizar fácilmente el lugar
donde se ha incorporado un cambio.
• Cuando un diseñador cambia el código JSP, la página es automáticamente
recompilada por el entorno del JSP y recargada en el servidor Web.
Los desarrolladores de las aplicaciones pueden facilitar a los diseñadores, etiquetas de

estilo y componentes JavaBeans para generar contenido dinámico. De esta forma, los
diseñadores Web pueden desarrollar páginas Web complejas, incluso sin mucho
conocimiento de lenguajes de programación. Se va a presentar un ejemplo para
entender el rol de los Servlets, JSPs y los JavaBeans.

Figura 1.2: Rol de los Servlets, JSPs y JavaBeans
En el ejemplo de la Figura 1.2, el AutenticaServlet, recibe la solicitud HTTP del

cliente, interactúa con la base de datos, procesa la solicitud, formatea la respuesta y lo
presenta al cliente. Sin embargo, este Servlet tiene las siguientes desventajas:
• El Servlet combina el procesamiento de la solicitud, la lógica del negocio y la
presentación, embebiendo etiquetas HTML dentro de las sentencias de
impresión. Esto implica que el programador, quien elabora estos Servlets, debe
ser un buen programador Java así como un buen diseñador de páginas Web.
• Si debe hacerse algún cambio ya sea en el procesamiento de la solicitud, en la
presentación o en la lógica del negocio, es difícil localizar el área donde se va a
incorporar el cambio, debido a que el código requerido que realiza todo esto está
ubicado dentro del mismo Servlet; si se hace algún cambio, el Servlet completo
tiene que ser recompilado y luego recargado nuevamente.
Si se utiliza JSP para la presentación, como se muestra en la Figura 1.2, se pueden
superar los problemas anteriores de la siguiente forma:
• El programador Java puede desarrollar el ValidadorServlet y el
ValidadorBean. El diseñador de páginas Web puede utilizar este bean y
diseñar la página Web dinámica para la presentación. Como consecuencia, el

programador de la aplicación no necesita conocer de diseño y el diseñador de

páginas no necesita ser un programador Java.
• Es más fácil localizar el lugar donde se han realizado los cambios, debido a que
los componentes individuales ejecutan cada una de las funciones. Si se debe
hacer un cambio en la presentación, solamente tiene que ser cambiado el JSP.
El JSP será compilado automáticamente cada vez que un requerimiento nuevo
llegue para la página.
De este modo, la tecnología JSP supera los problemas de la presentación que tienen
los Servlets. Otra ventaja de la tecnología JSP es que separa completamente el rol de
los programadores de la aplicación del rol de los diseñadores de las páginas.
La tecnología JSP no es un sustituto para los Servlets. Se trata de combinar HTML con
Java Servlet y tecnología JavaBean para crear un entorno altamente productivo para
desarrollar y desplegar sitios Web confiables, interactivo, de alto rendimiento e
independientes de la plataforma.
2.2 Elegir entre Servlets y JSP
Los Java Servlets y las tecnologías JSP son alternativas atractivas para otros tipos de
programación o script de Web dinámica. Debido a que ambas tecnologías tienen
características en común, su uso debe ser claramente definido para evitar confusiones
en el momento de elegir uno de ellos.
Para entender el uso de los Servlets y JSP, primero se planteará su rol en la

arquitectura Modelo Vista Controlador (MVC). Esto permitirá tener una visión de los
roles para los cuales cada tecnología es más apropiada.
La arquitectura MVC es un método para asignar las funcionalidades entre los

componentes, mantener y presentar los datos para minimizar el grado de acoplamiento
entre los componentes.
En la arquitectura MVC:
• El Modelo representa los datos de la aplicación junto con las reglas del negocio
que gobiernan el acceso y la modificación de los datos
• La Vista suministra el contenido del modelo. Accede a los datos desde el modelo
y especifica la forma en que los datos deben ser presentados. Cuando el modelo
cambia, es responsabilidad de la Vista mantener la consistencia en su
presentación.
• El Controlador define el comportamiento de la aplicación, interpreta las entradas
del usuario y los hace corresponder a acciones a ser realizadas por el modelo.
En aplicaciones Web, la entrada puede ser una solicitud HTTP GET o POST
desde un cliente. La acción realizada por el modelo incluye activar procesos del
negocio o cambiar el estado del modelo. El Controlador selecciona la Vista,
basándose en las acciones o solicitudes del usuario y los resultados de los
comandos del modelo, que serán presentados como parte de la respuesta a la
solicitud del usuario.

Los conceptos de la arquitectura MVC pueden hacerse corresponder directamente al

dominio de las aplicaciones empresariales basadas en la Web como se ilustra en la
Figura 1.3.
Figura 1.3: Arquitectura MVC Aplicada a los Componentes Web
El JavaBean actúa como el modelo, dado que interactúa directamente con el Sistema
de información Empresariales (EIS). Representa los datos y las reglas del negocio
asociados con la aplicación.
El Servlet actúa como un controlador e interpreta la solicitud HTTP del cliente, a su vez
Interactúa con el JavaBean para el procesamiento. El Servlet, entonces reenvía la
solicitud al JSP. Si no debe hacerse ningún procesamiento, el Servlet reenvía la
solicitud directamente al JSP.
EL JSP actúa como la vista. Accede el dato procesado desde el modelo (JavaBean), lo
formatea y lo presenta al cliente.
Cuando un patrón de diseño MVC se hace corresponder al dominio de la aplicación

Web, los Servlets fracasan directamente en el sitio como controladores y el rol de la
vista se hace corresponder en el JSP. Esto proporciona algunas indicaciones sobre
cuando los Servlets y JSPs pueden ser utilizados.
2.3 Indicaciones para Elegir entre Servlets y JSP

Los Servlets pueden ser empleados como:
• Un componente frontal para interceptar las solicitudes de los usuarios.

• Un coordinador entre otros componentes Web de la aplicación.
• Un controlador de aplicaciones Web.
• Se pueden utilizar los Servlets para procesar solicitudes y realizar el acceso a la
base de datos.

Los JSPs pueden ser empleados para:
• Formatear y presentar datos al cliente.

• Interceptar y procesar solicitudes en aplicaciones pequeñas.
• Aunque una buena práctica de diseño es dividir las funcionalidades a través de
múltiples componentes, un componente individual puede representar múltiples
roles, dependiendo del tamaño y requerimientos de la aplicación.
• En aplicaciones pequeñas, que requieren poca coordinación, los JSP pueden
jugar los roles de controlador y vista.
• Los JSPs pueden interceptar la solicitud, interactuar con el JavaBean y
presentar la respuesta al cliente como se muestra en la Figura 1.4.
Figura 1.4: JSP Realizando Procesamiento y Presentación de la Solicitud
El rol de un controlador y un modelo puede ser representado por el Servlet, como se

muestra en la Figura 1.5.
Figura 1.5 Servlet Realizando Procesamiento y Acceso a la Base de Datos
Aquí el Servlet realiza el trabajo de procesar la solicitud y acceder a la base de datos,

mientras el trabajo de la presentación de los datos la hace el JSP.
A pesar de que los roles de los Servlets y JSPs están claramente definidos, existen
ciertas tareas, tales como procesar un requerimiento e interceptar solicitudes de los
usuarios donde los Servlets y los JSPs se pueden usar de forma intercambiable.
Naturalmente, esto conduce a confusiones entre los programadores. Para evitar esta
confusión, J2EE Blueprint de Sun ofrece unas cuantas guías.

De acuerdo al J2EE Blueprint, los Servlets deben usarse estrictamente como una
tecnología de extensión del servidor Web. Esto puede incluir la implementación de
componentes de controlador especializados que ofrecen servicios, tales como
autenticación y validación en la base de datos. Se deben utilizar los Servlets para la
comunicación con los Java Applets y aplicaciones dado que los JSP solamente trabajan
con datos textuales. Por lo tanto, se deben utilizar Servlets para:
• Determinar el procesamiento necesario para satisfacer la solicitud.
• Validar la entrada.
• Trabajar con objetos de negocio para acceder a los datos y realizar el
procesamiento necesario para satisfacer la solicitud.
• Controlar el flujo a través de la aplicación Web.
Sin embargo, el J2EE Blueprint recomienda utilizar los JSPs para mostrar el contenido
generado por la aplicación Web.
El J2EE Blueprint proporciona sólo guías y no reglas. En un ambiente donde sólo la

tecnología Servlet está disponible, los Servlets pueden manejar el procesamiento de
lógica compleja, acceso a los datos y formateo de los datos en una respuesta HTML. En
un ambiente donde ambas tecnologías están disponibles, dependiendo del conjunto de
habilidades del equipo de desarrollo y la arquitectura de la aplicación, se puede utilizar
Servlets y JSPs.
Sin embargo, cuando se eligen los componentes para el desarrollo de aplicaciones

Web se debe notar que los JSPs como componentes de presentación tienen ventajas
sobre los Servlets, mientras que los Servlets son la mejor elección para controlar los
componentes.
2.4 Un JSP Ejemplo
Se presenta un ejemplo de un código JSP antes explicar la arquitectura JSP.
Ejemplo 1.1
EL código JSP comienza aquí…

1. <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01
Transitional//EN">
2. <HTML>
3. <HEAD>
4. <%@ page language="java" contentType="text/html;
charset=ISO-8859-1" pageEncoding="ISO-8859-1"
5. %>
6. <%@ page import="java.util.Date" %>
7. <TITLE>MostrarFecha.jsp</TITLE>
8. </HEAD>

9. <BODY>
10. <H4>Ejemplo Sencillo de JSP para mostrar Fecha
actual</H4>
11. <% java.text.DateFormat fechaCompleta =
12. java.text.DateFormat.getDateInstance(
13. java.text.DateFormat.LONG);
14. %>
15. En el Servidor la Fecha actual es:
<%=fechaCompleta.format(new java.util.Date())%>
16. </BODY>
17. </HTML>
El código JSP finaliza aquí.
Nota: Todos los archivos JSP tienen extensión .jsp
En este ejemplo simple se observa que un archivo JSP se parece mucho a un archivo
HTML, con pocas etiquetas de script embebidas. Estas etiquetas contienen código Java
embebidos dentro de ellos, los cuales son responsables de generar el contenido
dinámico. Las etiquetas y el código Java incluido en este ejemplo aparecen en negrita,
con la finalidad de distinguirlos del contenido HTML estático del archivo.
La respuesta generada después de la ejecución por el JSP MostrarFecha.jsp,

aparecerá en el navegador del cliente, como se muestra en la Figura 1.6.
Figura 1.6: Respuesta Enviada al Cliente por MostrarFecha.jsp
Fin del Ejemplo 1.1

3. Arquitectura JSP
Todos los servidores Web que soportan tecnología JSP deben proporcionar una
implementación JSP que este conforme con las especificaciones JSP de Sun
Microsystems. Esta implementación se denomina motor de JSP o el contenedor JSP.
Cuando la primera solicitud llega para un JSP, el JSP es trasladado a un Java Servlet.
Este Servlet resultante se invoca para manejar todas las subsiguientes solicitudes para
la página. Esto se muestra en la Figura 1.7.
Figura 1.7: Conversión de JSP a Servlet
La especificación de JSP define el lenguaje JSP y el ambiente de tiempo de ejecución,

pero no el ambiente de traducción. En otras palabras, define cómo lucirá el archivo
fuente del JSP y el ambiente de tiempo de ejecución para el Servlet generado,
incluyendo clases e interfaces. No define cómo el código fuente JSP es convertido a
Servlet, ni indica cómo el Servlet debe ser desplegado. El detalle específico de la
traducción de la página es dependiente del motor JSP, el cual proporciona la
implementación de la tecnología JSP.
La mayoría del los motores JSP toman un enfoque directo cuando traducen. Cuando
una solicitud se hace para un JSP, el motor JSP recibe una solicitud del servidor Web.
Luego el motor JSP carga el JSP del sistema de archivos y traduce el código fuente del
JSP a un Java Servlet y compila el código fuente del Servlet resultante en Java
bytecode. De allí en adelante, siempre y cuando el código fuente JSP no se modifique,
este Servlet compilado procesa cualquier solicitud del navegador para ese JSP. Si el
código fuente del JSP es modificado, automáticamente el motor JSP traduce el JSP a
un código Servlet, recompila el Servlet traducido y lo recarga para la próxima vez que
se solicite la página. Por lo tanto, el tiempo de respuesta para un JSP será alto después
de la primera invocación, es decir cuando ya ha sido traducido con relación a la primera
solicitud del cliente. La Figura 1.8 resume el proceso explicado.

Figura 1.8: Arquitectura JSP
4. Acerca del Contenedor para el Servlet Generado

De acuerdo a las especificaciones JSP (que el contenedor sigue) el Servlet generado al
final del proceso de traducción puede extenderse desde una clase que puede ser
cualquiera de las siguientes:
• Especificado por el autor del JSP a través de un atributo extends en la directiva
de la página. Esto permite a los autores de los JSP especificar sus propias súper
clases. Sin embargo, cuando se usa este atributo, privará al JSP de algunos de
los servicios provistos por el contenedor. Por lo tanto, se debe utilizar el atributo
con cautela.
• Una clase específica de un contenedor JSP que implementa la interfaz
javax.servlet.jsp.JspPage y provee algún comportamiento específico básico
de la página. En el caso del JSP donde el protocolo de comunicaciones es
HTTP, la clase de implementación debe implementar la interfaz
javax.servlet.jsp.HttpJspPage, el cual extiende a ella misma de interfaz
javax.servlet.jsp.JspPage.
La jerarquía para los Servlets generados que se extienden de la clase de

implementación específica del contenedor se muestra en la Figura 1.9.

Figura 1.9: Jerarquía de los Servlets Generados
La interfaz javax.servlet.jsp.JspPage contiene los siguientes dos métodos:

• public void jspInit(): Se invoca cuando se inicializa el JSP y es similar al método
init() en los Servlets. Los autores del JSP pueden proporcionar la inicialización
del JSP implementando este método en el JSP.
• public void jspDestroy(): Se invoca este método antes que el JSP sea destruido y
es similar al método destroy() de los Servlets. Los autores del JSP pueden
liberar cualquier recurso adquirido y ejecutar otras acciones de limpieza,
implementando este método en el JSP.
La interfaz javax.servlet.jsp.HttpJspPage contiene el siguiente método:
public void _jspService (HttpServletRequest request,
HttpServletResponse response)
Este método es similar al método service() en los Servlets y es invocado para servir
las solicitudes del cliente. El contenedor proporciona la implementación de este método
y el autor del JSP no debe implementar este método. El método _jspService() es
generado durante la traducción de la página. Cualquier expresión, scriptlets y acción
que se escriba en el JSP afecta la implementación generada del método
_jspService() de la página. Cualquier declaración JSP afecta la definición de la
clase Servlet generada.
La clase HttpJspBase proporciona implementaciones vacías para jspInit() y

jspDestroy(). Sin embargo, el método _jspService() permanece como un método
abstracto, haciendo a la clase HttpJspBase una clase abstracta. El método init()

del Servlet HttpJspBase es implementado de una forma que hace una llamada al
jspInit(). El método service() hace una llamada al _jspService() y el método
destroy() hace una llamada al método jspDestroy(). El Servlet MostrarFecha_jsp
se extiende de la clase HttpJspBase. Como el MostrarFecha.jsp no provee ninguna
implementación para los métodos jspInit() y jspDestroy(), estos dos métodos no
son implementados en el Servlet generado MostrarFecha_jsp. El método
_jspService() es implementado para generar la respuesta al cliente.
5. Ciclo de Vida JSP

Después de que un JSP es compilado en un Servlet, su ciclo de vida es similar al ciclo
de vida de un Servlet como se muestra en la Figura 1.10.
Figura 1.10: Ciclo de vida de un JSP
A continuación se discutirán cada uno de los pasos en detalle:
5.1 Crear la Instancia Servlet
Cuando un contenedor Web recibe una solicitud para un JSP, transfiere la solicitud al
motor JSP. Si es la primera vez que el JSP ha sido requerido o si la copia compilada del
JSP no se encuentra, el motor JSP genera y compila un archivo fuente Java para el
JSP. Por defecto, la sintaxis JSP en un JSP se convierte a código Java y luego se
adiciona al método _jspService() del archivo de clase generada. Una vez que el
archivo de clase Servlet es generado, el contenedor Web crea una instancia del Servlet.

5.1.1 Inicializar
Una vez que la instancia Servlet es creada, el contenedor Web llama al método init()
del Servlet, el cual a su vez invoca al método jspInit (). Por lo tanto, el autor del
JSP debe proporcionar el código de inicialización implementando el método
jspInit(). Cuando un Servlet lanza una excepción durante la inicialización, el
contenedor debe liberar la instancia Servlet y enviarlo al recolector de basura.
5.1.2 Procesar la Solicitud
Después que se completa la inicialización, el contenedor invoca al método service()

del Servlet. Este método a su vez invoca al método _jspService(), el cual genera la
respuesta al cliente. Todas las solicitudes subsecuentes para el JSP son manejadas por
la instancia del Servlet. Cuando el contenedor Web recibe una solicitud para el JSP, el
motor JSP verifica para determinar si el archivo JSP (.jsp) ha cambiado desde que
fue cargado. Si ha sido cambiado, el contenedor Web vuelve a cargar el archivo JSP
actualizado, lo que implica generar un código fuente Java actualizado y un archivo
.class para el JSP. La nueva instancia cargada del Servlet recibe la solicitud del cliente.
5.1.3 Finalizar
Cuando el contenedor Web no necesita del Servlet o una nueva instancia del Servlet
está siendo nuevamente cargada, el contenedor Web invoca al método destroy().
Este a su vez invoca al método jspDestroy(). El contenedor Web puede también
llamar al método destroy() si el motor necesita conservar los recursos o una llamada
pendiente al método service() excede el intervalo de tiempo de espera (timeout). El
JVM ejecuta al recolector de basura después de la ejecución del método destroy() .
6. Beneficios del JSP

Los beneficios del uso de los JSPs para desarrollar aplicaciones empresariales
basadas en la Web se listan a continuación:
• Separación del contenido estático del dinámico: La lógica para generar el
contenido dinámico se mantiene separada de la presentación estática
encapsulándolo dentro de componentes externos (JavaBean).
• Distribución de la carga de trabajo: El diseño de las páginas Web estáticas y
dinámicas pueden hacerla completamente los diseñadores Web. Los
programadores de aplicación pueden concentrarse únicamente en el desarrollo
de la aplicación.
• Escribir una vez y Ejecutarlo en Cualquier Parte: Es posible moverse
fácilmente entre plataformas, ya que no es necesario reescribirlo.
• La especificación JSP se construye basado en la funcionalidad de la
especificación Servlet: La especificación JSP es una extensión estándar
definida encima de los API Servlets, por lo tanto, los JSPs tienen todas las
ventajas que todos los Servlets tienen como una tecnología del lado del servidor.

• Reutilización de componentes y librerías de etiquetas: La tecnología JSP se

enfatiza en la reusabilidad de componentes, tales como JavaBeans, EJBs y
librerías de etiquetas.
• Soporte a herramientas de alta calidad: Uno de los objetivos del diseño del
JSP es permitir la creación de herramientas de desarrollo JSP tales como el
Page Designer en el Application Developer. Con herramientas de desarrollo la
creación de páginas es mucho más fácil.
• Recompilación automática: Cuando los cambios se hacen al archivo fuente de
un JSP, estos son recompilados automáticamente antes de dar servicio a las
próximas solicitudes.
• Cumple con J2EE: La arquitectura Java para desarrollar aplicaciones
empresariales multicapas es el J2EE. Como parte del J2EE, JSP tiene acceso a
todos los componentes J2EE, incluyendo JavaBeans, componentes EJBs y Java
Servlets. Debido a que los JSPs son compilados en los Servlets, tienen todos los
beneficios de estas flexibles aplicaciones Java del lado del servidor. Los
contenedores de la plataforma J2EE administran la complejidad de las
aplicaciones empresariales, incluyendo administración de transacciones y
agrupamiento de recursos (resource pooling). Los JSPs tienen acceso a todos
los servicios estándar J2EE, incluyendo Java Naming y Directory service, JDBC,
JavaMail y Java Message Service (JMS).
7. Comparación entre JSP y ASP

Una vez visto los beneficios del JSP, es posible determinar los pro y contra de la
tecnología de la principal competencia, Microsoft’s Active Server Pages (ASP). ASP es
tecnología script del lado del servidor de Microsoft, diseñada para crear páginas Web
interactivas. Los JSP y ASP son bastante similares, ya que ellos soportan la creación de
páginas Web dinámicas utilizando plantillas HTML, código script y componentes para la
lógica del negocio. Sin embargo, existen algunas diferencias entre ellos. Estas
diferencias son tan significativas como lo son las similitudes. El análisis se enfoca en las
áreas principales que conciernen a un desarrollador Web y a cualquier organización que
adopta estas tecnologías como parte de su arquitectura basada completamente en la
Web.
• Independencia del Servidor y la Plataforma: La tecnología JSP está diseñada
para ser servidor web independiente de la plataforma. Se adhiere a la filosofía
Write Once Run Anywhere (Escriba Una Vez, Ejecute Donde Quiera) de la
arquitectura Java. En lugar de estar atado a una sola plataforma o vendedor, la
tecnología JSP es soportada por una amplia variedad de herramientas de
múltiples vendedores. Por otro lado, ASP se basa principalmente en la
tecnología Microsoft. La tecnología ASP está básicamente restringida a
plataformas basadas en Microsoft Windows, ya que usa los controles ActiveX
para sus componentes.
• Lenguaje de Script: La tecnología JSP utiliza Java para script, mientras que los
ASPs utilizan Microsoft VBScript o JScript. Java es un lenguaje de programación
orientado a objetos escalables, que provee más beneficios sobre lenguajes de

script basados en BASIC. Por ejemplo, Java proporciona mejor rendimiento

cuando es comparado al VBScript interpretado o al JScript. Java facilita el
trabajo de los desarrolladores también de otras formas. Así por ejemplo, Java
ayuda en la administración de memoria al proporcionar protección contra
pérdidas de memoria y errores de punteros difíciles de encontrar, que pueden
hacer que el despliegue de aplicación sea lento. Los JSPs también proporcionan
manejo robusto de las excepciones, lo cual es necesario para aplicaciones del
mundo real.
• Soporte de Etiquetas Extensibles: Aunque los ASP y JSP utilizan una
combinación de etiquetas y script para crear páginas Web dinámicas, JSP ofrece
a los desarrolladores la posibilidad de extender de las etiquetas disponibles. Los
desarrolladores JSP pueden crear librerías de etiquetas personalizadas (estas
librerías de etiquetas personalizadas serán discutidas en detalle en la unidad 7 –
Etiquetas Personalizadas en JSP). Con las etiquetas personalizadas, los
desarrolladores pueden proteger a los autores de páginas de la complejidad de
la creación lógica de la página y extender funciones clave a un mayor rango de
autores.
Tabla1.1 Resumen de la comparación entre las dos tecnologías:
JSP ASP
Servidor Web Cualquier servidor Web, Microsoft IIS o Personal
incluyendo Apache, Web Server
Netscape, WebSphere
Application Server y IIS
Plataformas Las más conocidas Microsoft Windows (El
plataformas, incluyendo el acceso a otras
Solaris Operating plataformas requieren
Environment, Microsoft productos ASP portables
Windows, Mac OS, Linux, de terceros)
y otras implementaciones
de plataformas UNIX
Componentes JavaBeans y EJB COM y DCOM
Lenguaje Script Java VBScript, Jscript
Etiquetas personalizadas Sí No
Protección de pérdida de
Sí No
la memoria
Tabla1.1: Comparación entre las Tecnologías JSP y ASP
A partir de la discusión anterior, es claro que el uso de JSPs es más beneficioso que el
uso de ASPs, tanto para desarrolladores como para las organizaciones.

Resumen
Ahora que ha completado esta unidad, Ud. debe ser capaz de:
• Explicar la tecnología JSP y sus usos en aplicaciones empresariales basadas en
Web.
• Describir el rol de los JSPs en la arquitectura MVC.
• Discutir el uso de los JSPs y los Servlets en la construcción de aplicaciones
Web.
• Describir la arquitectura JSP.
• Explicar la jerarquía del Servlet generado.
• Explicar el ciclo de vida del JPS.
• Discutir los beneficios que proporciona el uso de la tecnología JSP.
• Discutir las diferencia entre los JSPs y los ASPs.

Unidad 1: Examen de Autoevaluación

1) ¿Cuál es el lenguaje script por defecto para JSP?
a) JScript
b) VBScript
c) Java
d) Perl
2) En la arquitectura MVC, ¿cuál de los siguiente roles corresponden a los JSP?

a) Modelo (Model)
b) Vista (View)
c) Coordinador (Coordinator)
d) Controlador (Controller)
3) ¿En qué se traduce la página JSP, cuando llega una solicitud por primera vez para
un JSP?
a) JavaBean
b) Session Bean
c) Servlet
d) Entity Bean
4) ¿Cuál de las siguientes alternativas realiza la traducción de un JSP?

a) Motor Servlet
b) Contenedor Web
c) Motor JSP
d) Servidor Web
5) ¿De acuerdo a las especificaciones JSP, el Servlet generado se puede extender de

cuál de las siguientes clases?
a) La clase especificada por el autor del JSP a través de un atributo extendido
en la directiva de la página
b) La clase implementación especifica del contenedor JSP que implementa la
interfaz javax.servlet.jsp.JspBase
c) La clase implementación especifica del contenedor JSP que implementa la
interfaz javax.servlet.jsp.JspBase
d) La clase javax.servlet.jsp.HttpServlet

6) ¿Cuál de los siguientes métodos está definido en la interfaz HttpJspPage?

a) public void jspInit();
b) public void jspDestroy();
c) public void jspService();
d) public void _jspService(HttpServletRequest request,
ttpServletResponse response);
7) El J2EE Blueprint recomienda utilizar JSPs en vez de Servlets para ____________.

a) Presentación de datos dinámicos
a) Procesamiento de solicitudes
b) Acceso a bases de datos
c) Coordinar con otros componentes Web
8) ¿La especificación JSP es una extensión estándar definida por encima de cuál de
las siguientes APIs?
a) Interfaz de nombres y de directorio Java JNDI
b) JDBC API
c) JavaBeans API
d) Servlet API
9) ¿Cuál de las siguientes características es soportada en las páginas JSP?

a) Componentes reutilizables
b) Separación de la lógica del negocio y la presentación
c) Recompilación automática cuando los cambios son hechos al archivo fuente
d) Etiquetas personalizadas
10) ¿Cuáles de los siguientes métodos están definidos en la interfaz

javax.servlet.jsp.JspPage?
a) public void jspInit();
b) public void jspDestroy();
c) public void _jspService(HttpServletRequest request,
HttpServletResponse response));
d) public void jspService();

Respuestas a la Unidad 1: Examen de Autoevaluación

1) c
2) b
3) c
4) c
5) a y b
6) d
7) a
8) d
9) a, b, c y d
10) a y b

Unidad 2: Laboratorio Introducción a

JSP
Al final de esta unidad, Ud. será capaz de:
• Crear un JSP simple en un entorno RAD.
• Utilizar el Motor de Ejecución del JSP.
• Invocar un JSP simple desde el Servlet.
Libro 2: Java Empresarial Unidad 2: Laboratorio Introducción a JSP 25

Ejercicios de Laboratorio
1) Crear un proyecto Web que acepte como entrada de datos la fecha y mes de
nacimiento del usuario y los muestre asociado a su signo zodiacal usando páginas JSP.
2) Modifique el ejercicio anterior para que una vez que el usuario ingrese su fecha y
mes de nacimiento la página le indique su edad.
Unidad 2: Laboratorio Introducción a JSP Libro 2: Java Empresarial 26

Unidad 3: Etiquetas JSP

• Describir los diferentes tipos de elementos JSP.
• Discutir los diferentes objetos implícitos definidos en JSP.
• Discutir las reglas que son aplicables a todos los JSPs.
• Explicar los contenidos de las plantillas.
• Discutir la directiva page.
• Explicar como incluir otros archivos dentro de los JSPs utilizando directiva
incluye.
• Discutir cómo declarar variables y funciones en JSPs.
• Describir el proceso de escribir expresiones JSP y scriptlets.
• Explicar cómo utilizar comentarios dentro de los JSPs.
Libro 2: Java Empresarial Unidad 3: Etiquetas JSP 27

1. Tipos de Elementos JSP

En la unidad 1 – Introducción a los JSPs se discutió la tecnología JSP, su arquitectura y
beneficios. En esta unidad, se estudia con más detalle algunos elementos JSP y sus
respectivas sintaxis.
A continuación se muestran las cuatro grandes categorías de la sintaxis de los

elementos definidos por la especificación de JSP:
• Contenido de Plantillas: Todo lo que está en un archivo fuente del JSP que no
es un elemento JSP es clasificado como contenido plantilla. Esto incluye todos
los contenidos estáticos.
• Directivas: Son instrucciones colocadas en un JSP para decirle al motor JSP

como ocuparse de la construcción del JSP, por ejemplo, un archivo incluido en
un JSP.
• Elementos de Script: Las declaraciones, expresiones y scriptlets son conocidos

de forma conjunta como elementos de script. Estos se utilizan para incluir código
Java en los JSPs.
Acciones: Las acciones proporcionan funcionalidad de alto nivel a un JSP en la forma

de etiquetas personalizadas al estilo XML. Las Acciones estándar permiten a los
diseñadores de páginas crear, modificar y usar JavaBeans dentro de los JSP de los que
ellos son autores. Ellos también proveen otras funcionalidades tales como incluir
archivos y reenviar solicitudes.
Cualquier expresión, scriptlet y acción que se escribe en un JSP afecta el método

_jspService()generado durante la traducción del JSP. Las declaraciones también
afectan la definición de la clase Servlet generada.
Nota: Técnicamente, las especificaciones JSP permiten que otros lenguajes diferentes
a Java se usen como un lenguaje script. Sin embargo, actualmente el lenguaje de script
debe ser Java. En el futuro también se podrán soportar otros lenguajes.
En esta unidad, se detallará el contenido de plantillas, directivas y elementos de script.

Las Acciones serán estudiadas en la Unidad 5 – Etiquetas de Acción Estándar en JSP.
Antes de comenzar con la discusión de los diferentes elementos JSP, se debe aprender
acerca de los objetos implícitos que son predefinidos por la arquitectura JSP y algunas
reglas básicas que son aplicables a todos los JSPs.
2. Objetos Implícitos
Los objetos implícitos permiten acceder al ambiente en tiempo de ejecución y están
disponibles automáticamente para su uso dentro del JSP. Muchos de los objetos
Unidad 3: Etiquetas JSP Libro 2: Java Empresarial 28

implícitos son componentes Servlet API estándar. Esta sección proporciona una visión
general de los objetos predefinidos en un JSP.
El objeto out: Es el objeto que se escribe dentro de un flujo de salida del cliente. Es
una instancia de javax.servlet.jsp.JspWriter. La clase JspWriter es la versión
‘buffered’ de la clase java.io.PrintWriter. Los métodos usuales de la clase
java.io.PrintWriter están disponibles. La única modificación es que los métodos de
la clase JspWriter lanzan java.io.IOException . El objeto out es pocas veces
referenciado directamente por un autor del JSP. El uso más común del objeto out está
dentro de un scriptlet o es pasado como un parámetro a otro método.
Objeto request: Es un objeto Servlet estándar que encapsula la solicitud del cliente
para el JSP. El objeto es una instancia de un protocolo y una subclase especifica de
implementación de la interfaz javax.servlet.ServletRequest (Para solicitudes HTTP
es javax.servlet.http.HttpServletRequest). El objeto request proporciona el
acceso a los parámetros de la solicitud, el tipo de solicitud (GET, POST, HEAD, etc.) y
las cabeceras HTTP entrantes (cookies). Este objeto tiene el alcance de la solicitud, es
decir, el objeto está disponible a lo largo de la solicitud y está disponible para páginas
incluidas o reenviadas.
Objeto response: Es un objeto Servlet estándar que representa la respuesta del

servidor a la solicitud. Este objeto es una instancia de un protocolo y una subclase
especifica de implementación de la interfaz javax.servlet.ServletResponse (Para
solicitudes HTTP es javax.servlet.http.HttpServletResponse). El objeto
response proporciona el acceso al flujo de salida de los Servlet. También permite que
encabezados de respuesta, cookies incluidos, tipo de contenido, control de caché,
refrescar y redirección sean establecidos. Este objeto tiene alcance de página.
Objeto session: Es un objeto Servlet estándar que es una instancia de la clase

javax.servlet.http.HttpSession . El objeto session representa la sesión creada
para un cliente. Las sesiones se crean automáticamente y están disponibles para el
diseñador de páginas a través de este objeto. El diseñador de páginas puede acceder
directamente la información de la sesión a través de este objeto. El objeto session
está disponible aun cuando no exista una sesión entrante, a menos que el autor de la
página JSP tenga especificado el valor false para el atributo session en la directiva
Page (<@page…>). Este objeto tiene alcance de sesión.
Objeto pageContext: Es una instancia de la interfaz

javax.servlet.jsp.PageContext . Este objeto provee un único punto de acceso para
muchos atributos páginas y es un lugar conveniente para almacenar datos compartidos
dentro de la página. Este objeto tiene alcance de página.
Objeto config: Es un objeto Servlet estándar que es una instancia de la clase

javax.servlet.ServletConfig. Provee acceso al ServletContext y a cualquiera de
los parámetros de inicialización de Servlet.

Objeto page: Es la instancia de la clase Servlet generada durante la traducción del

JSP. Es del tipo java.lang.Object y tiene alcance de página.
Objeto application: Es un objeto Servlet estándar que representa el

ServletContext. Es una instancia de la clase javax.servlet.ServletContext y
tiene alcance de aplicación.
Objeto exception: Es una instancia de java.lang.Throwable . El objeto exception

estará presente sólo en páginas, las cuales están definidas como páginas de error,
colocando el valor verdadero para el atributo isErrorpage en la directiva page.
Contiene la excepción que causó que la solicitud fuera reenviada a la página de error.
Los objetos implícitos son locales al método _jspService() generado. Los Scriptlets y
expresiones que serán parte del método _jspService() tienen acceso a los objetos
implícitos. Sin embargo, las declaraciones no serán parte del método _jspService() y
no tendrán acceso a estos. Los objetos implícitos discutidos anteriormente se listan en
la siguiente tabla para una referencia rápida.
Objeto Clase
out javax.servlet.jsp.JspWriter
request javax.servlet.ServletRequest
response javax.servlet.ServletResponse
session javax.servlet.http.HttpSession
pageContext javax.servlet.jsp.PageContext
config javax.servlet.ServletConfig
page java.lang.Object
application javax.servlet.ServletContext
exception java.lang.Throwable
Tabla 3.1: Objetos Implícitos
3. Reglas a Seguirse Cuando se Escriben JSPs

Las siguientes son algunas de las reglas que son aplicables a todos los JSPs:
• Los elementos de script y las directivas tienen una sintaxis JSP (sintaxis <%) y
una sintaxis basada en XML
• Etiquetas JSP basadas en XML deben tener la siguiente estructura:
<jsptag nombreAtributo =”valor” >
...
</jsptag>
o

<jsptag nombreAtributo = ”valor” />

Los atributos son opcionales. Estas etiquetas pueden tener un cuerpo o pueden
ser etiquetas vacías.
• Los valores proporcionados a los atributo en las etiquetas JSP, deben aparecer
siempre entre comillas (ya sea simple o dobles comillas). Si las comillas son
parte del valor del atributo, entonces se pueden usar caracteres especiales
' y &quote;.
• Todas las etiquetas en JSP son sensibles a mayúsculas y minúsculas. Los
espacios en blanco presentes dentro del cuerpo del JSP no tienen ninguna
relevancia, pero son preservados durante la traducción del JSP a un Servlet.
• La barra inversa (\) puede ser empleada como una secuencia de escape en una
etiqueta JSP. Por ejemplo, si el carácter % es parte de la sintaxis de la etiqueta
JSP, no se puede utilizar la secuencia % si el carácter tiene que ser usado para
algún otro propósito dentro de la etiqueta JSP, en tal caso, se puede usar la
secuencia \%.
• Los objetos implícitos pueden ser utilizados directamente dentro del JSP. Los
nombres de estos objetos son sensibles a mayúsculas y minúsculas.
Una vez que se tienen claros cuáles son los objetos implícitos predefinidos y las reglas
a seguirse, se comenzará con la discusión de los elementos JSP. Primero se estudiarán
el Contenido de Plantilla.
4. Contenido de Plantilla
Realmente el contenido de plantillas no es un elemento específico de la página JSP,
sino que representa todo contenido de la página que no sea un elemento JSP real.
Considere el código para el siguiente ejemplo HolaMundo.jsp:
Ejemplo 3.1
El código JSP comienza aquí...

1. <HTML>
2. <HEAD><TITLE>Hola Mundo, Ejemplo de
JSP</TITLE></HEAD>
3. <BODY>
4. Hola Mundo.
5. </BODY>
6. </HTML>
El código JSP termina aquí
Todo lo que se muestra en el código JSP anterior es contenido de plantilla. La

especificación JSP dice que todo lo que no sea un elemento JSP real es contenido de
plantilla.
Fin del Ejemplo 3.1

Considere el HolaMundo.jsp reescrito que se muestra a continuación, el cual tiene

contenido HTML así como elementos JSP:
Ejemplo 3.2

1. <HTML>
2. <HEAD>
3. <TITLE>Hola Mundo, Ejemplo de JSP mostrando
4. la fecha actual
5. </TITLE>
6. </HEAD>
7. <BODY>
8. <% java.text.DateFormat fechaCompleta =
java.text.DateFormat.getDateInstance(
java.text.DateFormat.LONG);
9. %>
10. En el Servidor la Fecha actual es:
<%=fechaCompleta.format(new
java.util.Date())%>
11. </BODY>
12. </HTML>
El código JSP finaliza aquí
Figura 3.1: Salida del HolaMundo.jsp

En el HolaMundo.jsp presentado anteriormente, el elemento JSP usado es resaltado

en negritas. El contenido HTML completo en la página, excluyendo el elemento JSP,
constituye el contenido de plantilla.
Fin del Ejemplo 3.2
A continuación se discutirán las diferentes directivas JSP.
5. Directivas JSP
Las directivas JSP se usan para enviar mensajes al motor JSP. Por ejemplo, son
empleadas para importar paquetes Java y ser usadas dentro de la página, para incluir
los archivos y acceder a las librerías de etiqueta personalizadas. El alcance de las
directivas se extiende a los archivos JSP completos y no producen ninguna salida al
cliente.
La siguiente tabla muestra las tres principales directivas que pueden ser usadas en
JSPs:
Directiva Propósito
page Controla las propiedades del JSP
include Incluye los contenidos de un archivo dentro del JSP

en el momento de la traducción
Especificando esta directiva se proporciona una
taglib librería de etiquetas personalizadas dentro de la
página JSP.
Tabla 3.2: Directivas JSP
La sintaxis general para una directiva se muestra a continuación:

<%@ [directive] %>
o
<jsp:directive.directive [...] /> (Sintaxis basada en XML)
A continuación se discute la directiva page e include en detalle. La directiva taglib
será discutida en detalle en la Unidad 7– Etiquetas Personalizadas en JSP.
5.1 La directiva page
La directiva page proporciona instrucciones al motor JSP de cómo construir el JSP. Se

usa para definir y manipular un número de atributos dependientes de la página, que
afectan por completo el archivo JSP.
La sintaxis general para una directiva page es:

<%@ page [attributo="valor"*] %>

o
<jsp:directive.page [attributo="valor"*] />
La siguiente tabla presenta una lista de los atributos de la directiva page y el valor por
defecto para cada atributo:
Nombre del
Atributo Descripción Valor por defecto
language El valor de este atributo debe ser el Java

lenguaje de script a ser usado por el JSP.
extends Define la súper clase (nombre de clase Omitido por defecto
calificada completamente) para el Servlet
que será generado en la traducción del
JSP.
Nota: Este atributo no se debe utilizar con
cuidado, dado que cada implementación
provee su propia clase por defecto,
sobrescribir la clase por defecto puede
afectar la calidad de la implementación.
import Proporciona una lista de clases o paquetes Por defecto los
que serán importados. Si hay más de una siguientes paquetes son
clase o paquete a ser importado, deben importados:
ser separados por comas (similar a la java.lang.*,
sentencia import en Java). javax.servlet.http
.*,
javax.servlet.*,
javax.servlet.jsp.
*
Se puede agregar
cualquier paquete o tipo
que necesite ser
importado para la página.
session Indica si el objeto sesión HTTP debe estar Verdadero
disponible para el JSP
Si session=true el objeto implícito está
disponible y puede ser usado para acceder
a la session de la página. Si
session=false, el objeto session
implícito no esta disponible dentro de la
página y la página no puede participar en
la sesión HTTP.
buffer Especifica si la salida de datos debe ser 8 KB o más (dependiente
almacenada en el buffer o no. de la implementación)
autoFlush Si el valor dado para este atributo es true, Verdadero
entonces la salida del buffer será

descargada automáticamente si se llena.

Pero si el valor de este atributo es false,
cuando el buffer se llena, será lanzada una
excepción en tiempo de ejecución para
indicar una condición de desborde
(overflow).
isThreadSafe Si el valor dado al atributo es true, indica Verdadero
que el método service del Servlet
generado es un hilo seguro. Por lo tanto, el
motor JSP puede enviar al mismo tiempo
múltiples solicitudes del cliente a la página.
Si el valor es especificado como false,
entonces el Servlet generado en la
traducción del JSP implementará la
interfaz javax.servlet.Single
ThreadModel y por tanto el motor JSP
no puede enviar a la página múltiples
solicitudes de cliente al mismo tiempo.
info Una cadena que proporciona información Omitido por defecto
sobre JSP puede ser suplido como un
valor para este atributo. Durante la
traducción del JSP, el método
getServletInfo() del Servlet
generado es sobrescrito (overridden) para
retornar al String info
errorPage El valor para este atributo será la página Omitido por defecto
de error que debe ser invocada si una
excepción ocurre. La implementación de la
página atrapa la instancia del objeto
exception y lo pasa a una página de
error procesando el error.
isErrorpage Especifica si esta página actuará como Falso
una página de error que procesará las
excepciones que ocurren en otros JSPs.
contentType Define el tipo MIME (Multipurpose Internet El valor por defecto para
Mail Extension) para la respuesta MIMETYPE es
generada por el JSP. text/html
Tabla 3.3: Atributos de la Directiva Page
Un JSP puede contener cualquier número de directivas page, en cualquier orden, en

cualquier lugar en el JSP. Todas las directivas son asimiladas durante la traducción y
son aplicadas juntas a la página. Sin embargo, puede haber una sola ocurrencia de
cualquier par atributo/valor definido por la página directiva en un JSP dado. Una
excepción es el atributo import, por lo que puede haber múltiples imports.

Los siguientes ejemplos ilustran el uso de la directiva page en los JSPs.
Ejemplo 3.3
En este ejemplo se mostrará el uso de la directiva page y el código generado para las
directivas page, durante la traducción de JSP a Servlet.
A continuación se reescribe el HolaMundo.jsp para incluir la directiva page:

continuación:

1. <%@ page import="java.util.Date, java.text.DateFormat"
2. session="true" info="Programa Ejemplo que demuestra el
uso de la directiva page JSP" errorPage="Error.jsp"
isErrorPage="true"
3. isThreadSafe="false" %>
4. <HTML>
5. <HEAD>
6. <TITLE>Hola Mundo, Ejemplo de JSP mostrando
la fecha actual
7. </TITLE>
8. </HEAD>
9. <BODY>
10. <% DateFormat fechaLarga =
11. DateFormat.getDateInstance(DateFormat.LONG);
12. %>
13. En el Servidor la Fecha actual es: <%=
14. fechaLarga.format( new Date())%>
15. </BODY>
16. </HTML>
El código JSP termina aquí...
En este ejemplo, las siguientes directivas page han sido especificadas:
• import: La clase java.util.Date ha sido importada, de manera que no se

tiene para calificar completamente el nombre del paquete cuando se crea un
objeto Date.
• info: Una cadena info ha sido especificada, la cual puede ser accedida en el
Servlet generado a través del método getServletInfo().

• errorPage: Error.jsp ha sido especificado como página error para

HolaMundo.jsp. Se invocará el , Error.jsp si algun error ocurre cuando el
JSP es ejecutado.
• isErrorPage: El valor para este atributo es falso debido a que el JSP no es
una página de error.
• isThreadSafe: El valor para este atributo es falso.
A continuación se presenta el código fuente para la página error Error.jsp.

1. <%@ page isErrorPage="true" %>
2. <HTML>
3. <HEAD>
4. <TITLE>Página Error </TITLE>
5. </HEAD>
6. <BODY>
7. <H2>Ha ocurrido una Excepción</H2>
8. <TABLE border="1">
9. <TR>
10. <TH>Excepción</TH>
11. <TD><%=exception %></TD>
12. </TR>
13. <TR>
14. <TH>Mensaje</TH>
15. <TD><%=exception.getMessage() %></TD>
16. </TR>
17. </TABLE>
18. </BODY>
19. </HTML>
Note que en Error.jsp, la directiva page tiene el atributo isErrorPage

establecido en verdadero. Error.jsp es la página error para HolaMundo.jsp. Por
consiguiente, cuando ocurre alguna excepción durante la ejecución de
HolaMundo.jsp, el contenedor web pasa el objeto excepción como un atributo para
Error.jsp
Fin del Ejemplo 3.3

5.2 La Directiva include
La directiva include notifica al contenedor que incluya el contenido del archivo

nombrado en el lugar actual donde es empleada la directiva include. El archivo
especificado debe ser accesible y disponible al motor JSP. El archivo puede ser un
archivo estático como HTML o un archivo dinámico como JSP.
La directiva incluye el contenido de un archivo en el momento de traducción, análogo al

C/C++ #include . La directiva include se usa para incluir contenido reutilizable, tal
es el caso de los elementos de cabecera y pie de página dentro del JSP. La sintaxis
para una directiva include es:
<%@ include file="nombreArchivo" %>
o
<jsp:directive.include file="nombreArchivo" />
La directiva include tiene un único atributo llamado ‘file’, cuyo valor debe ser el
nombre del archivo que será incluido.
Observe un uso simple de la directiva include a través de un ejemplo.
Ejemplo 3.4
Este ejemplo ilustra el uso de la directiva include en JSP.
En este ejemplo, la página inicial de una organización llamada ‘Tears’

(PaginaCentral.jsp) incluye un archivo cabecera Cabecera.jsp , el cual muestra el
nombre de la organización y la fecha actual. Utilizando un archivo cabecera para
mostrar el nombre de la organización, se puede incluir este archivo en todas las páginas
de la aplicación Web correspondiente a esta organización, de este modo se muestra
uniformidad así como reutilización del contenido. El código fuente para
PaginaCentral.jsp se muestra a continuación:

2. Transitional//EN">
3. <%@ include file="Cabecera.jsp" %>
4. <FONT SIZE="4" COLOR="#000099"> ProVea es un
Voluntariado, que representa una organización cuyo
principal objetivo es ayudar a la preservación del
medio ambiente en toda Venezuela. La idea principal es
crear conciencia de la necesidad de preservar nuestras
playas, ríos, lagos,montañas y médanos. Necesitamos de
la ayuda de todos ustedes, así que todo aquel que desee

ayudarnos...Contáctenos a través de nuestra dirección

de correo provea_ambiente@correo.com. <BR>
5. </FONT>
6. <HR>
7. <FONT SIZE="3" COLOR="#990000"> <U>Nuestra
Dirección:</U><BR>
8. ProVea S.A.<BR>Av. Fernando Blohm 234, Chacao,
Caracas, Venezuela.
9. <BR>email: provea_ambiente@correo.com
A continuación se muestra el código fuente para la cabecera, Cabecera.jsp.

1. <%@ page import="java.text.DateFormat,java.util.*" %>
2. <HTML>
3. <HEAD><TITLE>PaginaCentral</TITLE></HEAD>
4. <BODY>
5. <TABLE>
6. <TR>
7. <TD width=200><FONT SIZE="3"
COLOR="#990000">
8. <%= DateFormat.getDateInstance(
DateFormat.LONG).format(new Date())%>
9. </FONT></TD>
10. <TD WIDTH=800 align="center">
11. <FONT SIZE="4" COLOR="#990000"> ProVea S.A
12. Organización en Pro de la Preservación
del Medio Ambiente.
13. </FONT>
14. </TD>
15. </TR>
16. </TABLE>
17. <HR>
La salida generada después de la ejecución del PaginaCentral.jsp se muestra en la

Figura 3.2.

Figura 3.2: Salida del PaginaCentral.jsp
Durante la traducción, el motor JSP analiza el archivo incluido Cabecera.jsp.

Únicamente los dos siguientes elementos JSP están presentes en Cabecera.jsp:
• La directiva page con el atributo import indica al contenedor JSP de importar
las sentencias java.text.DateFormat y java.util.*.
• La expresión JSP <%=java.text.DateFormat.getDateInstance
(java.text. DateFormat.LONG).format(new Date()).Cada vez que
una solicitud llega para el PaginaCentral.jsp, la fecha actual se muestra
como parte de la cabecera.
Por lo tanto, es claro que los archivos JSP que son incluidos en otros JSPs utilizando la
directiva include pueden tener contenido dinámico.
Es importante notar que el motor JSP analiza el contenido del archivo Cabecera.jsp
incluido durante la traducción de Cabecera.jsp. Si el archivo Cabecera.jsp es
cambiado después de la traducción de Cabecera.jsp, los cambios no serán reflejados
cuando el Cabecera.jsp se ejecuta. El Cabecera.jsp tiene que ser recompilado
para que los cambios hechos en Cabecera.jsp se reflejen. Por consiguiente, no es
aconsejable incluir archivos cuyo contenido cambia con el tiempo, usando la directiva
include.
Fin del Ejemplo 3.4

6. Elemento de Script
Los elementos JSP de script permiten las declaraciones de variables o métodos,
scriptlets (Código Java arbitrario) y expresiones Java a ser incluidos dentro de los JSPs.
Los tres tipos de elementos de script son:
Declaraciones JSP.
Expresiones JSP.
Scriptlets JSP.
A continuación se explicarán en detalle cada uno de ellos.
6.1 Declaraciones JSP
Las declaraciones JSP se utilizan para las siguientes funciones:

• Para definir variables de clase.
• Para sobrescribir los métodos de la clase base.
• Para escribir nuevos métodos.
Las declaraciones tienen un alcance de clase en el Servlet generado, de manera que
cualquier cosa definida en una declaración está disponible a lo largo del JSP para otras
declaraciones, expresiones y código. Las declaraciones no escriben nada en el flujo de
salida. La sintaxis para una declaración se muestra a continuación:
<%!declaraciones java %>
o
<jsp:declaration> declaraciones java </jsp:declaration>
6.2 Definir Nuevos Métodos y Variables de Clases
Los siguientes ejemplos ilustran la forma de definir nuevos métodos y variables de clase
usando declaraciones JSP.
Ejemplo 3.5
En este ejemplo, se emplean las declaraciones JSP para declarar una variable y un
método de clase. Se tiene un JSP llamado MostrarFechaHora.jsp, el cual posee
métodos para obtener la fecha y hora actual y la fecha y hora cuando el JSP fue
cargado.
El código MostrarFechaHora.jsp se muestra a continuación:

Transitional//EN">}

2. <%@ page import="java.text.*, java.util.*" %>

3. <%!
4. private static DateFormat formateo = new
SimpleDateFormat("d MMM yyyy HH:mm:ss
'GMT'", Locale.getDefault());
5. private static String fechaHora = aFormatoGMT(
new Date());
6. private static String obtenerFechaHora() {
7. return fechaHora;
8. }
9. private static String obtenerFechaHoraActual() {
10. return aFormatoGMT(new Date());
11. }
12. private static String aFormatoGMT(Date fecha) {
13. return formateo.format(fecha);
14. }
15. %>
16. <HTML>
17. <HEAD>
18. <TITLE>Ejemplo de Declaracion en JSP
</TITLE>
19. </HEAD>
20. <BODY>
21. <H3>Esta página fue cargada en memoria el :
22. <%=obtenerFechaHora()%><BR> La fecha y
hora actual es: =
obtenerFechaHoraActual()%></H3>
23. </BODY>
24. </HTML>
El código JSP termina aquí
En el código anterior se resalta la declaración JSP. Se sabe que cada JSP es compilado
dentro de una clase Java Servlet. Las declaraciones JSP permiten declarar nuevos
miembros para la clase. En el ejemplo se declararon dos nuevas variables de clase
llamadas formateo y fechaHora, también fueron declarados tres métodos class
obtenerFechaHora(), obtenerFechaHoraActual() y aFormatoGMT(). Luego, en el
cuerpo del JSP, se referencian las nuevas funciones. A continuación, en la Figura 3.3 se

muestra la salida de datos generado después de la ejecución de

MostrarFechaHora.jsp.
Figura 3.3: Salida de MostrarHora.jsp
Cuando el JSP se invoca por primera vez, las variables ya llegan inicializadas. El
método obtenerFechaHora() se invoca en el cuerpo del JSP, y retorna el valor
almacenado en la variable fechaHora. Como consecuencia, para todas las solicitudes
para este JSP, se mostrará en el cliente la fecha y hora que primero fue cargado el JSP.
Este JSP también muestra la fecha y hora actual, esto se muestra en la Figura 3.2.
Fin del Ejemplo 3.5
A continuación se presenta cómo implementar los métodos jspInit() y

jspDestroy() usando las declaraciones JSP.
6.2.1 Sobrescribir jspInit() y jspDestroy()
Como ya se discutió en la Unidad 1– Introducción al JSP en la sección de ciclo de vida

de un JSP, el método jspInit() será llamado antes que la página sea requerida para
dar servicio a alguna solicitud. Por lo tanto, el autor del JSP deberá proporcionar el
código de inicialización implementando el método jspInit(). El método
jspDestroy() es invocado antes que el JSP sea removido del servicio. Por
consiguiente, el autor del JSP deberá implementar este método para proveer un código
de limpieza para liberar los recursos adquiridos. La implementación de este método
deberá hacerse colocándolos dentro de la declaración JSP.
El siguiente ejemplo ilustra la sobreescritura de los métodos jspInit() y

jspDestroy().

Ejemplo 3.6
Este ejemplo es idéntico al ejemplo de la declaración JSP. El siguiente código muestra

la implementación de los métodos jspInit() y jspDestroy() para el archivo
MostrarFechaHora2.jsp.

3. <%@ page import="java.text.*, java.util.*" %>
4. <%!
5. private static DateFormat formateo;
6. private static String fechaHora;
7. private static String obtenerFechaHora() {
8. return fechaHora;
9. }
10. private static String obtenerFechaHoraActual() {
11. return aFormatoGMT(new Date());
12. }
13. private static String aFormatoGMT(Date fecha) {
14. return formateo.format(fecha);
15. }
16. public void jspInit() {
17. formateo = new SimpleDateFormat("d MMM yyyy
HH:mm:ss 'GMT'", Locale.US);
18. fechaHora = aFormatoGMT(new Date());
19. //En tiempo real el método jspInit() para abrir
20. //archivo, recursos como conexiones a bases de
//datos y a sockets
21. }
22. public void jspDestroy() {
23. formateo = null;
24. //Este método debería ser utilizado para liberar
25. //recursos
26. }
27. %>
28. <HTML>
29. <HEAD>

30. <TITLE>Ejemplo de Declaracion en JSP</TITLE>

31. </HEAD>
32. <BODY>
33. <H3>Esta página fue cargada en memoria el:
34. <%=obtenerFechaHora()%><BR>
35. La fecha y hora actual es:
36. <%=obtenerFechaHoraActual()%></H3>
37. </BODY>
38. </HTML>
A continuación, en la Figura 3.4 se muestra la salida de datos generada después de la

ejecución de MostrarFechaHora2.jsp.
Figura 3.4: Salida de MostrarHora1.jsp
Fin del Ejemplo 3.6
6.3 Expresiones JSP
Las expresiones en código Java son sentencias que resultan en un valor. Una expresión
JSP es una expresión Java que se evalúa en el momento de la solicitud (request-time),
convertida a un String y escrita en el flujo de salida. La sintaxis para una expresión
JSP es:
<%= expresión-java %>
o
<jsp:expression> expresión-java </jsp:expression>
Nota: La sintaxis de la expresión no termina con un punto y coma.

El siguiente ejemplo ilustra el uso de expresiones en JSP.
Ejemplo 3.7
En este ejemplo se ilustrará el uso de expresiones en JSP.
Considere el ejemplo Fecha.jsp. Se presenta a continuación el código fuente para

Fecha.jsp

1. <%@ page import=”java.util.Date, java.text.DateFormat”
%>
2. <HTML>
3. <HEAD>
4. <TITLE>Fecha.jsp</TITLE>
5. </HEAD>
6. <BODY>
7. <H4>Ejemplo de JSP para mostrar la fecha en el
Servidor</H4>
8. La fecha del Servidor es:
9. <% DateFormat fechaCompleta =
DateFormat.getDateInstance(DateFormat.LONG);
10. %>
11. <%=fechaCompleta.format(new Date())%>
12. </BODY>
13. </HTML>
Fin del Ejemplo 3.7
A continuación se discutirá un tipo de elemento del JSP llamado Scriptlet
6.4 Scriptlet
Hasta el momento, se ha visto cómo declarar nuevos datos y miembros de funciones,

así como también cómo usar expresiones Java para crear contenido dinámico para una
página Web. Sin embargo, surge la pregunta ¿Cómo agregar flujo lógico como ciclos y
bifurcaciones en la página Web?. ¿Será posible realizar todas esas funciones con
scriptlets?
Los scriptlets, como su nombre indica, son un conjunto de sentencias escritas en Java.
Múltiples scriptlets son combinadas y colocadas en el método _jspService() del
Servlet generado. El orden en el que son colocados en el método _jspService() será

el mismo que en el JSP. Como ellos forman parte del método _jspService(), los
scriplets son procesados para cada solicitud hecha por el JSP.
A continuación se muestra la sintaxis para los scriptlets:

<% sentencias java %>
o
<jsp:scriptlet>sentencias java</jsp:scriptlet>
El siguiente ejemplo ilustra el uso de scriptlets en JSP.
Ejemplo 3.8
En este ejemplo, la página HTML Calculador.html suministra al cliente un

formulario donde ingresar los operandos y la operación. Al momento de enviar el
formulario se invoca el Resultado.jsp. Esto muestra el resultado a los clientes.
A continuación se muestra el código fuente para Calculador.html:
El código HTML comienza aquí...

3. <HTML>
4. <HEAD>
5. <TITLE>Calculadora Simple</TITLE>
6. </HEAD>
7. <BODY>
8. <FORM METHOD=POST ACTION="Resultado.jsp">
9. <TABLE border="1" align="center">
10. <TR>
11. <TH colspan="2">Calculadora Simple</TH>
12. </TR>
13. <TR>
14. <TH align="left">Primer Operando:</TH>
15. <TD><INPUT TYPE="text" NAME="ope1"></TD>
16. </TR>
17. <TR>
18. <TH align="left">Segundo Operando:</TH>
20. </TR>
21. <TR>

22. <TH align="left">Operacion</TH>

23. <TD><INPUT TYPE="radio" checked
NAME="operacion"
24. value="Adicion">Adicion<BR>
25. <INPUT TYPE="radio" NAME="operacion"
26. value="Subtraccion">Subtracción<BR>
28. value="Multiplicacion">Multiplicacion<BR>
30. value="Division">Division<BR>
32. value="Modulo">Modulo<BR>
33. </TD>
34. </TR>
35. <TR>
36. <TD align="center" colspan="2">
37. <INPUT TYPE="submit" value="Calcular"></TD>
38. </TR>
39. </TABLE>
40. </FORM>
41. </BODY>
42. </HTML>
El código HTML finaliza aquí.
El código fuente para Resultado.jsp se muestra a continuación:

3. <HTML>
4. <HEAD>
5. <TITLE>Pagina Resultados</TITLE>
6. </HEAD>
7. <BODY>
8. <% int op1 = 0;
9. int op2 = 0;
10. int resultado = 0;
11. String operando1 = request.getParameter("ope1");

12. String operando2 = request.getParameter("ope2");

13. String oper = request.getParameter("operacion");
14. %>
15. <CENTER>
16. <H3>Resultado:</H3>
17. </CENTER>
18. <% if((operando1 != null)&& (operando1.trim().length()
!= 0))
19. op1 = Integer.parseInt(operando1);
20. if((operando2 != null) &&
(operando2.trim().length() != 0))
21. op2 = Integer.parseInt(operando2);
22. if (oper.equals("Adicion")) {
23. resultado = op1 + op2;
24. } else if (oper.equals("Subtraccion")) {
25. resultado = op1 - op2;
26. } else if (oper.equals("Multiplicacion")) {
27. resultado = op1 * op2;
28. } else if (oper.equals("Division")) {
29. resultado = op1 / op2;
30. } else if (oper.equals("Modulo")) {
31. resultado = op1 % op2;
32. }
33. %>
35. <TR>
36. <TH colspan="2">Salida de la
Operacion...</TH>
37. </TR>
38. <TR>
39. <TH>Operando #1</TH>
40. <TD><%=operando1%></TD>
41. </TR>
42. <TR>
43. <TH>Operand0 #2</TH>
44. <TD><%=operando2%></TD>
45. </TR>
46. <TR>

47. <TH>Operacion</TH>
48. <TD><%=oper%></TD>
49. </TR>
50. <TR>
51. <TH>Resultado...</TH>
52. <TD><%=resultado%></TD>
53. </TR></TABLE>
54. </BODY>
55. </HTML>
En Resultado.jsp, los scriptlets se usan para declarar las variables locales

requeridas y para escribir lógica para realizar el cálculo.
En Resultado.jsp, las variables locales requeridas para el cálculo se declaran e

inicializan utilizando los scriptlets. Luego hay una sentencia HTML y otro bloque de
código encerrado dentro de un scriptlet que ejecuta el cálculo. Cuando se usan los
scriptlets, una secuencia de sentencias Java se pueden dividir en cualquier número de
partes como sea requerida y puede ser distribuida en el JSP. Estos scriptlets serán
combinados y colocados en el método _jspService() del Servlet generado en el
mismo orden en el cual aparecen en el JSP.
Ejecución del Ejemplo.
El formulario proporcionado por Calculador.html para ingresar el detalle del cálculo

aparecerá en el navegador del cliente, como se muestra en la Figura 3.5

Figura 3.5: Página de Entrada de Datos para el Ejemplo Calculadora
El usuario proporciona los operandos, elige la operación deseada y envía el formulario

al servidor. El Resultado.jsp mostrará los resultados del calculo al cliente, el cual
aparecerá en el navegador como se muestra en al Figura 3.6.

Figura 3.6: Página de Resultado para el Ejemplo Calculadora
En esta unidad, se estudiaron las directivas JSP y elementos de script en JSPs. Antes
de concluir esta unidad, se explicará cómo incluir comentarios en JSPs.
Fin del Ejemplo 3.8
Nota: Se deben utilizar los scriptlets con moderación. Es muy fácil extralimitarse
escribiéndolos, debe recordar que a pesar de que los scriptlets permiten escribir casi
cualquier código Java dentro de un JSP, esto no se considera un buen diseño JSP. El
objetivo principal del JSP es mantener la lógica de programación separada de la
presentación. Los JSPs pueden ser, más adelante, mantenidos por los diseñadores de
páginas web que no son programadores de Java. Puede ser confuso tener muchos
scriptlets embebidos en las páginas web. Por consiguiente, se debe concentrar el
código Java en JavaBeans y etiquetas personalizadas JSP y limitar la cantidad de
código que se escribe dentro de los scriptlets.
7. Comentarios en JSP
Se pueden colocar dos tipos de comentarios dentro de los JSPs. Estos son:
Comentarios HTML.

Comentarios JSP.
El formato para comentarios HTML se muestra a continuación:
<!— Un comentario en HTML -->
Este comentario forma una parte del contenido de la plantilla al igual que cualquier otro
contenido HTML, el motor JSP lo trata como otra pieza del contenido de la plantilla y lo
pasa inalterado al flujo de salida. El navegador reconoce los comentarios de HTML y no
muestra al cliente el contenido encerrado dentro del comentario.
El formato para los comentarios para el JSP se muestra a continuación:
<%-- Un comentario JSP --%>
El motor JSP reconoce el comentario JSP y los ignora durante la traducción. Por lo
tanto, estos comentarios no aparecen en los Servlets generados. El usuario nunca verá
el comentario, ni sabrá de su existencia.
8. Resumen de la Sintaxis del Elemento JSP

Tabla 3.5 Resumen la sintaxis de los elementos JSP para una referencia rápida.
Elementos JSP <% Syntaxis%> Sintaxis XML
directiva page <%@ page attribute="valor" %> <jsp:directive.page

[attribute="valor"*] />
directiva include <%@ include <jsp:directive.include

file="nombreArchivo" %> file="nombreArchivo" />
Declaraciones <%! Declaraciones java %> <jsp:declaration>
declaraciones java
</jsp:declaration>
Expresiones <%= expresion %> <jsp:expression>
expresion java
</jsp:expression>
Scriptlet <% sentencias java %> <jsp:scriptlet>
sentencias java
</jsp:scriptlet>
Comentarios HTML  --
Comentarios JSP <%-- comentario JSP --%> --
Tabla 3.4: Resumen de los Elementos JSP con sus Sintaxis

Resumen
• Describir los diferentes tipos de elementos JSP.
• Discutir los distintos objetos implícitos definidos en JSP.
• Discutir las reglas que son aplicables a todos los JSPs.
• Explicar el contenido de las plantillas.
• Discutir la directiva page.
• Explicar cómo incluir otros archivos dentro de los JSPs utilizando la directiva
include.
• Discutir cómo declarar variables y funciones en JSPs.
• Describir el proceso de escribir expresiones JSP y scriptlets.
• Explicar cómo usar comentarios dentro de los JSPs.


1) ¿Cuál de los siguientes elementos afecta al método _jspService() generado
durante la traducción del JSP?
a) Expresiones
b) Scriptlets
c) Declaraciones
d) Acciones
2) La especificación JSP permite que otros lenguajes diferentes a Java se usen como
lenguaje de script para JSP.
a) Verdadero
b) Falso
3) ¿Cuáles son las funciones para las que se utilizan las declaraciones en JSP?
a) Para definir variables de clase
b) Para cambiar flujo de salida
c) Para sobrescribir los métodos de la clase base
d) Para escribir nuevos métodos
4) ¿Cuáles de los siguientes son objetos implícitos pre-definidos por la arquitectura

JSP?
a) page
b) out
c) in
d) config
5) ¿Cuál de las siguientes sentencias describen mejor al contenido plantilla?

a) El contenido incluido dentro de los elementos JSP
b) Contenido dinámico dentro de un JSP
c) Contenido tanto estático como dinámico dentro de un JSP
d) Cualquier cosa en un JSP que no sea parte de un elemento JSP

6) ¿Cuál de las siguientes no es una directiva JSP?

a) page
b) exclude
c) include
d) taglib
7) ¿Cuáles de los siguientes elementos JSP son agrupados en elementos de script?

a) Directivas
b) Scriptlets
c) Expresiones
d) Declaraciones
8) ¿Cuáles de los siguientes son atributos de la directiva page?

a) language
b) import
c) session
d) extends
9) La implementación de los métodos jspInit() y jspDestroy() se deben

proporcionar dentro de ________.
a) Directivas
b) Declaraciones
c) Scriptlets
d) Expresiones
10) ¿Cuáles de las siguientes sentencias son verdaderas con respecto a los comentarios
JSP?
a) El motor JSP reconoce los comentarios JSP y los ignora durante la traducción.
b) Son parte del contenido plantilla
c) No aparecen en los Servlets generados
d) Son llamados comentarios invisibles


1) a, b y d
2) a
3) a, c y d
4) a, b y d
5) d
6) b
7) b, c y d
8) a, b, c y d
9) b
10) a, c y d

Página dejada intencionalmente en blanco…..

Unidad 4: Laboratorio de Etiquetas JSP

• Escribir JSPs utilizando etiquetas JSP básicas.
• Usar la directiva page e include en los JSPs.
Libro 2: Java Empresarial Unidad 4: Laboratorio de Etiquetas JSP 59

1) Crear una aplicación web que le permita al usuario ingresar a la aplicación y le
muestre un mensaje de bienvenida.
2) Crear una aplicación web que genere un número aleatorio en el rango del 1 al 100 e
invite al usuario a adivinar el número generado.
Ejercicios de Laboratorio Opcionales

1) Crear una aplicación web que permita calcular el interés simple.
2) Crear una aplicación web que permita al usuario ingresar (login) y le muestre una
predicción interesante.
Unidad 4: Laboratorio de Etiquetas JSP Libro 2: Java Empresarial 60

Unidad 5: Etiquetas de Acción Estándar

en JSP
• Explicar las etiquetas de acción estándar y sus tipos.
• Describir cómo
la etiqueta de acción estándar <jsp:useBean>,
<jsp:setProperty> y <jsp:getProperty> trabaja con JavaBeans.
• Explicar cómo los componentes web pueden ser incluidos y reenviados
utilizando etiquetas de acción estándar <jsp:include> y <jsp:forward>.
• Describir cómo pasar parámetros al recurso referenciado <jsp:include> y
<jsp:forward> usando etiqueta de acción estándar <jsp:param>.
Libro 2: Java Empresarial Unidad 5: Etiquetas de Acción Estándar en JSP 61

1. Etiquetas de Acción Estándar

En la Unidad 3 - Etiquetas JSP, se estudió acerca de las etiquetas básicas JSP. En esta
unidad, se discutirá acerca de las etiquetas de acción estándar definidas por la
especificación JSP. Estas etiquetas de acción estándar son bastante diferentes de las
etiquetas básicas. Cada una de estas etiquetas implementa una funcionalidad que es
utilizada comúnmente por el diseñador web, por lo tanto, hace que el trabajo del
diseñador web sea más simple.
La especificación JSP enumera algunas etiquetas de acción estándar, que todos los
motores JSP deben soportar independientemente de la implementación. Las etiquetas
de acción estándar son etiquetas basadas en XML, que los autores de páginas pueden
usar para incluir archivos, reutilizar los componentes JavaBean y reenviar las solicitudes
a otros componentes web. Estas etiquetas no tienen una sintaxis equivalente a <%.
Cuando el motor JSP encuentra una etiqueta de acción estándar durante la traducción
de un JSP en un Servlet, lo reemplaza con código Java que proporciona la
implementación de la funcionalidad soportada por la etiqueta. Por lo tanto, las etiquetas
de acción estándar afectan el comportamiento en tiempo de ejecución del JSP, así
como también la respuesta enviada al cliente.
Los siguientes son tres categorías de etiquetas de Acción estándar:

• Etiquetas de acción estándar utilizando componentes JavaBeans.
• Etiquetas de acción estándar que controlan el incluir y reenviar solicitudes en
tiempo de ejecución.
• Etiquetas de acción estándar que prepara HTML para plug-in Java (Esta etiqueta
esta fuera del alcance de este curso).
En la siguiente sección se discute cada una de estas categorías al detalle.
2. Usar JavaBeans en JSP

Cuando se escriben aplicaciones que invocan lógica compleja, es mejor separar la
lógica del negocio de la presentación. Para hacer esto, es una buena idea encapsular la
lógica del negocio en JavaBeans, instanciar un objeto del bean y usar este objeto dentro
del JSP.
La siguiente tabla muestra una lista de etiquetas de acción estándar asociadas con los
JavaBeans que trabajan conjuntamente para lograr esto:
Unidad 5: Etiquetas de Acción Estándar en JSP Libro 2: Java Empresarial 62

Etiquetas de Acción
Descripción
Estándar
<jsp:useBean>
Prepara un bean para ser usado dentro del
JSP
<jsp:setProperty> Determina las propiedades del bean
<jsp:getProperty>
Muestra la salida del valor de la propiedad
bean como un string.
Tabla 5.1: Etiquetas de Acción Asociadas con los JavaBeans
A continuación se explicarán en detalle cada una de las etiquetas de acción estándar.
2.1 Etiquetas de Acción Estándar <jsp:useBean>
La etiqueta de acción estándar <jsp:useBean> se puede usar para crear una nueva
instancia bean y asignarlo a una variable. También puede usarse para localizar la
instancia bean que ya se ha creado. Cuando la etiqueta se usa en el código, primero
intenta localizar si la instancia bean existe, si no lo encuentra, entonces crea una nueva
instancia bean y le asigna una variable a éste.
La sintaxis para la etiqueta de acción estándar <jsp:useBean> es como sigue:

<jsp:useBean id="nombre" scope="Alcance-Bean" Especificación-Bean/>
también se puede escribir de la siguiente forma:
<jsp:useBean id="nombre" scope="Alcance-Bean " Especificación-Bean/ >
<jsp:setProperty name="nombreBean" ExpresiónPropiedad />
...
</jsp:useBean>
La Tabla 5.2 muestra una lista de todos los atributos válidos del <jsp:useBean> junto
con sus descripciones.

Atributo Descripción
id
Nombre de la variable que contendrá la instancia del
bean.
scope
El alcance de disponibilidad de la instancia del
bean.Indica el contexto en el que el bean debería estar
disponible. Hay cuatro posibles valores: page (por
defecto), request, session y application. Especificación
del Bean
class
Nombre de la clase bean (debería ser un nombre de clase
completamente calificado).
beanName
El nombre del bean debe ser especificado en el formato
que debe pasarse al método instantiate () de la clase
java.beans.Beans. El beanName puede ser un una
expresión JSP, cuyo valor es calculado al momento de la
solicitud (request time).
type
El tipo usado por el bean dentro de la página. El tipo debe
ser uno de los siguientes:
La clase bean.
Una súper clase de la clase bean.
Una interfaz implementada por el bean.
Tabla 5.2: Atributos de la Etiqueta <jsp:useBean>
El alcance dentro del cual la instancia bean debe estar disponible es definido usando el
atributo scope (alcance). Una vez que el bean se ha instanciado, se encontrará
disponible en el alcance definido y asociado con el id especificado.
Tabla 5.3 muestra los posibles valores para el atributo scope.
scope Duración
page
El objeto estará disponible sólo dentro de la definición
de la página JSP y será creado nuevamente para
cada nueva solicitud. Es un valor por defecto para el
atributo scope.
request
El objeto estará disponible a través de una solicitud
particular y está disponible para páginas incluidas o
reenviadas.

session
El objeto será asociado con la sesión responsable de
su creación y estará disponible por el ciclo de vida de
la sesión.
application
El objeto, es común para todas las sesiones, está
disponible hasta que la aplicación Web finalice.
Tabla 5.3: Valores Válidos para el Atributo scope
A continuación se detallarán los valores que debe proporcionar la especificación Bean,

que da el detalle acerca del bean. El valor debe ser proporcionado en cualquiera de las
siguientes combinaciones:
class="nombreClase"
class="nombreClase" type="nombreTipo"
beanName="nombreBean" type="nombreTipo"
type="nombreTipo"
2.1.1 Semántica
Cuando el motor JSP encuentra una etiqueta <jsp:useBean> durante la traducción de
un JSP, éste reemplaza la etiqueta con el correspondiente código Java. La Figura 5.1
muestra un flujograma que describe la lógica del código reemplazado.

Figura 5.1: Flujograma que Describe la Semántica del Código Generado por
<jsp:useBean>
El flujograma muestra la forma que el contenedor web intenta primero localizar la

instancia bean en el alcance dado. Si encuentra la instancia bean, lo convierte (cast) al
tipo especificado y lo asigna a la variable creada.
En el caso que el contenedor no haya podido localizar la instancia bean, intenta crear
una instancia bean. Primero verifica si la clase atributo está especificada. Si es así,
entonces se crea una instancia del bean, en caso contrario, verifica si el tipo está
especificado y convierte la instancia (cast) a ese tipo y lo asigna a la variable creada.

Si la clase atributo no es especificada, pero si se especifican el nombreBean y el

nombre del tipo, entonces instancia una instancia del bean, lo convierte al tipo
especificado y lo asigna a la variable creada. Sin embargo, si la clase atributo y
nombreBean no son tampoco especificados, el contenedor lanzará una
InstantiationException.
Es también claro, a partir del flujograma, que la etiqueta <jsp:useBean> encapsula un

gran bloque de código Java y permite a los autores de las páginas usar JavaBeans
dentro de JSPs.
Una vez familiarizados con la sintaxis y la semántica de la etiqueta <jsp:useBean>,

se estudiarán las etiquetas de Acción estándar <jsp:setProperty> y
<jsp:getProperty> que son utilizadas en combinación con <jsp:useBean>.
2.2 Etiquetas de Acción Estándar <jsp:setProperty>
Esta etiqueta se usa en combinación con la etiqueta <jsp:useBean> para establecer

las propiedades de los bean. Se usa la introspección en el bean (instrospection bean)
para acumular información relacionada a las propiedades de los bean tales como el tipo
de propiedad (simple/indexado) y los métodos de mutación (mutator) disponibles para
las propiedades.
La sintaxis para la etiqueta de acción estándar <jsp:setProperty> se muestra a

continuación:
<jsp:setProperty name="nombreBean" propertyExpressin />
El valor usado para nombreBean es el nombre que se usó para el atributo id en la
etiqueta de acción estándar <jsp:useBean>.
Considerar la siguiente sentencia <jsp:useBean>:

<jsp:useBean id = "miNombre" ... />
La etiqueta de acción estándar <jsp:setProperty> asociada con el bean miNombre se
debe escribir como sigue:
<jsp:setProperty name = "miNombre" ... />
La Tabla 5.4 muestra la lista de atributos válidos de <jsp:setProperty> junto con sus
descripciones.

name
El nombre de la instancia bean cuya propiedad tiene que ser
establecida (Este nombreBean debe estar ya definido por una
etiqueta <jsp:useBean>)
property
Nombre de la propiedad bean cuyo valor tiene que ser establecida
param
Nombre del parámetro de la solicitud cuyo valor tiene que ser
asignado a una propiedad bean deficiente.
value
Valor que tiene que ser asignado a la propiedad bean.
Tabla 5.4: Atributos de la Etiqueta <jsp:setProperty>
La Expresión property para <jsp:setProperty>, anteriormente especificada en la

sintaxis de la etiqueta, puede tomar varias formas, como se muestran a continuación en
la Tabla 5.5.
propertyExpression Descripción
property=" * "
Establece las propiedades del bean, para el cual
existen parámetros de la solicitud HTTP con el
mismo nombre. Esto es probablemente la forma
más usada de <jsp:setProperty> y se usa en
conjunción con una forma HTTP.
property="nombrePropiedad"
Establece la propiedad del bean, con el valor del
parámetro de la solicitud http, el cual tiene el
mismo nombre que la propiedad.
property="nombrePropiedad"
param="nombreParametro" Establece la propiedad especificada al valor del
parámetro de la solicitud especificado.
property="nombrePropiedad”
value="valorPropiedad" Establece la propiedad especificada al valor del
string especificado. El valor puede ser una
expresión JSP, la cual se calcula al momento de
la solicitud. Tal expresión debe usar la sintaxis
<%.
Tabla 5.5: Combinaciones Válidas para propertyExpression
Cuando las propiedades son asignadas desde una constante de string o valores de
parámetro de solicitudes, se aplican métodos de conversión Java estándar. Por

ejemplo, si la propiedad del bean es del tipo integer y el valor asignado es un String, se
usa el método java.lang.Integer.valueOf(String) para realizar la conversión.
Para propiedades indexadas, el valor asignado debe ser un arreglo.
2.3 Etiquetas de Acción Estándar <jsp:getProperty>
La etiqueta de acción estándar <jsp:getProperty> es la contraparte de la etiqueta de

acción estándar <jsp:setProperty> y se usa para acceder a las propiedades del bean. A
continuación se muestra la secuencia de las operaciones realizadas por la etiqueta:
• Acceso a los valores asociados con la propiedad.
• Convertir el valor en un string.
• Imprimir el valor de la propiedad al flujo de salida.
La sintaxis para la etiqueta de acción estándar <jsp:getProperty> se muestra a
continuación:
<jsp:getProperty name= "nombreBean" property="nombrePropiedad" />
La Tabla 5.6 muestra la lista de los atributos válidos para la etiqueta <jsp:getProperty>
junto con sus Descripciones.
name
El nombre de la instancia bean, cuya propiedad tiene que ser accedida
(El nombre bean debe estar ya definido por la etiqueta <jsp:useBean> )
property Nombre de la propiedad del bean cuyo valor tiene que ser accedido
Tabla 5.6: Atributos de la Etiqueta <jsp:getProperty>
Una vez aprendida la sintaxis de las etiquetas <jsp:useBean>, <jsp:setProperty> y

<jsp:getProperty>, se presenta un ejemplo simple el cual utiliza las tres etiquetas.
El siguiente ejemplo ilustra el uso a las etiquetas de acción estándar relacionadas al

bean:
Ejemplo 5.1
El siguiente ejemplo se usa para ilustrar el uso de las etiquetas de Acción estándar
<jsp:useBean>, <jsp:setProperty> y <jsp:getProperty> en JSP.
En la Unidad 3 - Etiquetas JSP, se analizó el ejemplo de una simple calculadora binaria.
La lógica para realizar el cálculo estaba concentrada en Resultado.jsp usando scriptlets.
Sin embargo, como uno de los principales objetivos de JSP es separar la lógica de la
presentación, se debe asegurar que el JSP no esté concentrado con código Java. En
esta sección, se reconstruirá la misma calculadora usando un CalculadorBean para la
lógica del negocio. Por lo tanto, la lógica del negocio será movida del JSP al JavaBean.
A continuación se muestra el código fuente para el Calculador.html.


Transitional//EN">
2. <HTML>
3. <HEAD>
4. <TITLE>Calculadora Simple</TITLE>
5. </HEAD>
6. <BODY>
7. <FORM METHOD=POST ACTION="Resultado.jsp">
9. <TR>
10. <TH colspan="2">Simple Calculadora</TH>
11. </TR>
12. <TR>
13. <TH align="left">Primer Operando:</TH>
15. </TR>
16. <TR>
17. <TH align="left">Segundo Operando:</TH>
19. </TR>
20. <TR>
21. <TH align="left">Operacion</TH>
22. <TD> <INPUT TYPE="radio" checked
NAME="operacion"
23. value="Adicion">Adicion<BR>
25. value="Sustracción">Sustracción<BR>
27. value="Multiplicacion">Multiplicacion<BR>
29. value="Division">Division<BR>
31. value="Modulo">Modulo<BR>
32. </TD>
33. </TR>
34. <TR>

35. <TD align="center" colspan="2">

36. <INPUT TYPE="submit" value="Calcular"></TD>
37. </TR>
38. </TABLE>
39. </FORM>
40. </BODY>
41. </HTML>
A continuación se muestra el código fuente para el CalculadorBean.
El código Java comienza aquí...

1. public class CalculadorBean {
2. private String ope1 = new String();

3. private String ope2 = new String();
4. private String sol = new String();
5. private String operacion = new String();
6. public CalculadorBean() {
7. super();
8. }
9. public String getSol() {
10. int op1 = 0;
11. int op2 = 0;
12. int solucion = 0;
13. if ((getOpe1() != null) &&
14. (getOpe1().trim().length() != 0))
15. op1 = Integer.parseInt(getOpe1());
16. if ((getOpe2() != null) &&
17. (getOpe2().trim().length() != 0))
18. op2 = Integer.parseInt(getOpe2());
19. if (getOperacion().equals("Adicion")) {
20. solucion = op1 + op2;
21. } else if
(getOperacion().equals("Sustracción")) {
22. solucion = op1 - op2;

23. } else if
(getOperacion().equals("Multiplicacion")) {
24. solucion = op1 * op2;
25. } else if
(getOperacion().equals("Division")) {
26. solucion = op1 / op2;
27. } else if (getOperacion().equals("Modulo"))
{
28. solucion = op1 % op2;
29. }
30. return new Integer(solucion).toString();
31. }
32. public String getOpe1() {
33. return ope1;
34. }
35. public String getOpe2() {
36. return ope2;
37. }
38. public String getOperacion() {
39. return operacion;
40. }
41. public void setOpe1(String string) {
42. ope1 = string;
43. }
44. public void setOpe2(String string) {
45. ope2 = string;
46. }
47. public void setOperacion(String string) {
48. operacion = string;
49. }
50. public void setSol(String string) {
51. sol = string;
52. }
53. }
El código Java finaliza aquí
A continuación se muestra el código fuente para Resultado.jsp

El código JSP comienza aquí

3. <HTML>
4. <HEAD>
5. <TITLE>Resultado.jsp</TITLE>
6. </HEAD>
7. <BODY>
8. <CENTER>
9. <H3>Resultado:</H3>
10. <jsp:useBean id="calculadora" scope="page"
11. class="volumen3.unidad5.ejemplo1.CalculadorBean">
12. </jsp:useBean>
13. <jsp:setProperty name="calculadora"
property="*"/>
14. </CENTER>
16. <TR>
17. <TH colspan="2">Salida de la
18. Operacion...</TH>
19. </TR>
20. <TR>
22. <TD>
23. <jsp:getProperty name="calculadora"
24. property="ope1"/>
25. </TD>
26. </TR>
27. <TR>
29. <TD>
31. property="ope2"/> </TD>
32. </TR>
33. <TR>
34. <TH>Operacion</TH>
35. <TD>


property="operacion"/>
37. </TD>
38. </TR>
39. <TR>
40. <TH>Resultado...</TH>
41. <TD>
43. property="sol"/>
44. </TD>
45. </TR>
46. </TABLE>
47. </BODY>
48. </HTML>
En este ejemplo la etiqueta de acción estándar <jsp:useBean> se utiliza para

instanciar un objeto de CalculadorBean y asignarla a la variable llamada calculadora.
Este objeto está disponible dentro de este JSP, ya que el alcance es especificado como
página (scope=”page”). Todos los parámetros de la solicitud pasados a
Resultado.jsp de Calculator.html son fijados a las propiedades correspondientes
del CalculadorBean usando la etiqueta de acción estándar <jsp:setProperty>.
En la etiqueta <jsp:setProperty>, el valor para el atributo name debe ser el mismo
como el valor especificado por el atributo id en la correspondiente etiqueta
<jsp:useBean>.
Las etiquetas de acción estándar <jsp:getProperty> se usan para mostrar los

operandos, la operación y la solución. Cuando el método getSol() del
CalculadorBean es invocado por la etiqueta de acción estándar
<jsp:getProperty name="calculadora" property="solucion"/>, ya
estarán establecidas las propiedades del operando1, operando2 y operación.
Por lo tanto, el método calcula la solución y la retorna. La etiqueta de acción estándar
<jsp:getProperty> muestra la solución.
La transferencia de la lógica del negocio a la clase CalculadorBean hace el JSP más

legible. El JSP, también hace más fácil el mantenimiento para los desarrolladores de las
páginas.
Fin del Ejemplo 5.1

Figura 5.2: Salida de Calculadora
3. Acciones que Controlan la Inclusión y el Reenvío en

Tiempo de Ejecución
La Tabla 5.7 enumera las etiquetas de acción que se usan para el reenvío e inclusión
de recursos en tiempo de ejecución.
Etiquetas de
Acción Descripción
Estándar
<jsp:include>
Incluye un recurso estático o dinámico en el JSP actual en el
tiempo de procesamiento de la solicitud.
<jsp:forward>
Reenvía la solicitud a un Servlet o a otro JSP o a un recurso
estático
<jsp:param>
Pasa un parámetro al recurso referenciado por la etiqueta
<jsp:include> o <jsp:forward>
Tabla 5.7: Etiquetas de Acción Estándar Usadas para la Inclusión y Reenvío en Tiempo de
Ejecución

3.1 Etiquetas de Acción Estándar <jsp:include>
La etiqueta de acción estándar <jsp:include> notifica al contenedor de incluir un

archivo en el JSP actual en el tiempo de procesamiento de la solicitud. Este archivo
debe ser accesible al contenedor. El archivo puede ser un archivo estático tal como un
archivo HTML o un archivo dinámico como un JSP.
La diferencia entre la directiva include discutida en la unidad anterior y la etiqueta de

acción estándar <jsp:include> es que la directiva inserta el archivo en el momento
que el JSP es traducido a un Servlet, mientras que la etiqueta de acción estándar
inserta el archivo en el momento que la página es pedida. Por lo tanto, mientras las
aplicaciones que usan las etiquetas de acción estándar <jsp:include> pueden no
ser tan eficientes, ellas son definitivamente flexibles. Ya que las etiquetas de acción
estándar <jsp:include> insertan dinámicamente el contenido de los archivos
incluidos en el momento de la solicitud, los archivos cuyo contenidos cambian con el
tiempo también pueden ser incluidos usando esta etiqueta.
Una página incluida tiene acceso al objeto JspWriter (objeto de salida implícita), pero
no puede establecer cookies ni cabeceras. Si se intenta algo de esto se lanzará una
excepción.
La sintaxis de la etiqueta de acción estándar <jsp:include> es como sigue:

<jsp:include page=”URL” flush=”true” />
Como alternativa se puede escribir el código que se muestra a continuación:
<jsp:include page=”URL” flush=”true” >
<jsp:param name=”nombreParametro”
value=”valorParametro” />
. . .
</jsp:include>
En la Tabla 5.8 se muestran los atributos de la etiqueta estándar <jsp:include>
page URL del recurso a ser incluido
flush Si el valor para este atributo es establecido a verdadero

(true), entonces el buffer en el flujo de salida es
descargado antes que la página sea incluida
Tabla 5.8: Atributos de la Etiqueta <jsp:include>
El siguiente ejemplo ilustra el uso de la etiqueta de acción estándar <jsp:include>

Ejemplo 5.2
En este ejemplo, se desarrolla una página de negocio de una organización llamada

Soluciones ABC. La página incluye un archivo cabecera, el cual proporciona el nombre
de la compañía, su logotipo y algunos textos dinámicos que informa a los usuarios
acerca de los últimos cursos que la organización está ofreciendo. La página también
incluye un pie de página, el cual muestra la dirección de la organización.
A continuación se muestra la fuente del código para el archivo cabecera

Cabecera.jsp.

1. <%@ page import="java.text.DateFormat,java.util.*" %>
2. <%! private DateFormat fechaCompleta;%>
3. <%
4. fechaCompleta=
DateFormat.getDateInstance(DateFormat.LONG);
5. %>
6. <HTML>
7. <HEAD><TITLE>Pagina Negocios</TITLE></HEAD>
8. <BODY>
9. <TABLE>
10. <TR>
11. <TD width=200>
12. <FONT SIZE="3" COLOR="#990000">
13. <%=fechaCompleta.format(new
Date())%>
14. </FONT>
15. </TD>
16. <TD WIDTH=800 align="center">
17. <FONT SIZE="6"
COLOR="#990000">Servicios de Soluciones ABC</FONT>
18. </TD>
19. <TD>
20. <IMG SRC="imagenes/Logo.gif"
align="right" >
21. </TD>
22. </TR>
23. </TABLE>
24. <MARQUEE>

25. <FONT SIZE="4" COLOR="#000099"><I><B>

26. Curso Interesante en el Manejo
de Linux!!! Inicia el 10 de Junio del 2007!!!Cupos
limitados…</B></I></FONT>
27. </MARQUEE><BR><HR>
Se muestra el código fuente para Pie.html.

1. <HR>
2. <FONT SIZE="" COLOR="#990000">
3. Copyright © 2007 Informacion Servicios de
Soluciones ABC <BR>
4. <U><B>Nuestra Direccion</B></U><BR>
5. Soluciones ABC,TORRE F #29-B Las
Mercedes,<BR>
6. Primer Piso Altamira<BR>
7. Telefono :45634554
8. </FONT>
9. </BODY>
10. </HTML>
El código fuente para la página principal se muestra a continuación

PaginaNegocios.jsp

1. <jsp:include page="Cabecera.jsp" flush="true" />
2. <FONT SIZE="4" COLOR="#000099">
3. Fundada en 1989 como institución que imparte la
educación en tecnologías de software, Soluciones ABC ha
crecido como organización con intereses de negocio en
el desarrollo de eduacion de software.Poseemos y
manejamos dos sedes en Venezuela – Caracas y
Valencia.<BR><BR>
4. </FONT>
5. <%@ include file="Pie.html" %>

Para el ejemplo, el archivo Encabezado.jsp muestra la última oferta de curso la cual

cambia frecuentemente. Por lo tanto, PaginaNegocios.jsp incluye
Encabezado.jsp usando la etiqueta de acción estándar <jsp:include>. Cada vez
que los cursos cambian, el autor de la página sólo debe actualizar el Encabezado.jsp
y el PaginaNegocios.jsp no se altera. Cuando una solicitud se hace para
PaginaNegocios.jsp, el contenedor incluye el procesamiento al momento de la
solicitud de Encabezado.jsp. Como consecuencia, se reflejan los cambios que se
hicieron en Encabezado.jsp después de la traducción de PaginaNegocios.jsp.
Sin embargo, Pie.jsp tiene la dirección de la compañía, que no cambia
frecuentemente. Por lo tanto, PaginaNegocios.jsp lo incluye usando la directiva
include. Cualquier cambio hecho en Pie.html después de la traducción de
PaginaNegocios.jsp será reflejado sólo si PaginaNegocios.jsp se recompila.
Nota: La directiva include se debe usar si el recurso que se incluye cambiará con poca
frecuencia, de no ser así, se debe utilizar la etiqueta de acción estándar
<jsp:include>.
La salida del PaginaNegocios.jsp aparecerá en el navegador del cliente como se

muestra en la Figura 5.3.
Figura 5.3: Salida de PaginaNegocios.jsp
Fin del Ejemplo 5.2

3.2 Etiqueta de Acción Estándar <jsp:forward>
Una vez entendido el uso de la etiqueta de acción estándar <jsp:include>, ahora

se estudia la etiqueta de acción estándar <jsp:forward>
La etiqueta de acción estándar <jsp:forward> se utiliza para reenviar la solicitud a

otro JSP, Servlet o recurso estático como una página HTM
L. El recurso para el cual la solicitud es reenviada debe pertenecer a la misma
aplicación a la que pertenece el JSP actual. La sintaxis de la etiqueta <jsp:forward>
es como sigue:
<jsp:forward page=”URL” />
También se puede hacerse como se muestra a continuación:
<jsp:forward page=”URL” >
<jsp:param name=”nombreParametro”
value=”valorParametro” />
...
</jsp:forward>
Durante la ejecución del JSP, si se encuentra la etiqueta <jsp:forward> se para la
ejecución y se limpia el buffer. Si la etiqueta <jsp:param> se ha usado para
especificar cualquier parámetro, estos parámetros son establecidos dentro del objeto
solicitado. La solicitud es finalmente reenviada a la dirección URL especificada.
Se debe garantizar que el reenvío se haga antes de acceder al objeto JspWriter

asociado con la respuesta (fuera del objeto implícito). Si se escribe alguna salida de
datos al flujo de salida, y no es enviada al buffer prontamente, la etiqueta de acción
estándar <jsp:forward> lanzará una excepción llegalStateException.
3.3 Etiqueta de Acción Estándar jsp:param
La etiqueta de Acción estándar <jsp:param> proporciona parámetros, que pueden ser

pasados a la página destino de una etiqueta de acción estándar <jsp:include> o
<jsp:forward>. Las etiquetas de acción estándar <jsp:include> y
<jsp:forward> pueden incluir etiquetas <jsp:param> que proporcionen parámetros
adicionales aparte de las solicitudes existentes.
La sintaxis para la etiqueta <jsp:param> es como sigue:

<jsp:param name="nombreParametro" value="parametroValor"
/>
La página destino (target) (página incluida o la página para la cual la solicitud es
reenviada) puede acceder tanto a los parámetros de la solicitud original como a los
nuevos parámetros especificados, utilizando la etiqueta <jsp:param> . Si al mismo

parámetro se le asigna más de un sólo valor, se mantendrán intactos los antiguos

valores, aunque los nuevos valores tengan precedencia sobre ellos.
Si un objeto solicitado, por ejemplo, tiene ya un parámetro

nombreParametro=valor1 establecido y se especifica un parámetro <jsp:param
name="nombreParametro" value="valor2" />, entonces el objeto solicitado
recibido por el JSP() incluido tendrá los valores para el parámetro nombreParametro
establecido como nombreParametro=valor2,valor1. Se puede extraer el
parámetro en la página incluida o reenviada usando el método
getParameter(String) de la interfaz ServletRequest. Si deben extraerse todos
los valores de un parámetro, se puede utilizar el método
getParameterValues(String) de la interfaz ServletRequest. Este método
retornará un arreglo que contiene todos los valores del parámetro.
Considere un ejemplo para ilustrar el uso de las etiquetas de acción estándar

<jsp:forward> y <jsp:param>
Ejemplo 5.3
En este ejemplo, existe un JSP llamado Bienvenido.jsp. Este JSP selecciona un

aviso del arreglo aleatoriamente, lo establece como un parámetro utilizando la etiqueta
de acción estándar <jsp:param> y reenvía la solicitud a PaginaCentral.jsp
usando la etiqueta de acción estándar <jsp:forward>
El código fuente para Bienvenido.jsp se muestra a continuación.

1. <%@ page import="java.util.*" %>
2. <HTML>
3. <HEAD>
4. <TITLE>Bienvenido.jsp</TITLE>
5. <%!
6. private static transient String[] anuncio =
{"Visitanos en www.ibm.com", "Conozca el mundo
tecnológico junto a nosotros"};
7. public String getAnuncio(){
8. Random r = new Random();
9. int indice = Math.abs(r.nextInt()) %
10. anuncio.length;
11. return anuncio[indice];
12. }
13. %>

14. <jsp:forward page="

PaginaCentral.jsp">
15. <jsp:param name="an" value="<%= getAnuncio()%>"/>
16. </jsp:forward>
17. </HEAD>
Durante la ejecución de Bienvenido.jsp, cuando se encuentra la etiqueta

<jsp:forward> , la ejecución de JSP se para y se limpia el buffer. Se establece el
parámetro "an" especificado usando <jsp:param> en el objeto requerido. Luego, la
solicitud es reenviada al recurso destino (target) PaginaCentral.jsp.
PaginaCentral.jsp extrae el parámetro y lo muestra como un texto desplazante. El

código fuente se muestra a continuación.

1. <HTML>
2. <HEAD><TITLE>PaginaCentral.jsp</TITLE></HEAD>
3. <BODY bgcolor="#0065CE">
4. <P align="center">
5. <MARQUEE behavior="scroll">
6. <FONT color="#ffffff" size="5">
7. <%= request.getParameter("an")%>
8. </FONT>
9. </MARQUEE>
10. </P>
11. <HR>
12. <H1 align="center">
13. <FONT color="#ffffff"
size="6">Bienvenido </FONT>
14. </H1><BR><HR>
15. <P align="center">
16. <FONT color="#ffffff" size="4">
17. Gracias por Visitarnos
18. </FONT>
19. </BODY>
20. </HTML>

3.4 Ejecución de un Ejemplo
Cuando un cliente realiza una solicitud al Bienvenido.jsp, este jsp establece el

parámetro "an" en el objeto solicitado y reenvía la solicitud a PaginaCentral.jsp. y
esta genera la respuesta que aparecerá en el navegador del cliente como se muestra
en la Figura 5.4.
Figura 5.4: Respuesta Generada por PaginaCentral.jsp
Fin del Ejemplo 5.3

Resumen
• Explicar las etiquetas de acción estándar y sus tipos.
• Describir cómo las etiquetas de acción estándar <jsp:useBean>,
<jsp:setProperty> y <jsp:getProperty> trabajan con los JavaBeans.
• Explicar cómo los componentes web se pueden incluir y reenviar usando
etiquetas de acción estándar <jsp:include> y <jsp:forward>.
• Describir cómo pasar los parámetros al recurso referenciado <jsp:include> y
<jsp:forward> usando las etiquetas de Acción estándar <jsp:param>.


1) ¿Cuál de las siguientes alternativas no es un atributo de la etiqueta de acción
estándar <jsp:useBean>?
a) id
b) type
c) className
d) beanName
2) ¿Cuáles de las siguientes alternativas son valores válidos que pueden ser asignados
al atributo scope de la etiqueta de acción estándar <jsp:useBean>?
a) page
b) session
c) response
d) request
3) La etiqueta de acción estándar <jsp:setProperty> usa ------------------------- para

descubrir las propiedades presentes en el bean.
a) Bean list
b) Property list
a) Property table
b) Bean introspection
4) La etiqueta de acción estándar <jsp:include>_________________.

a) Incluye un recurso estático en el JSP actual en el tiempo de procesamiento
de la solicitud
b) Incluye un recurso estático en el JSP actual en el tiempo de traducción
c) Incluye un recurso dinámico en el JSP actual en el tiempo de procesamiento
de la solicitud
d) Incluye un recurso dinámico en el JSP actual en el tiempo de traducción.
5) Una página incluida usando <jsp:include> ______________.

a) Puede establecer cookies
b) Puede establecer headers
c) Tiene acceso al objeto JspWriter
d) No tiene acceso al objeto JspWriter

6) Si el flujo de salida no fue llevado al buffer y si alguna salida se ha escrito al flujo de

salida, entonces la etiqueta de acción estándar lanzará ______________.
a) IllegalAccessException
b) StreamCorruptedException
c) IllegalStateException
d) OutputStreamCorruptedException
7) Cuando se especifica un parámetro al <jsp:forward> utilizando una etiqueta

<jsp:param>, si el nombre del parámetro es el mismo al de un parámetro que ya
existe para el objeto solicitado, entonces:
a) Se mantienen intactos los valores anteriores, pero los nuevos valores toman
precedencia sobre los viejos.
b) Los antiguos valores son descartados y se asigna al parámetro.
c) Se mantiene intacto el antiguo valor y se descarta el nuevo valor
d) El nuevo y antiguo valor son asignados al parámetro, pero el antiguo valor
toma precedencia sobre el nuevo valor.
8) ¿Cuál de las siguientes etiquetas de acción estándar están asociadas con

JavaBeans?
a) <jsp:useBean>
b) <jsp:param>
c) <jsp:getProperty>
d) <jsp:property>
9) Cuando el motor JSP encuentra una etiqueta <jsp:useBean> durante la traducción

de un JSP, éste reemplaza la etiqueta con el correspondiente código Java
a) Verdadero
b) Falso
10) Las etiquetas de acción estándar ______________________.

a) Tienen que ser soportadas por todos los contenedores, independientemente
de la implementación
b) Son etiquetas basadas en XML
c) Son etiquetas personalizadas
d) Son etiquetas JSP opcionales, todos los containers JSP no necesitan
soportarlos


1) c
2) a, b y d
3) d
4) a y c
5) c
6) c
7) a
8) a y c
9) a
10) a y b

Unidad 6: Lab. Etiquetas de Acción

Estándar en JSP
• Usar JavaBeans en JSPs.
• Comunicarse entre JSPs usando las etiquetas de acción include y forward.
Libro 2: Java Empresarial Unidad 6: Lab. Etiquetas de Acción Estándar en JSP 89

1) Crear una aplicación web, que acepte del usuario los detalles de un estudiante y
establezca las propiedades correspondientes del EstudianteBean. Las propiedades
establecidas en el EstudianteBean se deben recuperar y mostrar al usuario en un
formato tabular.
2) Crear los componentes web que se requieren para procesar las validaciones del
usuario.
Ejercicios Opcionales de Laboratorio

1) Crear los componentes web que se requieren para obtener del usuario los detalles de
un libro y establecer las propiedades en el LibroBean que corresponda a los detalles
del libro obtenidos del usuario. Las propiedades establecidas en el LibroBean deben
ser recuperadas y mostradas al usuario en un formato tabular.
2) Crear los componentes web que se requieran para verificar si un determinado libro
está disponible en la librería o no.
Unidad 6: Lab. Etiquetas de Acción Estándar en JSP Libro 2: Java Empresarial 90

Unidad 7: Escribir Etiquetas

Personalizadas en JSP
• Explicar la necesidad de etiquetas personalizadas.
• Discutir acerca de los componentes de una etiqueta personalizada.
• Explicar cómo escribir etiquetas personalizadas.
• Describir cómo manipular el contenido del cuerpo de etiquetas personalizadas.
Libro 2: Java Empresarial Unidad 7: Escribir Etiquetas Personalizadas en JSP 91

1. Vista Previa de Etiquetas Personalizadas y Librerías

de Etiquetas
En la Unidad 5: Acciones Estándar en JSP, se presentó una visión acerca de las
etiquetas de acción estándar que implementa el proveedor del JSP. En esta unidad se
estudiará cómo crear las etiquetas definidas por el usuario en JSP. JSP 1.1 introdujo
una característica bastante útil y práctica llamada “etiquetas personalizadas” o
“etiquetas de estilo”, las cuales permiten a los desarrolladores definir sus propias
extensiones para etiquetas JSP. Las etiquetas personalizadas están basadas en
etiquetas XML que permiten adicionar un amplio rango de funcionalidades a los JSPs.
Para entender cómo las etiquetas personalizadas logran hacer esto, primero se
explicará cómo las etiquetas de acción estándar han mejorado la funcionalidad del JSP.
Considere la etiqueta de acción estándar <jsp:useBean>, que está definida por la
especificación JSP, cuando el motor del JSP encuentra una etiqueta <jsp:useBean>, lo
reemplaza con el código Java correspondiente a la etiqueta, lo cual ocurre durante la
traducción del JSP. Considere los siguientes ejemplos:
<jsp:useBean id="calculadora" scope="page" class="CalculadorBean">
</jsp:useBean>
A continuación se muestra el código Java generado por <jsp:useBean> durante la

traducción del JSP.
El código Java comienza aquí…

// begin [file="/Resultado.jsp";from=(16,0);to=(16,94)]
volumen3.unidad5.ejemplo1.CalculadorBean calculadora =
null;
boolean _jspx_specialcalculadora = false;
synchronized (pageContext) {
calculadora= (volumen3.unidad5.ejemplo1.CalculadorBean)
pageContext.getAttribute("calculadora",PageContext.PAGE_SC
OPE);
if (calculadora == null) {
_jspx_specialcalculadora = true;
try {
calculadora = (volumen3.unidad5.ejemplo1.CalculadorBean)
java.beans.Beans.instantiate(this.getClass().getClassLoade
r(), "volumen3.unidad5.ejemplo1.CalculadorBean");
} catch (ClassNotFoundException exc) {
throw new
InstantiationException(exc.getMessage());
Unidad 7: Escribir Etiquetas Personalizadas en JSP Libro 2: Java Empresarial 92

} catch (Exception exc) {

throw new ServletException (" No es posible crear bena de
la clase "+"volumen3.unidad5.ejemplo1.CalculadorBean",
exc);
}
pageContext.setAttribute("calculadora", calculadora,
PageContext.PAGE_SCOPE);
...
Es conveniente aclarar que la simple etiqueta de acción estándar JSP <jsp:useBean>

reemplaza un bloque grande de código Java que de otra manera aparecería en el JSP.
Las distintas etiquetas de acción estándar, definidas por las especificaciones JSP,
generalmente encapsulan funcionalidades usadas dentro de etiquetas simples y fáciles
de usar. Esto reduce el requerimiento para escribir código Java dentro de JSPs.
El objetivo de las etiquetas personalizadas es similar a las etiquetas de acción estándar,

excepto que tienen que ser designadas en base al requerimiento. Las etiquetas
personalizadas permiten a los desarrolladores elegir ciertas funcionalidades que serán
usadas luego frecuentemente en varias aplicaciones. Por ejemplo, si se está
desarrollando una aplicación de banca en línea o una aplicación de apoyo a clientes,
una funcionalidad que será requerida comúnmente por las aplicaciones es la validación
del cliente. Se puede diseñar una etiqueta personalizadas como se muestra a
continuación:
<Utility:validate usuario=
”<%=request.getParameter(usuario)%>”
clave =”<%=request. getparameter(clave)”%>
Esto se puede implementar de la forma que se conecta a la base de datos o a un
servidor LDAP y valida al usuario, basado en los valores suministrados para los
atributos usuario y clave. De esta forma las etiquetas personalizadas permiten que
funcionalidades complejas sean encapsuladas dentro de etiquetas simples. Las
etiquetas personalizadas permiten que funcionalidades de las aplicaciones sean
invocadas usando etiquetas simples y fáciles de usar, de esta manera, evitar que
enormes bloques de código Java se incluyan en los JSPs.
Las etiquetas personalizadas que se relacionan pueden ser clasificadas en grupos

llamados librerías de etiquetas. Estas librerías de etiquetas pueden ser reutilizadas en
cualquier número de archivos JSP. Esta posibilidad provista por el JSP 1.1 define las
librerías de etiquetas que permitan a los desarrolladores implementar comportamientos
complejos del lado del servidor dentro de etiquetas simples. Los diseñadores de
páginas JSP pueden fácilmente incorporar estas librerías dentro de sus páginas.

2. Componentes de una Etiqueta Personalizada

La estructura de las etiquetas personalizadas es similar a las etiquetas de acción
estándar. Algunas de las características de las etiquetas personalizadas se listan a
continuación:
• Todas las etiquetas personalizadas tienen un nombre. El nombre de la etiqueta
tienen un prefijo y sufijo separados por dos puntos.
• Las etiquetas pueden tener cualquier número de atributos. Estos atributos
pueden ser opcionales u obligatorios.
• Una etiqueta puede encerrar otras sub etiquetas dentro de ella, como las
etiquetas <jsp:forward> y <jsp:include> que encierran las etiquetas
<jsp:param>. La etiqueta que encierra a otra es llamada etiqueta padre de la
etiqueta encerrada.
• Las etiquetas pueden tener un contenido del cuerpo (body content). El contenido
entre el comienzo y el final del elemento de la etiqueta, excluyen a las sub
etiquetas y se denomina contenido del cuerpo.
La Figura 7.1 muestra los diferentes componentes de la etiqueta personalizada.
Figura 7.1 Ilustración de los Componentes de una Etiqueta Personalizada
Ahora se presenta cómo construir una simple etiqueta personalizada.
3. Construir una Etiqueta Personalizada Simple

En esta sección se construye una etiqueta personalizada simple, la cual no tiene ningún
atributo o contenido del cuerpo. Esta etiqueta muestra un mensaje de bienvenida
(Buenos Días, Buenas Tardes, Buenas Noches) dependiendo de la hora del día.
Ejemplo 7.1

3.1 Crear una etiqueta JSP que utiliza la Etiqueta Estilo <simple:saludo>
El siguiente código muestra el código fuente de Simple.jsp
El código JSP comienza aquí…
1. <%@ page import="java.util.*"%>
2. <%@ taglib uri="/CustomTags" prefix="simple" %>
3. <HTML>
4. <HEAD><TITLE>Ejemplo de un Simple Custom
Tag</TITLE></HEAD>
5. <BODY>
6. <%Calendar calendario = Calendar.getInstance();
7. int hr = calendario.get(Calendar.HOUR_OF_DAY);
8. int min=calendario.get(Calendar.MINUTE);
9. int seg=calendario.get(Calendar.SECOND);
10. %>
11. <FONT size="5" color="#0065CE">
12. <simple:saludo/>
13. La Hora es: <%=hr%>:<%=min%>:<%=seg%>
14. </FONT>
15. </BODY>
16. </HTML>
En el código anterior, está resaltada la declaración para importar el descriptor de la

librería de etiqueta. Luego en este ejemplo, se estudiará cómo escribir librerías de
etiquetas. Además, se resalta el uso de la etiqueta personalizada <simple:greeting>
en el archivo JSP.
3.2 Crear la Clase Manejadora (Handler Class) para la etiqueta

<simple:saludo>
Una vez usada una etiqueta personalizada en el JSP, se le indica al motor del JSP que
debe hacer si encuentra una <simple:saludo> durante la traducción de
Simple.jsp. Por lo tanto, el siguiente paso es escribir la etiqueta de clase handler,
cuyos métodos serán invocados por el motor del JSP cuando encuentre
<simple:saludo>. Esta clase debe implementar la interfaz
javax.servlet.jsp.tagext.Tag. Se puede lograr esto extendiendo la clase
javax.servlet.jsp.tagext.TagSupport, la cual a su vez implementa la interfaz
javax.servlet.jsp.tagext.Tag. A continuación se muestra el código fuente para
la etiqueta de clase handler SaludoTagHandler.java
El código Java comienza aquí…

1. package volumen3.unidad7.ejemplo1;
2. import javax.servlet.jsp.*;
3. import java.util.*;
4. import java.io.*;
5. import javax.servlet.jsp.tagext.TagSupport;
6.
7. public class SaludoTagHandler extends TagSupport {
8. public int doStartTag() throws JspTagException {
9. return EVAL_BODY_INCLUDE;
10. }
11. public int doEndTag() throws JspTagException {
12. Calendar calendario =
Calendar.getInstance();
13. int hr =
calendario.get(Calendar.HOUR_OF_DAY);
14. try {
15. if (hr < 12)
16. pageContext.getOut().write("Buenos Dias.");
17. else
18. if (hr < 19)
19. pageContext.getOut().write("Buenas
Tardes.");
20. else
21. pageContext.getOut().write("Buenas
Noches.");
22. } catch (IOException ex) {
23. throw new JspTagException("Fatal
error:Etiqueta saludo no puede ser escrita en bufer de
salida");
24. }
25. return EVAL_PAGE;
26. }
27. }
El código Java finaliza aquí.
Los métodos doStartTag() y doEndTag() se definen por la interfaz Tag. En esta

sección y a través de la Clase TagSupport se aprenderá acerca de la interfaz Tag.
Cuando el motor JSP encuentra la etiqueta de apertura <simple:greeting> durante
la traducción de <simple:greeting> , inserta el código para hacer una llamada al

método doStartTag() de la clase handler. Cuando se encuentra la etiqueta de cierre

<simple:greeting/>, el motor JSP inserta el código para invocar al método
doEndTag(). Así, en el ejemplo cuando se invoca a doEndTag(), se mostrará un
saludo de bienvenida en el flujo de datos de salida.
A continuación se presenta el descriptor de librería de etiquetas que hace corresponder

la etiqueta personalizada <simple:greeting> a su clase tag handler
SaludoTagHandler.java.
3.3 Crear el Descriptor de Librería de Etiquetas
Debe escribirse el Descriptor de Librería de Etiquetas (Tag Library Descriptor - TLD)

saludo.tld, el cual es un documento XML con extensión .tld, conforme a la
definición del Tipo de Documento (DTD) dado por Sun Microsystems. El TLD hará
corresponder la etiqueta personalizada <simple:saludo> a su clase manejadora de
etiqueta (tag handler class) SaludoTagHandler.java.
El código XML comienza aquí…

1. <?xml version="1.0" encoding="UTF-8"?>
2. <!DOCTYPE taglib PUBLIC "-//Sun Microsystems,
Inc.//DTD JSP
3. Tag Library 1.1//EN"
4. "http://java.sun.com/j2ee/dtds/web-
5. jsptaglibrary_1_1.dtd">
6. <taglib>
7. <tlibversion>1.0</tlibversion>
8. <jspversion>1.1</jspversion>
9. <shortname>simple</shortname>
10. <info>Una libreria tag simple.</info>
11. <tag>
12. <name>saludo</name>
13. <tagclass>
14. unidad7.ejemplo1.SaludoTagHandler
15. </tagclass>
16. <bodycontent>empty</bodycontent>
17. <info>Tag simple que desplega un saludo</info>
18. </tag>
19. </taglib>
El código XML finaliza aquí.
El elemento raíz del TLD es <taglib> y está definido en el DTD como:

<!ELEMENT
taglib(tlibversion,jspversion?,shortname,uri?,info?,tag+)>
La siguiente tabla explica cada elemento del DTD presentado anteriormente:
Nombre Elemento Descripción
tlibversion Este elemento define la versión del TLD. Si se requiere se puede

mantener múltiples versiones del TLD.
jspversion Este elemento define la versión de la especificación JSP para el

cual está conforme el JSP actual. El valor para este atributo debe
ser mayor que 1.1, ya que las etiquetas personalizadas son
soportadas sólo a partir del JSP 1.1 en adelante. Este elemento es
opcional y el texto del elemento por defecto asumido para este
elemento es 1.1.
shortname Las relacionadas pueden ser agrupadas dando el mismo prefijo

para los etiquetas. Este prefijo puede ser utilizado como el texto del
elemento para el elemento shortname. El texto del elemento
proporcionado por el elemento shortname no puede comenzar
con una línea subrayada o un digito, y el texto del elemento no
debe contener espacios en blanco. En el ejemplo que se muestra,
se ha escrito sólo una etiqueta y el prefijo que se ha dado es
simple. Por lo tanto, se especifica el texto del elemento como
simple para shortname.
Uri El elemento define el URI que identifica únicamente el TLD. Este

elemento es opcional. Se omitió en el ejemplo dado. Se configura
en el descriptor de despliegue.
info Alguna información básica acerca de los TLD se puede

proporcionar como texto del elemento. En el ejemplo tag library es
justo un ejemplo TLD. Este es un elemento opcional.
tag Como puede ser visto en saludo.tld , este elemento encierra

sub-elementos y es definido en el DTD.
Tabla 7.1: Descripción del Elemento taglib
El elemento tag se define en un DTD de la siguiente manera:

<!ELEMENT tag(name, tagclass, teiclass?, bodycontent?, info?,

attributes*) >
Los subelementos presentes en el DTD se muestran a continuación:
Name: Este elemento define el nombre de la etiqueta personalizada. Como se vio en el

TLD, el sufijo tag es un nombre real de la etiqueta. En el ejemplo, para la etiqueta
<simple:saludo>, se especifica el nombre de la etiqueta como “greeting”.
Tagclass: Este elemento define el nombre de la clase handler de la etiqueta,

correspondiente a la etiqueta. La clase especificada debe implementar directa o
indirectamente la interfaz javax.servlet.jsp.tagext.Tag
teiclass: Este elemento define información extra de la clase usada por la etiqueta. La
clase extra info debe ser una subclase de la clase
javax.servlet.jsp.tagext.TagExtraInfo. Este es un elemento opcional y no es
aplicable para el ejemplo dado.
bodycontent: El texto del elemento especificado para este elemento puede ser
tagdependent, JSP o empty. Si el texto es tagdependent, implica que la etiqueta
handler se encargará de éste. Si el texto es JSP, el motor de JSP evaluará el contenido
en tiempo de ejecución. En el ejemplo anterior, no se requiere que ningún bodycontent
sea especificado para la etiqueta. De este modo, se ha especificado el texto como
empty. Este elemento es opcional y el texto del elemento por defecto para este es JSP.
info: Es un elemento opcional, es una cadena que describe que la etiqueta se pasa
como texto del elemento para este elemento.
attributes: Una etiqueta elemento puede tener cualquier número de atributos. Este
elemento tiene un número de sub-elementos y se considera opcional, por eso, no es
relevante para el ejemplo. Se explicará más a detalle acerca de este elemento en las
siguientes secciones de esta unidad.
Al incluir elementos adicionales <tag>, cualquier número de etiquetas personalizadas

pueden ser definidas en un único TLD.
3.4 Actualizar el web.xml
Se tendrá que especificar la librería de etiquetas URI y su ubicación incluyendo un

elemento <taglib> en el archivo web.xml. A continuación se muestra el código
fuente para web.xml.
El código XML comienza aquí…

1. <!DOCTYPE web-app PUBLIC "-//Sun Microsystems,
Inc.//DTD Web Application 2.2//EN"
"http://java.sun.com/j2ee/dtds/web- app_2_2.dtd">

2. <web-app id="WebApp">
3. <display-name>CustomTags</display-name>
4. …
5. <taglib>
6. <taglib-uri>/CustomTags</taglib-uri>
7. <taglib-location>/WEB-
INF/tlds/saludo.tld</taglib-
8. location>
9. </taglib>
10. </web-app>
El código XML finaliza aquí.
En el código escrito para Simple.jsp, se ha importado la librería de etiqueta usando la

directiva taglib de la siguiente forma:
<%@ taglib uri="/CustomTags" prefix="simple" %>
El servidor tendrá que localizar el TLD de manera que el servidor será capaz de
identificar la clase handler para la etiqueta personalizada usada en el JSP. Para que el
servidor sepa donde buscar la librería de etiquetas, se ha especificado su URI y la
ubicación en el archivo web.xml usando una etiqueta especial <taglib>. La siguiente
lista explica los dos elementos de la etiqueta taglib:
• <taglib-uri> Este elemento define el uri del TLD. En el ejemplo anterior, se
especificó /CustomTags como text para este atributo. Cuando se importa la
librería de etiquetas en Simple.jsp, se tendrá que especificar el mismo valor
/CustomTags como valor de atributo uri.
• <taglib-location> El elemento define la localización del TLD. Para cada
especificación JSP. Los TLDs deben ser almacenados en una carpeta llamada
tlds en el directorio WEB-INF.
Cuando se importa la librería de etiquetas en el JSP, el servidor web podrá localizar el
TLD, con la información que se ha proporcionado usando la etiqueta <taglib> en el
archivo web.xml file.
3.5 Desplegar la Aplicación
Para el despliegue, se debe empaquetar el TLD, clases manejadoras de etiquetas (tag

handler classes) y el JSP en un archivo solo WAR. Antes de crear el archivo WAR, tiene
que crearse la siguiente estructura de directorio y deben colocarse los archivos en el
directorio apropiado, como se muestra a continuación:
Simple.jsp
WEB-INF/
web.xml
classes/

volumen3/
unidad7/
ejemplo1/
SaludoTagHandler.class
tlds/
saludo.tld
El comando que se muestra a continuación, dado en la línea de comando en cualquier
ambiente de desarrollo Java, puede crear el archivo WAR. Una vez creado, se puede
importar el archivo WAR dentro de cualquier servidor web, que tenga un JSP 1.1 y
cumpla con el motor JSP. De esta manera, la aplicación estará lista para ejecutarla.
jar –cvf saludo.war WEB-INF/classes/volumen3/unidad7/ejemplo1/
SaludoTagHandler.class WEB-INF/tlds/saludo.tld WEB-INF/web.xml
Simple.jsp
Nota: En RAD, un proyecto web tiene que ser creado y agregado al Simple.jsp en la
carpeta webApplication. El archivo de la clase Java SaludoTagHandler.java tiene
que ser adicionado en la carpeta fuente. Se tiene que crear una carpeta tlds bajo la
carpeta WEB-INF y se tiene que añadir el saludo.tld a la carpeta tlds. Por otra parte,
es necesario modificar el archivo web.xml para agregar al elemento<taglib> como
se muestra en el código de la sección Actualizar el web.xml Ahora el código está listo
para su ejecución.
3.6 Ejecutar Simple.jsp
Durante la traducción de Simple.jsp, el motor JSP importa el TLD, saludo.tld

definido por la directiva taglib del uri especificado. Luego contacta al TLD para
localizar la clase manejadora de la etiqueta correspondiente, instancia un handler y lo
inicializa. En tiempo de ejecución, cuando el motor del JSP encuentra la etiqueta de
apertura de <simple:saludo>, invoca al método doStartTag() de la clase
handler SaludoTagHandler. El método doStartTag() retorna una constante
EVAL_BODY_INCLUDE (las otras constantes que pueden ser retornadas por el método
doStartTag() serán explicadas en detalle más adelante en esta unidad) la cual
instruye al motor JSP para evaluar el bodycontent y cualquier cantidad de etiquetas
hijo (child) que pueda tener. Como en este ejemplo, no se tiene ningún bodycontent o
etiquetas hijo, el motor JSP invocará al método doEndTag() de la clase handler
cuando encuentra la etiqueta de cierre. Este método envía un saludo de bienvenida al
flujo de salida y retorna una constante EVAL_PAGE, dicha constante indica al motor
JSP que continue evaluando el resto de la página. La respuesta generada por
Simple.jsp aparecerá en el navegador del cliente como se muestra en la Figura 7.2.

Figura 7.2: Respuesta Generada por Simple.jsp
Fin del Ejemplo 7.1
4. Interfaz Tag y la Clase TagSupport

Cuando se construyó la etiqueta personalizada <simple:saludo> en la sección
anterior, la clase manejadora (SaludoTagHandler) de la etiqueta <simple:saludo>
extiende de una superclase llamada TagSupport. En esta sección se explicará la clase
TagSupport y la interfaz Tag. En la Figura 7.3 se muestra la jerarquía de clases e
interfaces en la especificación JSP 1.2 de J2EE 1.3 para el desarrollo de clases
manejadoras (Tag Handler) de Etiquetas Personalizadas.
Figura 7.3: Jerarquía de Interfaces y Clases en la Especificación JSP 1.2 para Tag
Handler

4.1 Interfaz javax.servlet.jsp.tagext.Tag
Todos los manejadores de etiquetas personalizadas (Tag Handler) deben directa e

indirectamente implementar esta interfaz porque representa el contrato entre el motor
JSP y la clase manejadora de etiqueta.
Durante la traducción del JSP, cuando el motor del JSP encuentra una etiqueta
personalizada, ubica al archivo TLD para localizar la clase manejadora de la etiqueta
(tag handler) e interactúa con él utilizando el método callback definido en la interfaz Tag.
Existen dos métodos principales dentro de la interfaz Tag: doStartTag() y doEndTag(),
Una vez que todas las propiedades de una etiqueta personalizada han sido inicializadas
(pageContent, parent y atributos) los métodos pueden ser invocados en la clase
manejadora.
La siguiente figura proporciona una ilustración de las semánticas del código generado.
También ilustrará la secuencia en la cual los métodos callback de la interfaz son
invocados (implementada por la clase tag handler).
Figura 7.4: Ciclo de vida de una Etiqueta Handler Simple

Una vez que el motor del JSP encuentra una etiqueta personalizada, intenta obtener
una instancia del tag handler (La mayoría de los motores del JSP no instanciarán un
nuevo handler cada vez que se encuentre una etiqueta, en lugar de eso mantendrá un
grupo (pool) de instancias handler). Después que el motor JSP obtiene una instancia del
la clase tag handler, lo inicializará llamando al método setPageContext(PageContext)
y establecerá la propiedad pageContext en el tag handler. El pageContext del JSP
actual estará entonces disponible para la clase handler de la etiqueta.
El motor JSP invocará al método setParent() para establecer la propiedad parent del
tag handler. Si una etiqueta no contiene ninguna sub-etiqueta, entonces la propiedad
parent se establecerá como null.
Si la etiqueta tiene algún atributo, la propiedad o propiedades correspondientes en la

clase tag handler serán establecidas con los valores especificados para los atributos.
Cuando el motor JSP encuentra la apertura de una etiqueta personalizada, llama al

método doStartTag(). Cualquier inicialización y proceso que se necesite hacer cuando
la etiqueta de apertura se encuentre, puede ser incluido en este método. Este método
retornar Tag.EVAL_BODY_INCLUDE o BodyTag.EVAL_BODY_BUFFERED es empleado si se
desea que el motor JSP evalúe el cuerpo y cualquier etiqueta hijo encerrada dentro de
la etiqueta personalizada. De lo contrario, si el método retorna Tag.SKIP_BODY,
entonces el motor del JSP ignorará el cuerpo de la etiqueta.
BodyTag.EVAL_BODY_BUFFERED solo puede ser un valor válido de retorno, si la clase
manejadora (Tag Handler) implementa directa o indirectamente la interfaz BodyTag.
Cuando el motor JSP encuentra la etiqueta personalizada de cierre, invoca al método

doEndTag(). Este método puede tener el código que represente la tarea que será
realizada por la etiqueta personalizada. Debe retornar una constante entera, la cual
puede ser EVAL_PAGE o SKIP_PAGE. Si el método doEndTag() retorna EVAL_PAGE,
entonces el motor JSP evaluará el resto del JSP. Si retorna SKIP_PAGE, entonces el
motor JSP terminará la ejecución del JSP. No es una buena práctica terminar la
ejecución de un JSP desde una clase handler retornando SKIP_PAGE ya que afectará
desfavorablemente la legibilidad del archivo JSP.
Aparte de retornar el valor del método doEndTag(), el motor del JSP invocará al método
release(), antes de liberar la instancia handler. Cualquier recurso adquirido por el
handler puede ser liberado en este método. En la Figura 7.5 se muestra los valores que
pueden retornar los métodos callback doStartTag() y doEndTag().

Figura 7.5: Valores de retorno de los métodos doStartTag() y doEndTag()
4.2 Clase javax.servlet.jsp.tagext.TagSupport
Esta es una clase concreta que implementa la interfaz

javax.servlet.jsp.tagext.IterationTag y proporciona las implementaciones
necesarias para todos los métodos de las interfaces IterationTag y Tag. Esta clase
posee un atributo denominado pageContext y almacena el contexto de la página
(pasado por el motor JSP cuando invoca al método setPageContext(PageContext))
en este atributo. Si los desarrolladores extienden su clase handler desde la super clase
TagSupport, entonces pueden implementar solamente aquellos métodos que son
relevantes para ellos. En el ejemplo anterior, la clase SaludoTagHandler se extiende de
la clase TagSupport. De este modo, se han implementado sólo los métodos
doStartTag() y doEndTag(). El doStartTag()pudo también ser omitido en el
ejemplo porque tiene el mismo código que el método doStartTag() de su super clase
TagSupport.
5. Asignar Atributos y Contenido de Cuerpo a las

Etiquetas Personalizadas
En la Sección 3 – Construir una Etiqueta Personalizada Simple, se construyó una
simple etiqueta personalizada, la cual no tenía ningún atributo o contenido del cuerpo
(content body). Ahora se construirá una etiqueta personalizada que manipule atributos y
tenga contenido de cuerpo.
Ejemplo 7.2
En este ejemplo, se presentará una página de ingreso Ingreso.html, que permita a

los usuarios ingresar sus nombres. Cuando este formulario es enviado, se invoca el
AtributoSimple.jsp. El JSP usa una etiqueta personalizada
<simple:saludoAtributo name="<%=usuario%>"/>. El AtributoSimple.jsp
extrae el nombre del usuario desde el objeto request y lo pasa como valor al atributo
name de la etiqueta personalizada. La etiqueta personalizada

<simple:saludoAtributo> muestra el mensaje de saludo con el nombre del

usuario. El contenido del cuerpo de la etiqueta tiene una combinación de texto y una
expresión JSP que muestra la hora actual. Este contenido del cuerpo será suministrado
por el JSP al igual que cualquier otro contenido JSP.
5.1 Crear la página de Ingreso

A continuación se muestra el código fuente para Ingreso.html.
3. <HTML>
4. <HEAD>
5. <TITLE>Pagina de Registro</TITLE>
6. </HEAD>
7. <BODY>
8. <FORM METHOD=POST ACTION="AtributoSimple.jsp">
9. <H2><LABEL>Registrese para Conocer Tiempo y Dia
</LABEL></H2>
10. <HR>
11. <LABEL><B>Ingrese su Nombre: </B></LABEL>
12. <INPUT TYPE="text" NAME="nombre">
13. <BR>
14. <BR>
15. <INPUT TYPE="submit" value="Registrarse">
16. <INPUT TYPE="reset" value="Limpiar">
17. </FORM>
18. <HR>
19. </BODY>
20. </HTML>
El código HTMl finaliza aquí
5.2 Crear AtributoSimple.jsp

A continuación se muestra el código fuente para AtributoSimple.jsp



5. <HTML>
6. <HEAD>
7. <TITLE>Ejmplo Etiquetas Simples</TITLE>
8. </HEAD>
9. <BODY>
11. int hr = calendario.get(Calendar.HOUR_OF_DAY);
12. int min=calendario.get(Calendar.MINUTE);
13. int seg=calendario.get(Calendar.SECOND);
14. String
usuario=request.getParameter("nombre");
15. %>
17. Saludos...
18. <simple:saludoAtributo nombre=’<%=usuario%>’>
19. La Hora es <%=hr%>:<%= min%>:<%=seg%>
20. </simple:saludoAtributo>
21. </FONT>
22. </BODY>
23. </HTML>
Este código JSP es similar al Simple.jsp que se construyó anteriormente, excepto que
usa una etiqueta personalizada <simple:saludoAtributo> la cual toma un atributo
nombre y muestra el saludo de bienvenida con el usuario. Este contenido del cuerpo de
la etiqueta personalizada será mostrado por el motor del JSP como cualquier otro
contenido JSP.
5.3 Crear la Clase Tag Handler
Cuando se escribe el tag handler para la etiqueta personalizada con atributo, se tendrá
que incluir una propiedad para cada atributo que se planee utilizar en la etiqueta
personalizada y proporcionar getter y setter para las propiedades. El nombre de la
propiedad debe coincidir exactamente con el nombre del atributo usado en la etiqueta
personalizada. En este ejemplo, la etiqueta personalizada
<simple:saludoAtributo> toma solamente un nombre de atributo. Por lo tanto, se
tiene que incluir una propiedad en la clase tag handler. El código fuente para el tag
handler se muestra a continuación:


1. package rad.apendiceC.ejemplo2;
2. import java.io.IOException;
3. import java.util.Calendar;
4. import javax.servlet.jsp.JspTagException;
5. import javax.servlet.jsp.tagext.TagSupport;
6. public class SaludoAtributoTagHandler extends
TagSupport {
7. private String nombre;
8. public String getNombre() {
9. return nombre;
10. }
11. public void setNombre(String nombre) {
12. this.nombre = nombre;
13. }
14. public int doStartTag() throws JspTagException{
15.
16. Calendar calendario=Calendar.getInstance();
17. int hr=calendario.get(Calendar.HOUR_OF_DAY);
18. try{if(hr<12)
19. pageContext.getOut().write("Buenos Dias "+
getNombre());
20. else if(hr<19)
21. pageContext.getOut().write("Buenas Tardes "+
getNombre());
22. else
23. pageContext.getOut().write("Buenas Noches " +
getNombre());
24. }catch(IOException ex){
25. throw new JspTagException("Error:La etiqueta saludo no
puede escribir en el flujo de salida");
26. }
27. return EVAL_BODY_INCLUDE;
28. }
29. public int doEndTag()throws JspTagException{
31. }
32. }

5.4 Crear el TLD
Al TLD, saludo.tld escrito anteriormente en el Ejemplo 7.1, se le adicionará un

elemento <tag> para incluir la nueva etiqueta personalizada <simple:saludoAtt>.
El código fuente para saludo.tld se muestra a continuación:
El código XML comienza aquí...

Inc.//DTD JSP
"http://java.sun.com/j2ee/dtds/web-
5. <taglib>
9. <info>Una librería simple de etiquetas.</info>
10. <tag>
12. <tagclass>
13.
volumen3.unidad7.ejemplo1.SaludoTagHandler
14. </tagclass>
16. <info>Despliega Saludos</info>
17. </tag>
18. <tag>
19. <name>saludoAtributo</name>
20. <tagclass>volumen3.unidad7.ejemplo2.
21. SaludoAtributoTagHandler </tagclass>
22. <bodycontent>JSP</bodycontent>
23. <info>Etiqueta con atributos</info>
24. <attribute>
25. <name>nombre</name>
26. <required>true</required>
27. <rtexprvalue>true</rtexprvalue>

28. </attribute>
29. </tag>
30. </taglib>
El código XML finaliza aquí
En el código anterior, se observa que un elemento extra <attribute> está anidado

dentro del elemento <tag>. El elemento <attribute> tiene sub elementos y está
definido en el DTD como:
<!ELEMENT attribute(name,required?,rtexprvalue?)>
A continuación se explicarán los diversos sub elementos del elemento atributo:
name: El elemento define el nombre del atributo como se usa en la etiqueta

personalizada. En el ejemplo anterior, el nombre del atributo usado es name.
required: Si el atributo definido en la etiqueta personalizada es un atributo

mandatorio, entonces el texto del elemento especificado para este elemento debe ser
verdadero. Si el atributo es un atributo opcional, el texto del elemento especificado para
este elemento debe ser falso. Este elemento es un elemento opcional y el valor por
defecto es falso. En este ejemplo, se quiere que el name sea un atributo mandatorio,
por lo tanto se ha especificado el texto del elemento para este elemento como
verdadero.
rtexprvalue: Si se quiere que el valor para el atributo sea dado como resultado de
una expresión JSP, el elemento texto especificado para este elemento debe ser
verdadero. Por ejemplo, es posible dar expresiones como valor para atributos como se
planteó en el AtributoSimple.jsp <simple:saludoAtributo nombre=
"<%=usuario%>"/>. Permitir que los atributos tomen valores de expresiones puede ser
útil como en el caso del ejemplo anterior, donde el nombre del usuario tiene que ser
pasado dinámicamente en tiempo de ejecución para la clase tag handler. Si se requiere
permitir solamente cadenas fijas como valor para el atributo, entonces el texto del
elemento especificado para este elemento debe ser falso. Este elemento es un
elemento opcional y el texto del elemento por defecto es falso.
Para cada atributo que se defina en la etiqueta personalizada, tiene una entrada
correspondiente en el TLD. La etiqueta <attribute> está anidada dentro del elemento
de la etiqueta. Debido a que la etiqueta <simple:saludoAtributo> toma un contenido
del cuerpo la misma, y se necesita que sea mostrada en forma automática por el motor
del JSP, como cualquier contenido JSP, se especifica el elemento texto JSP para el
elemento <bodycontent> como se observó en el código anterior.
El archivo web.xml será el mismo como el mostrado en la sección Construir una

Etiqueta Personalizada Simple, debido a que se está usando el mismo saludo.tld y
solo fue modificado adicionando un elemento etiqueta. La aplicación tiene que ser

empaquetada en un archivo WAR como se mostró en la sección Construir una Etiqueta

Personalizada Simple y desplegarla en el servidor web.
5.5 Ejecutar AtributoSimple.jsp
Cuando AtributoSimple.jsp es traducido, el motor JSP genera código para obtener

el objeto tag handler. Para cada atributo en la etiqueta, el motor JSP genera código para
invocar el correspondiente método setter de la clase tag handler.
Cuando el cliente genera una solicitud al Ingreso.html, aparecerá en su navegador

como se muestra en la siguiente figura:
Figura 7.6: Formulario Ingreso
Al suministrar el Ingreso.html se invoca AtributoSimple.jsp. Cuando se ejecuta,

el nombre del usuario es extraído del objeto request en forma de parámetro y en la
propiedad (atributo) name de la clase manejadora (tag handler) se establece con el
nombre del usuario. El motor JSP invoca al método doStartTag(), el cual escribe el
mensaje de bienvenida junto con el nombre del usuario hacia el flujo de salida. Luego
retorna una constante entera Tag.EVAL_BODY_INCLUDE, la cual le indica al motor JSP
que debe evaluar el contenido del cuerpo de la etiqueta. El contenido del cuerpo
proporcionado por la etiqueta “La hora es<%=hr%>:<%= min%>:<%=seg%>.<BR>”,
es evaluado como cualquier expresión JSP y enviado al flujo de salida. El motor JSP
entonces invoca al método doEndTag(), el cual retorna EVAL_PAGE. Esto indica al
motor del JSP que debe evaluar el resto de la página. La respuesta enviada al cliente
aparecerá en el navegador como se muestra en la Figura 7.7.

Figura 7.7 Respuesta Generada por AtributoSimple.jsp
Una forma eficiente de regular el comportamiento en tiempo de ejecución de las

etiquetas personalizadas es haciendo uso de las etiquetas personalizadas con atributos.
Con los atributos se pueden diseñar etiquetas personalizadas que sean genéricas y
reutilizables.
En el ejemplo anterior, el nombre del atributo es definido para que sea de tipo String
en la clase handler. Sin embargo, se pueden tener atributos, los cuales se hacen
corresponder con propiedades de otros tipos diferentes a String en la clase handler.
Por ejemplo, en la etiquetas personalizadas <simple:format font=”Arial”
size=”11” />, el atributo size en la clase handler puede ser definido como tipo int .
En tales situaciones, el motor JSP intentará convertir el valor del atributo para el tipo de
propiedad correspondiente en la clase handler, antes de que invoque al correspondiente
método setter. En este caso, el String “11” será convertido a int. Si la conversión
falla, una excepción será lanzada y el JSP que contiene la etiqueta la manejará.
Fin del Ejemplo 7.2
6. Manipular el Contenido del Cuerpo

En los dos ejemplos construidos en esta unidad, mientras se diseñó el tag handler para
las etiquetas personalizadas <simple:saludo> y <simple:saludoAtributo>, se
expandió la etiqueta handler desde la super clase TagSupport. Sin embargo, en ambos
ejemplos, no fue manipulada la etiqueta personalizada del contenido del cuerpo (body
content). En el ejemplo en la sección Asignar Atributos y contenido del cuerpo a las
etiquetas personalizadas, se observó la forma en la que el motor JSP presenta de
manera automática el contenido del cuerpo en la clase handler. Sin embargo, en
situaciones donde se necesita acceder y manipular el contenido del cuerpo de la
etiqueta en la clase handler, la clase handler debe directa o indirectamente implementar
la interfaz BodyTag

6.1 Interfaz javax.servlet.jsp.tagext.BodyTag
La interfaz BodyTag se extiende de la interfaz IterationTag. Por lo tanto los métodos

centrales de la interfaz Tag, doStartTag() y doEndTag() pueden usarse en la misma
forma como se usaron en los ejemplos previos. La interfaz IterationTag define un
método callback el cual permite trabajar con el contenido del cuerpo. Este método es:
int doAfterBody() throws JspException
Este método procesa la evaluación o reevaluación del cuerpo de la etiqueta. El motor
del JSP invocará este método cuando procese el contenido del cuerpo de la etiqueta y
no lo invocará si no existe una evaluación del cuerpo, de igual forma el método debe
retornar una constante entera, que puede ser EVAL_BODY_AGAIN o SKIP_BODY. Si el
valor de retorno es EVAL_BODY_AGAIN, el motor del JSP realiza una reevaluación del
cuerpo de la etiqueta y cualquiera etiqueta hijo otra vez (seguido de una nueva
invocación del método doAfterBody()). Si el valor retorno es SKIP_BODY, se termina el
procesamiento del contenido del cuerpo y se invocará el método doEndTag().
La interfaz BodyTag define el método callback extra para trabajar con el contenido del
cuerpo. Los métodos importantes de la interfaz BodyTag son:
public void setBodyContent(BodyContent b)
Este método asigna la propiedad bodyContent. Este método es invocado al menos una
vez y antes del método doInitBody() cuando el método doStartTag() retorna
BodyTag.EVAL_BODY_BUFFERED. Mientras que, no será invocado para etiquetas vacías
o para etiquetas “no vacías” que en el método doStartTag() retorna Tag.SKIP_BODY o
Tag.EVAL_BODY_INCLUDE.
public void doInitBody()throws JspException
Este método prepara la evaluación del cuerpo de la etiqueta, este es invocado después
de los métodos doStartTag() y setBodyContent() y antes de que el cuerpo sea
evaluado por primera vez. Además este método no será invocado para etiquetas vacías
o para etiquetas “no vacías” que en el método doStartTag() retorna Tag.SKIP_BODY o
Tag.EVAL_BODY_INCLUDE. En este método puede ser incluido el código para que
cualquier inicialización que deba hacerse antes de que el contenido del cuerpo de la
etiqueta sea evaluado, efectivamente se haga.
Nota: El método doStartTag() perteneciente a una clase handler que implementa la

interfaz BodyTag no debe retornar EVAL_BODY_INCLUDE. Si el motor JSP detecta esto
lanzará una excepción.
6.2 Clase javax.servlet.jsp.tagext.BodyTagSupport
Tal como la clase TagSupport implementa la interfaz IterationTag y provee un

soporte adicional para los desarrolladores que desean usar la interfaz IterationTag, la
clase BodyTagSupport implementa la interfaz BodyTag y provee las principales
implementaciones para los métodos de la interfaz BodyTag. Como esta clase se
extiende de la clase TagSupport, el soporte proporcionado por la clase TagSupport

está también disponible para los desarrolladores quienes extienden sus clases desde
esta super clase.
En la clase BodyTagSupport existe

un atributo bodyContent del tipo
javax.servlet.jsp.tagext.BodyContent en que se encapsula la información acerca
del cuerpo de la etiqueta. A continuación se muestra un método asociado a este
atributo:
public BodyContent getBodyContent()
El método getBodyContent() retorna un objeto del tipo BodyContent con la

información del cuerpo de la etiqueta personalizada.
La clase BodyContent define dos importantes métodos:

JspWriter getEnclosingWriter()
Este método retorna el JspWriter de la página JSP encerrada.
String getString()
Este método retorna un String conteniendo el contenido del cuerpo completo.
La clase BodyTagSupport sobreescribe doStartTag( ) heredado de la clase

TagSupport. Este método debe retornar BodyTag.EVAL_BODY_BUFFERED.
6.3 Construir una Etiqueta Personalizada para Manipular el Contenido del

Cuerpo
Una vez se ha aprendido acerca de la interfaz BodyTag y soporte de la clase

BodyTagSupport, se construirá una etiqueta personalizada simple
<simple:saludoBodyTag> la cual manipula el contenido del cuerpo. Se mostrarán
en detalle el tiempo en horas, minutos y segundos en el cuerpo de esta etiqueta. La
clase tag handler SaludoBodyTagHandler accede a los detalles del tiempo del
contenido del cuerpo, y basado en la hora escribe un mensaje de saludo y el formato de
la hora en horas: minutos AM/PM en el flujo de salida.
Ejemplo 7.3
6.3.1 Crear el ManipuladorBody.jsp
El código fuente para ManipuladorBody.jsp se muestra a continuación:

3. <HTML>

4. <HEAD>
5. <TITLE>Ejemplo simple Custom Tag</TITLE>
6. </HEAD>
7. <BODY>
9. int hr =
calendario.get(Calendar.HOUR_OF_DAY);
10. int min = calendario.get(Calendar.MINUTE);
11. int seg = calendario.get(Calendar.SECOND);
12. %>
14. <simple:saludoBodyTag>
15. <%=hr%>:<%=min%>:<%=seg%>
16. </simple:saludoBodyTag>
17. </FONT>
18. </BODY>
19. </HTML>
6.3.2 Crear la Clase Tag Handler

A continuación se muestra el código de SaludoBodyTagHandler.java

1. package volumen3.unidad7.ejemplo3;
2. import java.io.IOException;
3. import java.text.DateFormat;
4. import java.util.*;
5. import javax.servlet.jsp.*;
6. import javax.servlet.jsp.tagext.*;
7. public class SaludoBodyTagHandler extends

BodyTagSupport {
8. public int doStartTag()throws JspTagException{
9. return EVAL_BODY_BUFFERED;
10. }
11. public int doAfterBody() throws JspTagException {
12. BodyContent bc = getBodyContent();

13. try {
14. if (bc != null) {
15. System.out.println("tamaño del buffer
"+ bc.getBufferSize());
16. String out = bc.getString();
17. System.out.println("String del body:
"+
18. out.toString());
19. StringTokenizer st = new
20. StringTokenizer(out, ":");
21. int hr =
Integer.parseInt(st.nextToken().trim());
22. int min = Integer.parseInt(
23. st.nextToken().trim());
24. int seg = Integer.parseInt(
25. st.nextToken().trim());
26. DateFormat df =
DateFormat.getTimeInstance(3);
27. if (hr < 12)
28.
bc.getEnclosingWriter().write("Buenos Dias,
29. es "+ df.format(new GregorianCalendar(
30. 2002, 9, 9, hr, min, seg).getTime()));
31. else if (hr < 19)
32.
bc.getEnclosingWriter().write("Buenas Tardes
33. es " + df.format(new
GregorianCalendar(2002, 9, 9, hr, min,
34. seg).getTime()));
35. else
36. bc.getEnclosingWriter().write("Buenas Noches, es"+
df.format(new GregorianCalendar( 2002, 9,
37. 9, hr, min, seg).getTime()));
38. }
39. } catch (IOException ex) {
40. throw new JspTagException("Fatal
error:La etiqueta saludo no puede escribiren el fujo de
salida");
41. }

42. return SKIP_BODY;

43. }
44. public int doEndTag() throws JspTagException {
46. }
47. }
El código Java finaliza aquí.
En la clase handler, se pasó el método doAfterBody() para manipular el contenido del

cuerpo. Este método obtiene una instancia del BodyContent el cual encapsula el
contenido del cuerpo de la etiqueta haciendo una llamada al método
getBodyContent(). Se obtiene el contenido del cuerpo como un string haciendo la
llamada al método getString() en la instancia, ambas situaciones resaltadas en el
código anterior. Luego, se manipula el contenido del cuerpo para acceder a los valores
de tiempo y se obtiene el objeto JspWriter de la página encapsulada invocando el
método getEnclosingWriter() para escribir un mensaje de saludo junto con la hora
en el formato ‘horas:minutos AM/PM al flujo de salida. El doAfterBody() retorna
SKIP_BODY de manera que termine el procesamiento del contenido del cuerpo y este
método no sea invocado nuevamente.
6.3.3 Crear el Descriptor de Librería de Etiquetas

Para este ejemplo también se usará el mismo TLD, saludo.tld el cual se usó
anteriormente. Se adicionará un elemento <tag> para incluir la nueva etiqueta
personalizada <simple:saludoBodyTag>. El código fuente saludo.tld se muestra
a continuación.
El código XML comienza aquí...

Inc.//DTD JSP
"http://java.sun.com/j2ee/dtds/web-
5. <taglib>
9. <info>Una libreria simple de etiquetas.</info>
10. <tag>

12. <tagclass>
13. volumen3.unidad7.ejemplo1.SaludoTagHandler
14. </tagclass>
16. <info>Etiqueta simple que despliega
saludos</info>
17. </tag>
18. <tag>
19. <name>saludoAtributo</name>
20. <tagclass>
21. volumen3.unidad7.ejemplo2.
22. SaludoAtributoTagHandler
23. </tagclass>
25. <info>Etiquetas Simples con atributos</info>
26. <attribute>
27. <name>nombre</name>
28. <required>true</required>
29. <rtexprvalue>true</rtexprvalue>
30. </attribute>
31. </tag>
32. <tag>
33. <name>saludoBodyTag</name>
34. <tagclass>
35.
volumen3.unidad7.ejemplo3.SaludoBodyTagHandler
36. </tagclass>
38. <info>Etiquetas simples con atributos</info>
39. </tag>
40. </taglib>
EL código XML finaliza aquí.
El archivo web.xml será el mismo como se mostró en la Sección 3, ya que se está

usando el mismo saludo.tld y solo se modifica para agregar un elemento tag
adicional. La aplicación debe ser empaquetada en un archivo WAR como se mostró
anteriormente y desplegada en el servidor web.

6.3.4 Ejecutar ManipuladorBody.jsp
Cuando el cliente hace una solicitud para el ManipuladorBody.jsp, la respuesta

generada por el JSP aparecerá en el navegador del cliente como se muestra en la
Figura 7.6:
Figura 7.8: Respuesta Generada por el ManipuladorBody.jsp
Fin del Ejemplo 7.3

Resumen
• Explicar la necesidad de las etiquetas personalizadas.
• Discutir acerca de los componentes de una etiqueta personalizada.
• Explicar cómo escribir etiquetas personalizadas simples y etiquetas
personalizadas que toman atributos.
• Describir cómo manipular el contenido del cuerpo de etiquetas personalizadas.


1) ¿Cuáles de los siguientes son componentes de una etiqueta personalizada?
a) Name (Nombre)
b) Attribute (Atributo)
c) Body content (Contenido del cuerpo)
d) Subtags (Subetiquetas)
2) ¿En qué versión de JSP se introdujo la etiqueta personalizada?

a) 0.9
b) 1.0
c) 1.1
d) 1.2
3) ¿Cuál de las siguientes interfaces debe ser directa o indirectamente implementada

por las etiquetas personalizadas?
a) TagHandler
b) Tag
c) CustomTag
d) Handler
4) ¿Cuál es el tipo de archivo de un TLD?

a) Documento XML
b) Archivo Text
c) Archivo Java
d) Archivo JSP
5) ¿Cuál es el tipo de retorno del método doStartTag() de la interfaz tag?

a) EVAL_BODY_INCLUDE
b) EVAL_PAGE
c) SKIP_BODY
d) SKIP_PAGE
6) ¿Cuáles de las siguientes sentencias son verdaderas con respecto al manejador de

etiquetas (tag handler) de las etiquetas personalizadas que manejan atributos?
a) Incluye una propiedad por cada atributo usado en la etiqueta personalizada.
b) Incluye una propiedad en una variable de script para cada atributo usado en la
etiqueta.

c) Provee getter para cada atributo.

d) Provee setters para cada atributo.
7) ¿Cuál de las siguientes interfaces debe ser directa o indirectamente implementada

por la etiqueta personalizada que manipule el contenido del cuerpo?
a) BodyTag
b) Tag
c) BodyContent
d) BodyHandler
8) ¿Cuáles de los siguientes métodos son definidos por la clase BodyContent?

a) getJspWriter()
b) getContent()
c) getEnclosingWriter()
d) getString()
9) Cualquier número de etiquetas personalizadas puede ser definido en un solo

Descriptor de Librería de Etiquetas
a) Verdadero
b) Falso
10) ¿Cuáles de las siguientes sentencias son verdaderas con respecto al

javax.servlet.jsp.tagext.BodyTagSupport.
a) Implementa la interfaz TagBody
b) Se extiende de la clase TagSupport
c) Se extiende de la clase BodyContent
d) Implementa la interfaz BodyTag


1) a, b, c y d
2) c
3) b
4) a
5) a y c
6) a, c y d
7) a
8) c y d
9) a
10) b y d

Guía de Estudiante Java Empresarial I - 1
Unidad 8: Lab. Escribir Etiquetas JSPs

Personalizadas
• Crear una librería de etiquetas JSP personalizadas y usar las etiquetas
personalizadas de la librería en JSPs.
Libro 2: Java Empresarial Unidad 8: Lab. Escribir Etiquetas JSPs Personalizadas 125

1) Crear una librería de etiquetas, la cual proporcionará etiquetas personalizadas para
obtener una conexión a la base de datos, insertar y eliminar registros de una tabla y
mostrar el contenido de la misma.
Ejercicios Opcionales de Laboratorio

2) Crear una librería de etiqueta personalizada que muestre la fecha actual en formato:
Nombre Formato
Fecha Corta 6-8-03
Fecha Corta 2 29/05/03
Fecha Corta 3 Abril 10, 1988
Fecha Europeo 20.10.99
Fecha Larga Lunes 6 de Mayo de 2002
Fecha Larga 2 Hoy es Lunes 6 de Septiembre.
Unidad 8: Lab. Escribir Etiquetas JSPs Personalizadas Libro 2: Java Empresarial 126

Java Empresarial v2

Cargado por

Información del documento

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Java Empresarial v2

Cargado por

Copyright:

Formatos disponibles

Java Empresarial I

Código del Curso: CY760

IBM IT Education Services

IBM ® es una marca registrada por International Business Machines Corporation.

Otras compañías, productos, y nombre de servicios pueden ser marcas registradas o

Trademarks of International Business Machines Corporation

Lotus Script Net.data

Marcas Registradas de otras Compañías

Windows, Microsoft Visual Studio Microsoft Corporation

Sybase Sybase Inc.

Edición Febrero 2008

La información contenida en este documento no ha sido sometida a ninguna prueba

Copyright International Business Machines Corporation, 2008. All rights reserved.

Instrucciones Especiales para la Impresión de este Curso:

Libro 2: Java Empresarial Unidad 1: Introducción a JSP 1

© Copyright IBM Corp. 2008

Unidad 1: Introducción a JSP

Libro 2: Java Empresarial Unidad 1: Introducción a JSP 3

© Copyright IBM Corp. 2008

1. Visión General del JSP

August 17, 2002

Figura 1.1: Una Típica Página Web

Unidad 1: Introducción a JSP Libro 2: Java Empresarial 4

© Copyright IBM Corp. 2008

embebida en la página HTML y enviada al navegador. Actualmente, un gran número de

La tecnología JSP se extiende desde HTML a snippets embebidos de código Java de

La tecnología JSP ofrece también beneficio a los programadores de Java, ya que

La tecnología JSP también separa la información de presentación de la lógica de la

2.1 JSPs vs. Servlets

Libro 2: Java Empresarial Unidad 1: Introducción a JSP 5

© Copyright IBM Corp. 2008

datos para la presentación en el navegador, generalmente en formato HTML. Un Servlet

Los desarrolladores de las aplicaciones pueden facilitar a los diseñadores, etiquetas de

Unidad 1: Introducción a JSP Libro 2: Java Empresarial 6

© Copyright IBM Corp. 2008

Figura 1.2: Rol de los Servlets, JSPs y JavaBeans

En el ejemplo de la Figura 1.2, el AutenticaServlet, recibe la solicitud HTTP del

Libro 2: Java Empresarial Unidad 1: Introducción a JSP 7

© Copyright IBM Corp. 2008

programador de la aplicación no necesita conocer de diseño y el diseñador de

2.2 Elegir entre Servlets y JSP

Para entender el uso de los Servlets y JSP, primero se planteará su rol en la

La arquitectura MVC es un método para asignar las funcionalidades entre los

Unidad 1: Introducción a JSP Libro 2: Java Empresarial 8

© Copyright IBM Corp. 2008

Los conceptos de la arquitectura MVC pueden hacerse corresponder directamente al

Figura 1.3: Arquitectura MVC Aplicada a los Componentes Web

Cuando un patrón de diseño MVC se hace corresponder al dominio de la aplicación

2.3 Indicaciones para Elegir entre Servlets y JSP

• Un componente frontal para interceptar las solicitudes de los usuarios.

Libro 2: Java Empresarial Unidad 1: Introducción a JSP 9

© Copyright IBM Corp. 2008

Los JSPs pueden ser empleados para:

• Formatear y presentar datos al cliente.

Figura 1.4: JSP Realizando Procesamiento y Presentación de la Solicitud

El rol de un controlador y un modelo puede ser representado por el Servlet, como se

Figura 1.5 Servlet Realizando Procesamiento y Acceso a la Base de Datos

Aquí el Servlet realiza el trabajo de procesar la solicitud y acceder a la base de datos,

Unidad 1: Introducción a JSP Libro 2: Java Empresarial 10

© Copyright IBM Corp. 2008

El J2EE Blueprint proporciona sólo guías y no reglas. En un ambiente donde sólo la

Sin embargo, cuando se eligen los componentes para el desarrollo de aplicaciones

2.4 Un JSP Ejemplo

Se presenta un ejemplo de un código JSP antes explicar la arquitectura JSP.