4. Curso Java JSP (Java Server Pages) - Curso 2005-2006

Samuel Marrero Lorenzo -
smarlor@iespana.es 1
J2EE – Java Server Pages
JSP

2
Introducción Servlets - JSP
En los servltes vistos anteriormente:
el texto generado para el aspecto (vista) de la interfaz
gráfica (HTML,WML, etc.) está mezclado con código Java
No es posible usar herramientas de generación de HTML,
etc. directamente
La generación del texto necesita ser escrita por una persona
con conocimientos de Java => económicamente muy
costoso
Cambios al aspecto de la interfaz gráfica requieren
recompilación, creación de un nuevo fichero .war y
rearranque del servidor
En una aplicación web, especialmente en Internet, los
cambios a la interfaz gráfica son muy frecuentes

3
Introducción Servlets – JSP
(2)
Situación a la que queremos llegar
Separación de roles
Personas que realizan el aspecto gráfico => diseñadores
gráficos o similares
Conocimientos de diseño gráfico y herramientas para
generación de HTML y WML
Personas que implementan el controlador y el modelo
=>programadores
Conocimientos de diseño e implementación
Se deberían poder usar directamente las herramientas de
diseño de páginas web
Las actualizaciones al aspecto gráfico no deben provocar un
re-arranque del servidor

4
JSP
¿ Qué es JSP ?
A modo de ejemplo, una página JSP que genera HTML
Tiene el aspecto de una página HTML
Puede incluir scriptlets (scripts) para generar HTML dinámicamente
Típicamente los scriptlets se escriben en Java
En realidad, una página JSP es un tipo especial de servlet
(javax.servlet.jsp y javax.servlet.jsp.tagext) orientado a
generar el texto de la interfaz gráfica
Invocables por GET y POST
<<interface>>javax.servlet.Servlet
<<interface>> javax.servlet.jsp.JspPage
<<interface>>javax.servlet.jsp.HttpJspPage
+ _jspService(request : HttpServletRequest, response :
HttpServletResponse) : void

5
JSP (2)
¿ Qué ocurre cuando se accede a una página
JSP ?
Si es la primera vez, el servidor de aplicaciones
genera un servlet (que implementa
javax.servlet.jsp.HttpJspPage) a partir de la
página JSP, lo compila y lo carga en memoria
Si no es la primera vez, le pasa la petición al
servlet (ya compilado y creado en memoria)
Si la página se ha modificado desde la última
compilación, el servidor se da cuenta, genera el
nuevo servlet, lo compila y lo carga de nuevo

6
Primer ejemplo de JSP
<%@page language="java"%> directiva
<HTML> HTML
<HEAD>
<TITLE>Primer ejemplo JSP</TITLE>
</HEAD>
<BODY>
<%if(request.getParameter("nombre")==null){%> scriptlet
<H1>Hola Mundo</H1>
<%}else {%>
<H1>Hola <%=request.getParameter("nombre")%></H1>
<%}%> Expresión
</BODY>
</HTML>
Código: c:javaJSP1-HolaMundoHolaMundoHolaMundo.jsp

7
Servlet generado por el servidor
Tomcat a partir del código JSP
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
public final class HolaMundo_jsp extends org.apache.jasper.runtime.HttpJspBase
implements org.apache.jasper.runtime.JspSourceDependent {
private static java.util.Vector _jspx_dependants;
public java.util.List getDependants() {
return _jspx_dependants;
}
public void _jspService(HttpServletRequest request, HttpServletResponse response)
throws java.io.IOException, ServletException {
JspFactory _jspxFactory = null;
PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
JspWriter _jspx_out = null;
PageContext _jspx_page_context = null;
try {
_jspxFactory = JspFactory.getDefaultFactory();
response.setContentType("text/html");
pageContext = _jspxFactory.getPageContext(this, request, response,true, 8192, true);

8
Servlet generado por el servidor
Tomcat a partir del código JSP
_jspx_page_context = pageContext;
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("rn"); out.write("rn"); out.write("<HTML>rn"); out.write("<HEAD>rn"); out.write("<TITLE>Primer ejemplo JSP</TITLE>rn");
out.write("</HEAD>rn"); out.write("<BODY>rn"); out.write("rn");
if(request.getParameter("nombre")==null){
out.write("rn"); out.write("rn");
out.write("t<H1>Hola Mundo</H1>rn");
out.write("rn");
}else {
out.write("rn");
out.write("rn");
out.write("t<H1>Hola ");
out.print(request.getParameter("nombre"));
out.write("</H1>rn");
out.write("rn");
}
out.write("rn"); out.write(" trn"); out.write("</BODY>rn"); out.write("</HTML>");
} catch (Throwable t) {
if (!(t instanceof SkipPageException)){
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
out.clearBuffer();
if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);
}
} finally {
if (_jspxFactory != null) _jspxFactory.releasePageContext(_jspx_page_context);
}
}
}

9
Expresiones
Expresión JSP: <%= expression %>
La expresión es evaluada y situada en la salida.
<%=request.getParameter(“nombre”)%>
Escribe en la salida el parámetro ‘nombre’ del objeto petición
‘request’
El equivalente XML es
<jsp:expression> expression </jsp:expression>.
Las variables predefinidas son request, response, out,
session, application, config, y pageContext.

10
Scriptlets
Scriptlet JSP: <% código Java %>
El código se inserta en el método
service del servlet generado
El equivalente XML es:
<jsp:scriptlet>código</jsp:scriptlet>

11
JSP1-HolaMundo
Scriptlets
<%if(request.getParameter("nombre")==null)
{
out.println(“<H1>Hola Mundo</H1>”);
}else {
out.println(“<H1>Hola”+
request.getParameter("nombre")+”</H1>”);
}
%>
Fíjate que aquí se utiliza en objeto out para escribir la salida,
equivalente al PrintWriter usado en servlets
El código está disponible en el directorio JSP1-HolaMundo
c:javaJSP1-HolaMundoHolaMundoHolaMundo.jsp

12
Declaraciones
Declaración JSP: <%! Código Java %>
El código se inserta en el cuerpo de la
clase del servlet generado, fuera del
método service, como un atributo de la
clase servlet.
<jsp:declaration>código</jsp:declaration>

13
Ejemplo de declaración
El siguiente ejemplo implementa un
contador de visitas a una página
<%! private int accesos = 0; %>
Visitas a la página desde el arranque del servidor
<%= ++accesos %>

14
Directiva page
Directiva page JSP: <%@ page atributo=“valor" %>
Dirige al motor servlet sobre la configuración general.
El equivalente XML es: <jsp:directive.page language=“java">.
Los atributos legales son (con los valores por defecto en negrita):
import="package.class"
contentType="MIME-Type"
isThreadSafe="true|false"
session="true|false"
buffer="sizekb|none"
autoflush="true|false"
extends="package.class"
info="message"
errorPage="url"
isErrorPage="true|false"
language="java"

15
La directiva page (2)
import="paquete.clase1,...,paquete.claseN".
Por ejemplo: <%@ page import="java.util.*" %> El atributo import es el
único que puede aparecer múltiples veces.
contentType="MIME-Type; charset=Character-Set" Esto especifica
el tipo MIME de la salida. El valor por defecto es text/html.
Por ejemplo, la directiva: <%@ page contentType="text/plain" %> tiene el
mismo valor que el scriptlet <% response.setContentType("text/plain");
%>
isThreadSafe="true|false". Un valor de true (por defecto) indica un
procesamiento del servlet normal, donde múltiples peticiones pueden
procesarse simultáneamente con un sólo ejemplar del servlet.
Un valor de false indica que el servlet debería implementar
SingleThreadModel, con peticiones enviadas serialmente.

16
session="true|false". Un valor de true (por defecto) indica que la
variable predefinida session (del tipo HttpSession) es la sesión si existe,
si no existe, se crea una nueva sesión.
Un valor de false indica que no se usarán sesiones, y los intentos de
acceder a la variable session resultarán en errores en el momento en que la
página JSP sea traducida a un servlet.
buffer="sizekb|none". Esto especifica el tamaño del buffer para el
JspWriter out. El valor por defecto es específico del servidor, debería
ser de al menos 8kb.
autoflush="true|false". Un valor de true (por defecto) indica que el
buffer debería descargase cuando esté lleno. Un valor de false,
raramente utilizado, indica que se debe lanzar una excepción cuando el
buffer se sobrecargue. Un valor de false es ilegal cuando usamos
buffer="none".

17
extends="paquete.superclase". Esto indica la superclase del servlet
que se va a generar. Debemos usarla con extrema precaución, ya que
el servidor podría utilizar una superclase personalizada.
info="message". Define un string que puede usarse para ser
recuperado mediante el método getServletInfo.
errorPage="url". Especifica una página JSP que se debería procesar si
se lanzará cualquier Throwable pero no fuera capturado en la página
actual.
isErrorPage="true|false". Indica si la página actual actúa o no como
página de error de otra página JSP. El valor por defecto es false.
language="java". En algunos momentos, esto está pensado para
especificar el lenguaje a utilizar. Por ahora, no debemos precuparnos
por él ya que java es tanto el valor por defecto como la única opción
legal.

18
Ejemplo JSP2 - TablaHTML
En el siguiente ejemplo se muestra la
construcción en JSP de una tabla de los
valores trigonométricos
Código TablaHTML.jsp: c:javaJSP2-
TablaHTMLTablaHTMLTablaHTML.jsp
Claves:
<%@ page import="java.io.*,java.text.*,java.util.*" %>
<%! private static final DecimalFormat FMT1 = new DecimalFormat("#0");%>
<% for (double gdo = 0; gdo <= 45; gdo += 1.0) { %> …

19
Directiva include
Directiva include JSP:
<%@ include file="url" %>
Un fichero del sistema local se incluirá cuando
se traduce de JSP a servlet.
<jsp:directive.include file="url">.
La URL debe ser relativa.
Usamos la acción jsp:include para incluir un
fichero en el momento de la petición en vez
del momento de la tradución.

20
Comentarios
Comentario JSP: <%-- comment --%>
Comentario ignorado cuando se traduce
la página JSP en un servlet.
Si queremos un comentario en el HTML
resultante, usamos la síntaxis de
comentario normal del HTML <--
comment -->.

21
Objetos implícitos en páginas
JSP
Objeto application Se corresponde con el ServletContext
obtenido mediante getServletConfig().getContext().
Objeto request HttpServletRequest, objeto proveniente de
la petición del cliente o de una redirección
Objeto response HttpServletResponse, objeto que
representa la respuesta
Objeto session HttpSession asociado con el request (si
existe una sesión)
Objeto out el PrintWriter (una versión con buffer del tipo
JspWriter) usada para envíar la salida al cliente (navegador).

22
Convenciones en JSP
Surge la siguiente cuestión:
"¿Cómo estructuramos el código JSP
para que sea fácil de leer, de escribir y
de mantener? “

23
Ficheros y su localización
Tipo de Fichero Extensión Localización Recomendada
JSP .jsp <contexto>/<subsystem path>/
Fragmento JSP .jsp <contexto>/<subsystem path>/
Fragmento JSP .jspf <contexto>/WEB-INF/jspf/<subsystem path>/
CCS .css <contexto>/css/
javascript .js <contexto>/js/
página HTML .html <contexto>/<ruta>/
fuente web .gif, .jpg, etc. <contexto>/images/
TLD .tld <contexto>/WEB-INF/tld/

24
Acceso a base de datos desde
JSP
JSP utiliza JDBC para acceder a base de
datos.
No necesita etiquetas especiales para
acceder a base de datos.

25
JSP con el código de acceso a
BD incrustado
Uso de scritplets que utilizan JDBC para
acceder a la BD.
No es necesaria la captura de
excepciones, JSP hace el trabajo
automáticamente.
Cuando recuperamos resultados de una
consulta aparecerá código HTML dentro
del bucle para ir mostrando cada fila.

26
Ejemplo JSP4-JDBC
Esta aplicación crea una conexión con la base
de datos ‘agenda’ y lista todos los contactos
de la tabla ‘Contactos’
MostrarTodos.jsp:
Código: c:javaJSP4-JDBCMostrarTodos.jsp
El driver JDBC de la base de datos tiene que estar
incluído en el directorio <contexto>/WEB-INF/lib
Los scriptlets de Java en este ejemplo están
mezclados con el código HTML haciendo difícil
el manejo y mantenimiento de esta aplicación

27
Optimización del diseño de las
aplicaciones
Objetivo: separar en capas la lógica de las
aplicaciones
Vista: en páginas JSP
Modelo: para el modelo y la lógica de negocio se
van a utilizar JavaBeans y clases Java
A este modelo se le conoce como Modelo 1, y
es el primer paso para llegar al modelo MVC
Más adelante veremos el Modelo 2 que
además proporciona el control de la
aplicación de forma separada. En ocasiones
también denominado MVC

28
Modelo 1: Acceso a través de
Beans
Una forma habitual de utilizar BD con JSP es utilizar
componentes JavaBean de apoyo.
De esta forma mantenemos independiente la
presentación y el acceso a datos, esto es fundamental
para facilitar el mantenimiento de la aplicación.

29
Introducción a JavaBeans
¿Qué es un JavaBean?
Un JavaBean es una clase Java
Representa un objeto del modelo, por
ejemplo un cliente
Proporciona métodos para leer y modificar
sus variables o atributos
<tipo> getAtributo () {…}
void setAtributo (<tipo> valor) {...}

30
Proceso para recuperar datos
a través de un JavaBean
El Bean se encarga de conectar con la BD y
ejecutar la sentencia deseada.
El bean proporciona métodos para
posicionarse en cada fila de la consulta.
A través de las propiedades del JavaBean
podemos acceder a los valores de cada uno
de los campos.
Las propiedades de un JavaBean se
representan muy fácilmente en una página
JSP.

31
Acción jsp:useBean
Acción jsp:useBean
<jsp:useBean at1=val1 at2=val2 …/>
<jsp:useBean atri=val*> ... </jsp:useBean>
Encuentra o construye un Java Bean. Los
posibles atributos son:
id="name"
scope="page|request|session|application"
class="package.class"
type="package.class"
beanName="package.class"

32
Acción jsp:setProperty
Acción jsp:setProperty:
<jsp:setProperty atrib=val …/>
Modifica las propiedades del bean, bien
directamente o designando el valor que viene
desde un parámetro de la petición.
Los atributos legales son:
name=“nombre del bean"
property=“propiedad del bean|*"
param=“nombre del parámetro"
value=“valor"

33
Acción jsp:getProperty
Acción jsp:getProperty:
<jsp:getProperty
name=“nombrePropiedad" value="valor"/>
Recupera y saca las propiedades del
Bean.

34
Ejemplo de utilización de
<jsp:useBean>
Ejemplo de uso:
<jsp:useBean id="pool" scope="application"
class="Clientes.Pool"/>
En este ejemplo se obtiene o crea el
objeto ‘pool’, con ámbito de aplicación y
a partir del JavaBean Pool del paquete
Clientes

35
Estructura del JavaBean para
acceso a BD
Constructor del JavaBean:
conexión con la base de datos.
realización de la consulta.
Guardar resultados en una estructura local al Bean.
establecer los valores de las propiedades.
cerrar la conexión.
Método para recorrer los resultados.
Recargando las propiedades cada vez que cambie.
Propiedades se corresponden con los campos
de la tabla.

36
Ejemplo Modelo 1.
JSP5-JDBC-CliPool
Este ejemplo de aplicación web utiliza un
JavaBean y clases Java que permiten
recuperar resultados de una BD, usando un
pool de conexiones.
Vista: varias páginas JSP
Modelo: clases Java
BDClientes: realiza las consultas y acciones en la BD
Cliente: JavaBean que representa el objeto Cliente del
modelo
Pool: Es el objeto que conecta con la base de datos y
permite obtener la conexión cuando sea solicitada

37
Ejemplo Modelo 1.
JSP5-JDBC-CliPool (2)
Clase BDClientes, métodos estáticos:
obtenerClientes(): hace la consulta sobre la BD y
guarda resultados en un vector interno, para
visualizar en JSP.
obtenerCliente(): crea un objeto cliente a partir de
su identificador para pasarlo a la página JSP.
insertarCliente(): inserta un nuevo cliente dado
por el usuario en una página JSP.
eliminarCliente(): elimina un cliente dado por el
usuario en una página JSP.

38
Ejemplo Modelo 1.
JSP5-JDBC-CliPool (3)
Clase Cliente, JavaBean:
Contiene las propiedades de un cliente y los
métodos getProp y setProp
Clase Pool, JavaBean:
Constructor: crea un objeto DataSource para la
conexión con la BD ‘agenda’
getConnection: obtiene una conexión a partir de la
asociación de conexiones
freeConnection: cierra la conexión, devolviéndola
a la asociación de conexiones

39
Ejemplo JSP5-JDBC-CliPool
Modelo
Modelo: código de las clases Java:
Clase BDClientes: c:javaJSP5-JDBC-
CliPoolCliPoolWEB-
INFsrcClientesBDClientes.java
Clase Cliente: c:javaJSP5-JDBC-
CliPoolCliPoolWEB-INFsrcClientesCliente.java
Clase Pool: c:javaJSP5-JDBC-
CliPoolCliPoolWEB-INFsrcClientesPool.java

40
Vistas (2)
Vista: código de las páginas JSP
index.jsp: c:javaJSP5-JDBC-CliPoolCliPoolindex.jsp,
presenta el formulario para agregar un contacto de cliente
InsertarCliente.jsp: c:javaJSP5-JDBC-
CliPoolCliPoolInsertarCliente.jsp, inserta un cliente
EliminarCliente.jsp: c:javaJSP5-JDBC-
CliPoolCliPoolEliminarCliente.jsp, elimina un cliente
MostrarClientes.jsp: c:javaJSP5-JDBC-
CliPoolCliPoolMostrarClientes.jsp, muestra los clientes
VerCliente.jsp: c:javaJSP5-JDBC-
CliPoolCliPoolVerCliente.jsp, visualiza un cliente

41
Ficheros de configuración
web.xml: c:javaJSP5-JDBC-CliPoolCliPoolWEB-INFweb.xml
Fragmento de código a insertar en server.xml, entre las etiquetas
<Host>
<Context path="/JSP5-JDBC-CliPool" docBase="/JSP5-JDBC-
CliPool/CliPool" debug="0" reloadable="true" crossContext="true">
<Resource name="jdbc/dsAgenda"
auth="Container"
type="javax.sql.DataSource"/>
<ResourceParams name="jdbc/dsAgenda">
…Parametros…
</Context>

42
Ficheros de configuración (2)
Parámetros de conexión en server.xml
<parameter>
<name>username</name>
<value>curso_java</value>
</parameter>
<parameter>
<name>password</name>
<value>curso_java</value>
</parameter>
<parameter>
<name>driverClassName</name>
<value>oracle.jdbc.driver.OracleDriver</value>
</parameter>
<parameter>
<name>url</name>
<value>jdbc:oracle:thin:@10.1.1.36:1521:DESA</value>
</parameter>
</ResourceParams>

43
Limitaciones del Modelo 1
Tiene cierta separación entre contenido y
presentación, por lo que es buena para pequeñas
aplicaciones Web.
El hecho que la lógica de presentación normalmente
conduzca a una considerable cantidad de código Java
embebido en el JSP en el formato de scriptlets, hace
que sea una pesadilla para los desarrolladores Java
experimentados el mantenimiento de estos sistemas.
Fíjate que en el Modelo 1, JSP es responsable de:
Procesar la petición y la respuesta al cliente (lógica de
presentación)
Problema sobretodo para los diseñadores de páginas JSP
que no programan código en Java

45
Componentes en el Modelo 2
Se implementa al igual que en el Modelo 1,
la vista con páginas JSP
el modelo con clases Java o JavaBeans
En el Modelo 2 además se implementa un
sistema de controladores (MVC)
En éste modelo, un controlador maneja las
solicitudes del usuario, en lugar de lidiar con otro
JSP.
El controlador o “controller” es implementado
como un servlet.

46
Misión del servlet Controlador
Aquí el servlet actúa como el
Controlador y está al cargo
del procesamiento de las peticiones
de la creación de cualquier JavaBean u
objeto usado por el JSP
así como, dependiendo de las acciones del
usuario, a qué página JSP redirigir la
petición

47
Pasos en el Modelo 2
Los siguientes pasos son ejecutados cuando el usuario envía
una solicitud:
1. El servlet Controlador atiende la solicitud.
2. El servlet Controlador instancia el JavaBeans apropiado,
basado en los parámetros de la solicitud.
3. El JavaBeans se comunica con la base de datos para retirar
los datos requeridos.
4. El Controlador ajusta el JavaBeans resultante, en uno de los
siguientes contextos: request, session o aplicación.
5. El Controlador entonces despacha la solicitud a la siguiente
vista basado en la URL solicitante.
6. La vista usa el JavaBeans del paso 3, para desplegar los
datos.

48
Ejemplo de Modelo 2
Esta pequeña aplicación ejemplifica el
uso del Modelo 2
Descripción:
Tienda en Internet de venta de cd’s
El usuario dispone de un carrito de compra
donde se almacenan, usando una sesión,
los cd’s que este compra

49
Ejemplo de Modelo 2
Componentes
Los componentes son:
Modelo: un JavaBean que representa el
objeto del negocio CD.java
Controlador: un servlet ServletCompra.java
que realiza las redirecciones a las vistas y
la creación de los Beans necesarios
Vista: varios ficheros .jsp que permiten al
usuario interactuar con la aplicación

50
Ejemplo JSP8-Modelo2
Modelo: CD.java
Es una clase java que representa un CD de
música con las propiedades siguientes:
Album, artista, país, precio, cantidad
Métodos: como en todo JavaBean se
proporcionan los métodos getXXX y setXXX
Código: c:javaJSP8-Modelo2WEB-
INFsrcshoppingcd.java

51
Controlador: ServletCompra.java
Comprueba la acción a realizar
Realiza la acción insertando los valores
necesarios en la sesión, si existe
Redirige la salida a la vista adecuada

52
Funcionamiento del controlador
ServletCompra.java:
Acción ‘Agregar’: Añade el cd seleccionado a la
sesión y redirige la salida a Tienda.jsp
Acción ‘Borrar’: Borra el cd seleccionado de la
sesión y redirige a Tienda.jsp
Acción ‘Comprar’: Calcula el total y redirige a
Comprar.jsp
Código: c:javaJSP8-Modelo2WEB-
INFsrcServletCompra.java

53
Vistas: son las páginas JSP
Tienda.jsp: página de entrada, muestra el
catálogo de CD’s disponibles
c:javaJSP8-Modelo2Tienda.jsp
Carrito.jsp: esta página se incluye en la anterior y
muestra los cd’s que el usuario ha ido metiendo
en el carrito
c:javaJSP8-Modelo2Carrito.jsp
Comprar.jsp: muestra el contenido del carrito y el
total a pagar cerrando la sesión

54
Ventajas del Modelo 2
Como no hay lógica de presentación en el
JSP, no hay necesidad de demasiados
scriptlets.
Se pueden tener múltiples controladores en la
aplicación Web,
aunque normalmente, se suele usar 1 solo.
Las aplicaciones Web son más sencillas de
mantener y extender, ya que las vistas no
refieren unas a otras, y no hay lógica de
presentación en ellas.

55
Acción jsp:include
Acción jsp:include:
<jsp:include page="relative URL" flush="true"/>
Incluye un fichero en el momento en que la
página es solicitada.
Aviso: en algunos servidores, el fichero
incluido debe ser un fichero HTML o JSP,
según determine el servidor (normalmente
basado en la extensión del fichero).

56
Acción jsp:forward
Acción jsp:forward
<jsp:forward page="URL relativa"/>
Reenvía la petición a otra página.

57
Acción jsp:plugin
Acción jsp:plugin:
<jsp:plugin attribute="value"*> ...
</jsp:plugin>
Genera etiquetas OBJECT o EMBED,
apropiadas al tipo de navegador,
pidiendo que se ejecute un applet
usando el Java Plugin.

58
Tags personalizadas
En las páginas JSP se usa código HTML, XML, Java e
incluso se usan etiquetas que encapsulan parte de la
lógica.
El uso de la etiqueta <jsp:useBean> en conjunción
con los JavaBeans hace que podamos separar la
lógica de presentación de la de proceso y
consigue unos archivos JSP mas claros,
y lo que es mas importante, el que escribe la JSP, no tiene
por que tener unos conocimientos avanzados de
programación para crear páginas JSP de funcionalidades
avanzadas.

59
Tipos de etiquetas
Hay dos tipos principales de etiquetas,
etiquetas que no tienen cuerpo. Ejemplo:
<img src=“canteras.gif”>
etiquetas que si lo tienen. Ejemplo:
<title>Las Canteras</title> que tiene
cuerpo y etiqueta de final.
Estos son dos tipos de etiquetas que
podemos crear en Java

60
Etiquetas personalizadas JSP
JSP sigue una sintáxis XML por lo tanto
Etiquetas sin cuerpo: <jsp:etiqueta/>
Etiquetas con cuerpo: <jsp:etiqueta> … </jsp:etiqueta>
Para crear etiquetas a medida debemos implementar
o heredar de otras clases
Interface Tag  interface general
Clase TagSupport  creación de etiquetas sin cuerpo
Clase BodyTagSupport  creación de etiquetas con cuerpo
En los ejemplos siguientes trabajaremos extendiendo
la clase TagSupport y BodyTagSupport que son
simplificaciones del interface Tag

61
Clase TagSupport
Las clase TagSupport suministra una serie de
métodos que sobreescribiremos para crear
una etiqueta. Estos son algunos:
doStartTag(): se invoca cuando se encuentra la
etiqueta de apertura
doEndTag(): se invoca cuando se encuentra la
etiqueta de cierre
doAfterBody(): se invoca una vez se ha obtenido
el contenido del cuerpo, cuando éste existe

62
Primer ejemplo JSP6-
HolaMundoTag
Diseñaremos una etiqueta sin cuerpo que
escribirá el mensaje “Hola Mundo” en el
cliente:
<JSP6:holamundo/>
Siguiendo la sintáxis XML, de documentos bien
formateados
Código y configuración:
Clase de la etiqueta: c:javaJSP6-
HolaMundoTagWEB-
INFsrcejemplosHolaMundoTag.java

63
JSP6-HolaMundoTag
Ficheros de configuración:
Definir el descriptor de librería de etiquetas
(Tag Library Descriptor) o TLD, en este
caso JSP6.tld: c:javaJSP6-
HolaMundoTagWEB-INFJSP6.tld
web.xml: c:javaJSP6-
HolaMundoTagWEB-INFweb.xml

64
Tag Library Descriptor (TLD)
JSP6.tld
Este fichero de configuración, situado en
<contexto>/WEB-INF, describe el formato del
conjunto de las etiquetas una librería.
En este caso la librería recibe el nombre de ‘JSP6’ y
describe una etiqueta de nombre ‘holamundo’
<tag>
<name>holamundo</name>
<tagclass>HolaMundoTag</tagclass>
<bodycontent>empty</bodycontent>
<info>Saludo</info>
</tag>

65
JSP6-HolaMundo
web.xml
El descriptor de despliegue de la aplicación
JSP6-HolaMundo: web.xml
Asigna un uri a la localización de la librería,
para poder referirnos a ella en las páginas
JSP, en este caso mediante el uri = ‘/JSP6’
<taglib>
<taglib-uri>/JSP6</taglib-uri>
<taglib-location>/WEB-INF/JSP6.tld
</taglib-location>
</taglib>

66
JSP6-HolaMundo
HolaMundo.jsp
HolaMundo.jsp: c:javaJSP6-
HolaMundoTagHolaMundo.jsp

<%@ taglib uri="/JSP6" prefix="JSP6"
%>
<HTML>
<HEAD>
<TITLE>Tag Hola Mundo</TITLE>
</HEAD>
<JSP6:holamundo/>
</BODY>
</HTML>

67
Página HolaMundo.jsp
Directiva taglib
Una directiva taglib declara las librerías de etiquetas
usadas por el JSP. Un directiva corta se declara en
una sola línea. Si tenemos varias directivas taglib se
deben almacenar juntas en la misma localización
dentro del cuerpo JSP:
<%@ taglib uri=“/JSP6" prefix=“JSP6" %>, en este ejemplo
Sólo deberíamos importar librerías de etiquetas que
realmente se van a utilizar en la página JSP.
Desde JSP 1.2, esta altamente recomendado utilizar
la JSP Standard Tag Library en nuestra aplicación
web para reducir la necesidad de scriptlets JSP en
nuestras páginas. Las páginas que usan JSTL son, en
general, más fáciles de leer y de mantener.

68
Constantes de las etiquetas
personalizadas
SKIP_BODY : indica en el método que la
etiqueta no tiene cuerpo o que no quiere
seguir evaluándolo
EVAL_PAGE : indica en el método doEndTag()
que se procede a evaluar el resto de la
página JSP
SKIP_PAGE : indica que no se siga evaluando
la página JSP
EVAL_BODY_AGAIN: indica que se vuelva a
evaluar el cuerpo, en caso de bucles

69
Etiquetas personalizadas con
parámetros
Vamos a ver una etiqueta con parámetros del
tipo
<JSP6:suma num1=2 num2=3/>, que suma los
números 2+3
Por cada parámetro que queremos que
soporte la etiqueta, se proporciona un
método set como en un javabean
El código de la clase SumaTag lo veremos a
continuación

70
SumaTag.java
Esta etiqueta no tiene cuerpo por lo que será
igual que la anterior excepto que se añaden
los métodos set
Código: c:javaJSP6-HolaMundoTagWEB-
INFsrcejemplosSumaTag.java
Mediante los métodos set los valores de los
parámetros son cargados automáticamente
en la clase

71
Modificación del Tag Library
Descriptor (TLD)
JSP6.tld: c:javaJSP6-HolaMundoTagWEB-
INFJSP6.tld
Uso de etiquetas para describir parámetros:
<attribute>
<name>num1</name>
<required>true</required>
<rtexprvalue>false</rtexprvalue> </attribute>
</attribute>
<rtextprvalue> indica si tiene o no que ser
evaluada en tiempo de ejecución

72
Etiquetas personalizadas con
cuerpo
Vamos a crear una etiqueta con cuerpo
y parámetro que realice un bucle.
<JSP7:bucle veces=“7”>
<JSP7:holamundo/> cuerpo
</JSP7:bucle>
La clase BucleTag extenderá la clase
BodyTagSupport

73
Ejemplo JSP7-BucleTag
BucleTag.java :c:javaJSP7-BucleTagWEB-
INFsrcejemplosBucleTag.java
JSP7.tld: c:javaJSP7-BucleTagWEB-
INFJSP7.tld
<bodycontent>JSP</bodycontent>
Indica que el contenido del cuerpo puede ser
HTML, texto o etiquetas JSP
Bucle.jsp: c:javaJSP7-BucleTagBucle.jsp
web.xml: c:javaJSP7-BucleTagWEB-
INFweb.xml

4. Curso Java JSP (Java Server Pages) - Curso 2005-2006

Más contenido relacionado

La actualidad más candente

Destacado

Similar a 4. Curso Java JSP (Java Server Pages) - Curso 2005-2006

Último

4. Curso Java JSP (Java Server Pages) - Curso 2005-2006