Curso JSP Mas

JAVASERVER PAGES
Módulo: J2EE Tema: JavaServer Pages ( JSP ) 1

Introducción
JavaServer Pages, JSP combina HTML con fragmentos de Java para producir
páginas web dinámicas. La tecnología permite generar páginas dinámicas a
través de la inclusión de código Java en la propia HTML.
El fichero que contiene la página HTML tiene la extensión .jsp, y se almacena
en el mismo sitio que una página web normal.
Cuando un cliente pide una página JSP del sitio web y no se ha ejecutado
antes, la página es pasada al motos de JSP, el cual complila la página
convirtiendola en un servlet, la ejecuta y devuelve el contenido de los
resultados al cliente.
Es posible ver el código del servlet generado, este código debe estar en una
carpeta del servidor, dependiendo ésta del tipo de servidor utilizado.
Se generan las siguientes clases:
JSPPages
HttpJspPages
Se encuentran también tres métodos:
_jspInit()
_jspDestroy()
_jspService()
Los dos primeros métodos pueden ser definidos por el programador de la
página JSP, pero el tercer método es la versión compilada de la página JSP,
y la crea al motor JSP..

Funcionamiento
¿Cuál es el funcionamiento básico? Muy sencillo:

1) El cliente solicita una página .jsp
2) La solicitud llega al servidor
3) El servidor «ejecuta» la página .jsp y obtiene un texto en formato html
4) El servidor envía el texto html al cliente
5) El navegador del cliente visualiza el texto html como si realmente hubiera
estado almacenado en el servidor.

Ventajas de JSP
JSP no nos da nada que no pudierámos en principio hacer con un servlet. Pero es
mucho más conveniente escribir (y modificar!) HTML normal que tener que
hacer un billón de sentencias println que generen HTML.
Además, separando el formato del contenido podemos poner diferentes personas

en diferentes tareas: nuestros expertos en diseño de páginas Web pueden
construir el HTML, dejando espacio para que nuestros programadores de
servlets inserten el contenido dinámico.

Comentarios iniciales
Un fichero JSP empieza con un comentario del lado del serviros:
<%--
- Author (s) :
- Date :
- Copyright Notice :
- @(#)
- Description :
--%>
Este comentario sólo es visible en el lado del servidor porque se elimina durante la
traducción JSP. Dentro de este comentario están los autores, la fecha, la nota de
copyright de la revisión, un identificador y una descripción sobre el JSP para los
desarrolladores web.

Directiva(s) JSP Page ( 1 )
Una directiva page, defina atributos asociados con la página JSP en tiempo de
traducción. La especificación JSP no impone ninguna obligaciñon sobre cuántas
directivas page se pueden definir en la misma página. Por eso los fragmentos
de código que veremos a continuación son equivalentes:
<%@ page session = ”true” %>

<%@ page import = ”java.util.*” %>
<%@ page errorPage = ”/pages/errorPage.jsp” %>
Si la longitod de cualquier directivam excede de la anchura normal de una página

JSP ( 80 caracteres), se debe dividor en varias lineas:
<%@ page session = ”true”

import = ”java.util.*”
errorPage = ”/pages/errorPage.jsp” %>

Directiva(s) JSP Page ( 2 )
Tal y como podemos ver, la directiva page posee variso atributos:
languaje = ”java”: Comunica al servidor el lenguaje que va a ser utilizado en

el archivo. Java es el único posible valor en esta especificación.
extends = ”package.class”: La variable extends, define la clase padre del
servlet generado. Normalmente no es necesario utilizar otras que no sean
las de las clases base del proveedor
import = ”package.*”,”package.class”: Sirve para especificar los paquetes
y las clases que se quieran utilizar.
session = “true \ false”: Por defecto session vale true, manteniendo los
datos de las sesiones para la página.
isThreadSafe = “true \ false”: Por defecto vale true, le hace señales al motor
de JSP para que multiples pedidos del cliente puedan ser tomados como
uno solo.
info = “text”: Información en la página a la que puede accederse a través del
método Servlet.getServletInfo().
errorPage = “pagina_error”: Página que manejará las excepciones de
errores.
isErrorPage = “true \ false”: Marca a la página como la página que manejará
los errores.

Directiva(s) JSP Include
Esta directiva nos permite incluir ficheros en el momento en que la página JSP es
traducida a un servlet. La directiva se parece a esto:
<%@ include file="url relativa" %>
La URL especificada normalmente se interpreta como relativa a la página JSP a la

que se refiere, pero, al igual que las URLs relativas en general, podemos decirle
al sistema que interpreta la URL reltativa al directorio home del servidor Web
empezando la URL con una barra invertida. Los contenidos del fichero incluido
son analizados como texto normal JSP, y así pueden incluir HTML estático,
elementos de script, directivas y acciones.

Directiva(s) Tag Library
Una directiva taglib declara las librerías de etiquetas usadas por el JSP. Una
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=”URI1” prefix=”tagprefix1” %>

<%@ taglib uri=”URI2” prefix=”tagprefix2” %>
Al igual que la directiva page, si la longitud de una directiva taglib excede la

anchura de 80 caracteres, debemos dividirla en varias líneas:
<%@ taglib
uri=”URI1”
prefix=”tagprefix1” %>
Solo deberíamos importar librerías de etiquetas que realmente se van a utilizar en

la página JSP.

Declaraciones JSP
Las declaraciones JSP declaran métodos y variable pertenecientes a la JSP.

Estos métodos y variables no se diferencian de los declarados en el lenguaje
Java, y por lo tanto se deberían seguir las convenciones de codificación más
importantes.
Es perferible que las declaraciones estén en un solo bloque de declaración
JSP <%! ... %>, para centralizar las declaraciones dentro de un área del
cuerpo JSP. Aquí tenemos un ejemplo:
Bloque de declaraciones Bloque de declaraciones

disparatadas disparatadas
<%! private int cont; %> <%!

<%! private Date today; %> private int cont;
... private Date today;
<%! public int getCont() { public int getCont() {
return cont; return cont;
} }
%> %>

Script de JSP
Los script son bloques de código Java residentes entre los tags <% %>.
Los elementos de script permiten insertar código Java dentro del método
_jspService() del servlet que se generará desde la página JSP. Hay dos tipos:
Expresiones: <%= expresion %>: Una expresión JSP se usa para insertar
valores directamente en la salida.
Las expresiones no terminan en (;), ya que el motor de JSP pondrá la
expresión automáticamente dentro de out.println().
Scriptles: <% código %>: Los scriptlets JSP permiten insertar código Java
dentro del método _jspService() del servlet que será construido al general la
página.

Variables predefinidas
JSP incorpora ocho variables ya definidas, llamadas también objetos implicitos.
request: Hace referencia a HttpServletRequest. Es la petición del cliente.

response: Hace referencia a HttpServletResponse. Es la página JSP de
respuesta.
session: Hace referencia a HttpSession. Variables de sesión.
out: Hace referencia a PrintWriter usada para enviar la salida al cliente.
application: Esta variable es el ServletContext obtenido medante
getServletConfig().getContext(). Permite almacenar datos persistentes en el
objeto ServletContext en lugar de variables de instancia.
config: Hace referencia al objeto ServletConfing e la página.
pageContext: Jsp incorpora una nueva clase llamada PageContext para
encapsular características de uso específicas el servidor. Esta clase
PageContext es inicializada con los objetos response y request y algunos
atributos de la directiva de la página ( erropage, session, buffer y autoflush ).
page: Esta variable es un sinónimo de this, y no es muy util en Java.
La mayoría de estas variables de referencia se han visto y utilizado con servlets y

sus funciones y operativa son idénticas.

Comentarios
Los comentarios se utilizan para descubrir información adicional o los propósitos

del código cercano.
Los comentarios JSP( tambien conocidos del lado del servidor) sólo son visibles
en el lado del servidor (es decir, no se propagan al lado del cliente ).
Se prefieres los comentarios puros JSP sobre los comentarios JSP con
comentarios de scripts, ya que los primeros son menos dependientes del
lenguaje de script subyacente.
<%-- Comentario de JSP --%>

Ejemplo de JSP ( 1 )
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">
<%@ page language="java"

contentType="text/html; charset=ISO-8859-1"
pageEncoding="ISO-8859-1" %>
<%@ page import="java.util.*" %>
<%!
String ip = null; // IP del cliente
String host = null; // Host del cliente
Enumeration e = null;
String value = null;
String name = null;
%>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

<title>Ejemplo 1</title>
</head>

Ejemplo de JSP ( 2 )
<body>
<%
ip = request.getRemoteAddr();
host = request.getRemoteHost();
%>
<div><b>Información del cliente</b></div>
<div>ip del cliente : <%= ip %><div>
<div>host del cliente : <%= host %><div>
<hr/>
<div><b>Cabeceras</b><div>
<%
e = request.getHeaderNames();
while (e.hasMoreElements()) {
name = (String)e.nextElement();
value = request.getHeader(name);
out.println("<div>" + name + " = " + value + "</div>");
}
%>
</body>
</html>

Ejercicios
Ejercicio 1:
Realizar una gestión de usuarios, de tal forma que podamos listar, añadir
usuarios, modificar usuarios y eliminar usuarios.
Dichos usuarios se almacenarán en una tabla de una base de datos que

tendrá los siguientes campos:
pk_id - int
nombre - varchar( 80 )
departamento – varchar( 80 )
email – varchar ( 80 )
Para acceder a la zona de administración debemos de validarnos en un

formulario. Los datos de acceso los recibirá un servlet como parámetros
iniciales por medio del fichero web.xml.
Tendremos que crear un usuarioVO, un usuarioDAO y los servlets que

consideremos oportunos.

Acciones
Las acciones JSP usan construcciones de síntaxis XML para controlar el

comportamiento del motor de Servlets. Podemos insertar un fichero
dinámicamente, reutilizar componentes JavaBeans, reenviar al usuario a otra
página, o generar HTML para el plug-in Java. Las acciones disponibles incluyen:
Recuerda que, como en XML, los nombre de elementos y atributos son sensibles
a las mayúsculas.
A continuación veremos las siguientes acciones:
jsp:include
jsp:forward
jsp:useBean
jsp:getProperty
jsp:setProperty

Acción jsp:include
Esta acción nos permite insertar ficheros en una página que está siendo
generada. La síntaxis se parece a esto:
<jsp:include page="relative URL" flush="true" />
Al contrario que la directiva include, que inserta el fichero en el momento de la

conversión de la página JSP a un Servlet, esta acción inserta el fichero en el
momento en que la página es solicitada. Esto se paga un poco en la eficiencia,
e imposiblita a la página incluida de contener código JSP general (no puede
seleccionar cabeceras HTTP, por ejemplo), pero se obtiene una significante
flexibilidad.
Con el cuerpo opcional jsp:param es posible enviar campos al formulario destino.
<jsp:include page="pagina.jsp" flush="true">

<jsp:param name="id" value="valor"/>
</jsp:include>

Acción jsp:forward
Esta acción nos permite reenviar la petición a otra página. Tiene un sólo atributo,
page, que debería consistir en una URL relativa. Este podría ser un valor
estático, o podría ser calculado en el momento de la petición:
<jsp:forward page=”pagina.jsp” />

<jsp:forward page=”<%= una expresión de java %>” />
También permite incorporar parámetros en la petición de la nueva página:
<jsp:forward page=”pagina.jsp” >

<jsp:param name=”login” value=”alumno” />
</jsp:forward>
El significado de ejemplo anterior sería equivalente a :
pagina.jsp?login=alumno

Beans ( 1 )
Los JavaBeans se idearon como un mecanismo para diseñar componentes,

generalmente de tipo gráfico, que pudiesen ser reutilizados por los entornos de
desarrollo integrado(IDE).
Para ello el interfaz de un JavaBean debía ser capaz de mostrar su contenido en

tiempo de ejecución. Esta característica ha hecho que los JavaBeans se utilicen
en otos entornos, como puede ser el desarrollo de aplicaciones web.
Un JavaBean no es más que una clase java que sigue ciertas convenciones con
los nombres de sus métodos

Beans ( 2 )
Pautas en la construcción de un bean:
Una clase bean debe contar, al menos, con un constructor sin argumentos.
No debe tener variables de instancia públicas. No debe permitir el acceso
directo a las variables de instancia.
Se accede a los valores de las variable a través de métodos denominados
getXXX y setXXX.
Un método que devuelve un tipo booleano debe denominarse is en lugar de
get.
Cuando se dice que un bean tiene una propiedad “nombre”, realmente se quiere
decir que la clase tiene un método getNombre que devuelve un tipo X, y otro
método llamado setNombre que toma X como argumentod e entrada.
Los beans se utilizan principalmente para intercambiar información entre las

distintas páginas que componen la aplicación, pudiendo sustituir perfectamente
a las variables de sesión.

Beans ( 3 )
Para no «ensuciar» el código HTML de la página JSP, se suministran varias

etiquetas jsp: que permiten gestionar los JavaBeans de forma natural
Las etiquetas jsp: para gestionar JavaBeans son:
jsp:useBean: Crea un objeto (si no existe ya) de una clase que cumple ser un
JavaBean y le da un nombre. A partir de este momento ese objeto se
utilizará por su nombre
jsp:setProperty: Invoca un método setXxx de un JavaBean previamente

creado
jsp:getProperty: Visualiza el resultado devuelto por un método getXxx de un

JavaBean previamente creado

jsp:useBeans ( 1 )
Esta acción permite cargar y utilizar un JavaBean en la página JSP. La sintaxis

más simple para especifica que se usa un Bean es:
<jsp:useBean id=”name” class="package.class" />
Se puede interpretar como: generar una instancia de la clase especificada y

asociarla a la variable definida en id. Es decir:
<jsp:useBean id=”discos” class="DiscoTienda" />
Debe entenderse como:
<% DiscoTienda discos = new DiscosTienda(); %>

jsp:useBeans ( 2 )
Los atributos que admite jsp:useBean son:
id=”nombre”. Nombre que se le da a ese objeto
scope=”page|request|session|application”. Indica dónde se puede usar

dicho objeto:
page: Valor por defecto. Sólo está disponible para la página actual.
request: Indica que el bean sólo está disponible para la petición actual.
session: Indica que está disponible para todas las páginas durante el
tiempo de vida de la sesión actual.
application: Existirá hasta que se cierre el servidor JSP. Disponible

para todo el mundo siempre.
class=”Clase.class”. Nombre completo del bean.
La importancia del ámbito radica en que sólo se generará una instancia si no

existe un bean con el mismo id y scope.:

jsp:setProperty( 1 )
Se usa jsp:setProperty para establecer los valores de la propiedad de los beans.

Se puede utilizar en dos contextos diferentes.
jsp:useBeans debe escribirse en el códifgo antes de utilizar jsp:setProperty.
Primero, se puede usar fuera de un elemento jsp:useBean:
<jsp:useBeans id=”discos” class=”DiscosTienda” />
<jsp:setProperty name=”discos” Property=”titulo” value =”Disco 1” / >
En este caso, el jsp:setProperty se ejecuta independientemente de si se ha
instanciado un nuevo bean o se ha encontrado uno ya existente. Sería
equivalente a:
<% discos.setTitulo( “Disco 1” ) %>
La segunda forma de usar jsp:setProperty es dentro del cuerpo de un elemento
jsp:useBean:
<jsp:useBeans id=”discos” class=”DiscosTienda” >
<jsp:setProperty name=”discos” Property=”titulo” value =”Disco 1” / >
</jsp:useBeans>
Aquí el jsp:setProperty sólo se ejecuta si se ha instanciado un nuevo objeto, no si
se encontró uno ya existente.

jsp:setProperty( 2 )
jsp:setProperty tiene cuatro posibles atributos:

name: Atributo necesario. Designa el bean cuya propiedad va a ser
seleccionada.
property: Atributo necesario. Indica la propiedad a la que se accede.
value: Atributo opcional. Especifica el valor para la propiedad.
param: Atributo opcional. Indica el parámetro de la petición del que se debería
derivar la propiedad, es decir, el nombre del campo del formulatio que llega
al servidor.
En el caso de utilizar param se debe tener en cuenta que si con la petición no

llega dicho parámetro, no se hará nada.
No se puede usar value y param juntos.
Si en la propiedad property se pone un “*” se quiere decir que automáticamente

asigne el valor a las propiedades del bean a través de los datos aportados por
los parámetros de la petición de página cuando el nombre corresponda con la
propiedad. En este caso se omite tanto value como param. Para que se realice
la asignación automática, los nombres de los parámetros de entrada deben
coincidir exáctamente, mayúsculas y minúsculas.

jsp:getProperty
Recupera el valor de una propiedad del bean, lo convierte a un string, y escribe el

valor en la salida out. Los atributos necesarios son:
name: Nombre del id del bean referenciado previamente con jsp:useBean.
property: Nombre de la propiedad cuyo valor se desea recuperar.
Ejemplo:
<html><head><title>Ejemplo de Bean</title></head>
<body>
<jsp:useBean id=”discos” class=”DiscosTienda” >
<jspSetroperty name=”disco” property=”id” />
<ul>
<li>
Titulo del disco:
<jsp:getProperty name=”disco” property=”titulo” />
</li>
</ul>
</body></html>

Ejemplo ( 1 )
Fichero StringBean.java
/*Un JavaBean sencillito que sólo tiene un campo

llamado mensaje de tipo String */
package business.vo;
public class StringBean {
private String mensaje = "Ningún mensaje";
public String getMensaje() {

return(mensaje);
}
public void setMensaje(String mensaje) {

this.mensaje = mensaje;
}
}

Ejemplo ( 2 )
Fichero StringBean.jsp
<htmlL>
<head><title>Uso de JavaBeans con JSP</title></head>
<body>
<div>Uso de JavaBeans con JSP</div>
<jsp:useBean id="stringBean" class="business.vo.StringBean" />
<ul>
<li>Valor inicial (getProperty):
<jsp:getProperty name="stringBean" property="mensaje" />
</li>
<li>
<jsp:setProperty name="stringBean" property="mensaje"
value="Texto" />
Valor después de haber cambiado el campo con setProperty:
<jsp:getProperty name="stringBean" property="mensaje" />
</Ii>
</ul>
</body>
</html>

Ejercicios
Ejercicio 1:
Tendremos que realizar una página JSP que nos muestre un formulario con
los datos personales de un usuario.
Una vez que rellenemos dicho formulario, mostraremos utilizando beans los
datos de ese usuario por pantalla.
Primero cargaremos los datos del usuario los cargaremos poniendo en el

property los nombres de las propiedades.
<jsp:setProperty name="usuarioVO" property="propiedad" />
Una vez realizado ésto, probaremos a ver que pasa poniendo un *.
<jsp:setProperty name="usuarioVO" property="*" />

Ejercicios
Ejercicio 2:
Modificar la aplicación anterior, de tal forma que vamos a tener una página de
inicio que lo único que hará será redirigirnos a otra págia principal utilizando
la acción apropiada.
Esa página principal estaá formada por cuatro páginas incluidas mediante otra
acción.
cabecera.jsp: Tendrá la cabecera de nuesta página

cuerpo.jsp: Tendrá que realizar las tareas del ejercicio 1.
contador.jsp: Contador de visitas de nuestra página. Las visitas serán el
número de accesos a la página de los usuarios que no la hyan visitado ya
en su sesión actual.
pie.jsp: Mostraremos el pie de nuestra página.

Ejercicios
Ejercicio propuesto para casa:
Vamos a realizar un de periódico virtual donde almacenaremos distintas

noticias.
Una noticias tendrán un solo autor y podrá pertenecer a varias secciones. Por
lo que tendremos que crear cuatro tablas para almacenar la información.
noticia: pk_id, titulo, reseña, contenido, fecha de publicación, fk_autor
autor: pk_id, nombre, apellidos
Seccion: pk_id, nombre, descripción
noticia_seccion: fk_noticia, fk_seccion
En nuestra aplicación tendremos dos partes, una parte privada y una parte
publica.
Parte privada: Administración de las noticias. Debemos estar validado para
acceder a esta parte. Guardaremos los usuarios en otra tabla de la base
de datos( pk_id, login, password ).
Parte pública: Los usuarios podrán consultar las noticias por autor o por
secciones. Tambíén dispondrán de un buscador avanzado de noticias
donde tendrán diversas opciones de busqueda, como por nombre, fecha
de publicación, sección, autor, etc.
En la portada se mostrarán las cuatro últimas noticias insertadas.

JSTL
La librería JSTL ( biblioteca de etiquetas estándar de Java ) es un componente dentro

de la especificación del Java 2 Enterprise Edition (J2EE) y es controlada por Sun
MicroSystems.
El objetivo de JSTL es facilitar el trabajo a los desarrolladores de JSP.
Como se verá a lo largo de nuestro estudio, JSTL utiliza ciertas convenciones que
hacen más fácil al desarrollador el recordar la estructura interna de las etiquetas.
JSTL proporciona unas bibliotecas de etiquetas JSP, como por ejemplo::
core: <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
fmt: <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>

Problema con los scriptlets JSP
La especificación JSP ahora se ha convertido en una tecnología estándar para la

creación de sitios Web dinámicos en Java, y el problema es que han aparecido
algunas debilidades:
El código Java embebido en scriptlets es desordenado.
Un programador que no conoce Java no puede modificar el código Java

embebido, anulando uno de los mayores beneficios de los JSP: permitir a los
diseñadores y personas que escriben la lógica de presentación que actualicen
el contenido de la página.
El código de Java dentro de scriptlets JSP no pueden ser reutilizados por otros
JSP, por lo tanto la lógica común termina siendo re-implementado en múltiples
páginas.
La recuperación de objetos fuera del HTTP Request y Session es complicada. Es

necesario hacer el Casting de objetos y esto ocasiona que tengamos que
importar más Clases en los JSP.

Mejora de la librería JSTL
Debido a que las etiquetas JSTL son XML, estas etiquetas se integran limpia y
uniformemente a las etiquetas HTML.
Las 4 librerías de etiquetas JSTL incluyen la mayoría de funcionalidad que será

necesaria en una página JSP. Las etiquetas JSTL son muy sencillas de usarlas
para personas que no conocen de programación, a lo mucho necesitarán
conocimientos de etiquetas del estilo HTML.
Las etiquetas JSTL encapsulan la lógica como el formato de fechas y números.

Usando los scriptlets JSP, esta misma lógica necesitaría ser repetida en todos los
sitios donde es usada, o necesitaría ser movida a Clases de ayuda.
Las etiquetas JSTL pueden referenciar objetos que se encuentren en los ambientes
Request y Session sin conocer el tipo del objeto y sin necesidad de hacer el
Casting.
Los JSP EL (Expression Language) facilitan las llamadas a los métodos Get y Set en
los objetos Java. Esto no es posible en la versión JSP 1.2, pero ahora está
disponible en JSP 2.0. EL es usado extensamente en la librería JSTL.

Desventajas de los JSTL
Los JSTL pueden agregar mayor sobrecarga en el servidor. Los scriptlets y las
librerías de etiquetas son compilados a servlets, los cuales luego son ejecutados
por el contenedor. El código Java embebido en los scriptlets es básicamente
copiado en el servlet resultante. En cambio, las etiquetas JSTL, causan un poco
más de código en el servlet. En la mayoría de casos esta cantidad no es
mensurable pero debe ser considerado.
Los scriptlets son más potentes que las etiquetas JSTL. Si desea hacer todo en un
script JSP pues es muy probable que insertará todo el código en Java en él. A
pesar que las etiquetas JSTL proporciona un potente conjunto de librerías
reutilizables, no puede hacer todo lo que el código Java puede hacer. La librería
JSTL está diseñada para facilitar la codificación en el lado de presentación que es
típicamente encontrado en la capa de Vista si hablamos de la arquitectura Modelo-
Vista-Controlador.

Lenguaje de Expresión JSTL (1)
El lenguaje de expresiones (EL) sirve para facilitar la escritura de expresiones

restringidas Java dentro de una página JSP
Antes de JSTL, JSP usaba Java para referenciar atributos dinámicos. Con JSTL ya
no es necesario. Compara por ejemplo, la lectura de un parametro:
con JSP
<%= request.getParameter("login") %>
con JSTL
${param.login}.
Una expresión EL se escribe de la forma ${expresion} y entre las llaves puede usarse
cualquier operador binario o unario que se quiera, ya sea matemático, de cadena,
relacional o lógico. Es muy útil el operador unario empty para saber si algo es null
o no.
Ejemplo: ${empty param.login}

Las expresiones se componen de:
Identificadores. Hay once identificadores reservados que corresponden a once

objetos implícitos (los veremos luego). El resto de identificadores sirven para
crear variables.
Literales. Son números, cadenas delimitadas por comillas simples o dobles, y los
valores true, false, y null.
Operadores. Permiten comparar y operar con identificadores y literales.
Operadores de acceso. Se usan para referenciar propiedades de los objetos.
Podemos usar expresiones en cualquier parte del documento, o como valores de los
atributos de etiquetas JSTL, exceptuando los atributos var y scope, que no aceptan
expresiones.
En cualquier sitio donde sea valido colocar una expresión, también será válido
colocar más de una. Por ejemplo: value="Hola ${nombre} ${apellidos}".

Para acceder al campo de un bean java, o a un elemento de una colección (array, o

Map), se usa el operador punto, o el operador corchete:
${bean.propiedad}
${map.elemento}
${header['User-Agent']}
Si un campo de un bean es otro bean, podemos encadenar puntos para acceder a

una propiedad del segundo bean:
${bean1.bean2.propiedad}
Las expresiones pueden aparecer como parte del valor de un atributo de una
etiqueta:
<c:out value="${nombre}"/>
<c:if test="${tabla.indice % 2 == 0}">es par</c:if>
O independientemente junto a texto estático como el HTML:
<input type="text" name="usuario" value="${requestScope.usuario.nombre}"/>

Las siguientes variables pueden usarse directamente (todas son listas):
param: Parámetros del request como cadenas.

paramValues: Parámetros del request como array de cadenas.
header: lista con los campos de la cabecera.
headerValues: lista con los valores de los campos de la cabecera.
cookie: lista con los nombres de las cookies.
initParam: Parametros de inicialización de la aplicación Web.
pageContext: El objeto PageContext de la página actual.
pageScope, requestScope, sessionScope y applicationScope: lista con las
variables definidas en cada ámbito.
Ejemplo:
<c:forEach var=”unaCookie” items=”${cookie}”>

${unaCookie}<br>
</c:forEach>

Core Tag Library
Etiquetas para iteración sobre datos, operaciones condicionales, e importación de

datos de otras páginas
<c:out> utilizada con el mismo objetivo que el scriptlet <%= expresion %> tiene
algunas funcionalidades adicionales
<c:set> permite asignar valores a variables (p.ej., de sesión) o a propiedades de
Java Beans
<c:remove> es el complemento natural al anterior, y sirve para destruir variables
con ámbito
<c:catch> permite recuperar un error, y supone el complemento perfecto para la
página de error JSP
<c:if> emite por la salida el cuerpo que contiene sólo si la condición a que se
refiere es cierta
<c:choose>, <c:when> y <c:otherwise> permiten formar una estructura de ifs en
cascada con parte else
<c:forEach> permite recorrer una colección o un array, así como ejecutarse como
un bucle FOR
<c:forTokens> divide una cadena en trozos y se ejecuta para cada trozo

<c:out>
La sintaxis de esta etiqueta es:
<c:out value=”valor” [escapeXml=”true|false”] [default=”valorSiEsNull”] />
Emite por la salida el valor del atributo value. Si este es nulo, se saca por pantalla el
valor del atributo default.
Por defecto escapeXml está puesto a true, lo que quiere decir que se traducen
algunos caracteres para evitar errores:
El Caracter '<' se traduce autómaticamente a '<'
Puede probarse como ejemplo con la página completa:
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<c:out value="Mensaje escrito con c:out" />
El valor dado al atributo value se convierte en String y se emite, a no se que sea un

objeto de tipo java.io.Reader, en cuyo caso lo que se emite es el resultado de leer
por completo dicho canal de entrada.

Ejemplo: <c:out> y reader ( 1 )
Tenemos el siguiente Bean:
package business.vo;
import java.io.*;
public class StringBean {
private String nombreFichero = "Ningun nombreFichero";
public String getNombreFichero() {

return(nombreFichero);
}
public void setNombreFichero(String nombreFichero) {
this.nombreFichero = nombreFichero;
}
public Reader getLector() throws IOException {
return new FileReader( getNombreFichero() );
}
public void setLector(String lector) {
this.nombreFichero = lector;
}
}
Ejemplo: <c:out> y reader ( 2 )
Y el JSP sería:
<jsp:useBean id="stringBean" class="business.vo.StringBean" />
<jsp:setProperty name="stringBean" property="lector" value="e:/prueba.txt" />
<c:out value="${stringBean.lector}"/><br>
<c:out value="Otra cosa" /><br>
La salida de la línea marcada es el contenido del fichero e:\prueba.txt. De una sola

tacada se ha emitido el contenido de un fichero entero.

<c:set> y <c:remove>
La sintaxis de <c:set> es:
Para asignar valor a una variable con ámbito
<c:set value=”valor”
var=”nombreVar”
[scope=”page|request|session|application”] />
Para asignar una propiedad a un Java Bean, o un elemento de un mapa
<c:set value=”valor” target=”nombreVar” property=”nombrePropiedad” />
<c:remove> sólo tiene sentido para variables con ámbito. La sintaxis de <c:remove>
es:
<c:remove var=”nombreVar” [scope=”page|request|session|application”] />
<c:set> hace asignaciones a variable con ámbito o a propiedades de Java Beans o a

datos de Mapas. <c:remove> elimina variables con ámbito.

Ejemplo: <c:set>
En este ejemplo se ve el uso de <c:set> (no olvidar la directiva taglib):
<c:set var="aux" value="1" />

${aux}<br>
<c:set var="aux" value="${aux + 1}" />
${aux}<br>
<c:set var="cadena" value="mi nombre" />
${cadena}<br>
<c:set var="cadena" value="${cadena} es Jorge" />
${cadena}<br>

Ejemplo ( 1 )
Para demostrar el concepto de ordenamiento y mejor mantenimiento de los JSP,

veamos 2 versiones de una página simple.
La primera versión usa etiquetas scriptlets, y la segunda usa etiquetas JSTL.
Ambas páginas implementan la misma lógica. Graban una lista de objetos

AddressVO del Request y luego iteran a través de la lista, imprimiendo el atributo
apellido de cada objeto (si el apellido no es null y de longitud diferente a 0).
En cualquier otro caso, imprimirá "N/A".
Finalmente, la página imprime la fecha actual.

<c:if>
La sintaxis de <c:if> es:
<c:if test=”condicion”
[var=”nombreVar”
[scope=”page|request|session|application”]] >
// Acciones que se ejecutan si la condicion se cumple
</c:if>
Si la etiqueta <c:if> se autocierra y se indica un nombre de variable, entonces es

como si se utilizara para cargar un valor booleano en dicha variable.
Como puede verse, esta etiqueta carece de cláusula else. El motivo es que la
cláusula else, utilizada a discreción, se convierte en unos ifs en cascada
mutuamente excluyentes; y para eso, la biblioteca core suministra otras etiquetas

Ejemplo: <c:if>
Ej. de control:
<c:if test="${ empty param.nombre}" >

Se le ha olvidado escribir un valor para el nombre.<br>
</c:if>
Puede probarse a cargar una página que contenga esto pasando o no pasando en
la dirección URL el parámetro nombre.
Ejemplo de carga de valor booleano:
<c:if var="existeNombre" test="${ empty param.nombre}" />

${existeNombre}<br>

<c:choose>, <c:when> y
<c:otherwise>
Estas tres etiquetas se emplean conjuntamente según la siguiente sintaxis
<c:choose>
<c:when test=”condicion1”>
// Cuerpo que se emite si condicion1 es cierta
</c:when>
<c:when test=”condicion2”>
// Cuerpo que se emite si condicion2 es cierta
// y condicion1 es falsa
</c:when>
....
<c:otherwise>
// Cuerpo que se emite si ninguna de las
// condiciones anteriores es cierta
</c:otherwise>
</c:choose>
La estructura de estas etiquetas es la intuitiva: una vez entrado en un <c:choose> se

evalúan los <c:when> en secuencia; en el primero en que la condición sea cierta,
se emite su cuerpo y se sale del <c:choose>. Si todas las condiciones son falsas se
emite el cuerpo de <c:otherwise>.
Ejemplo: <c:choose>
El siguiente ejemplo completo comprueba los parámetros de entrada a un formulario

y emite diferentes salida en base a estos:

<h3>Saludos</h3>
<c:choose>
<c:when test="${empty param.nombre}" >
Necesito un nombre.<br>
</c:when>
<c:when test="${empty param.tiempo}" >
Necesito un tiempo.<br>
</c:when>
<c:otherwise>
¡Hombre ${param.nombre}!.<br>
¡Cuánto tiempo sin verte!<br>
Qué día más ${param.tiempo} hace.<br>
</c:otherwise>
</c:choose>

<c:forEach> ( 1 )
La sintaxis que recorre una estructura es:
<c:forEach [var=”nombreVar”]
items=”coleccion”
[varStatus=”nombreVarEstado”]
[begin=”comienzo”]
[end=”final”]
[step=”paso”] >
// Cuerpo a repetir
</c:forEach>
Para ejecutarse un determinado número de veces, la sintaxis es:
<c:forEach [var=”nombreVar”]
[varStatus=”nombreVarEstado”]
begin=”comienzo”
end=”final”
[step=”paso”] >
// Cuerpo a repetir
</c:forEach>

<c:forEach> ( 2 )
La sintaxis de la ejecución un determinado número de veces parece clara: la variable

nombreVar parte del valor comienzo hasta el valor final incrementándose en cada iteración
por paso unidades.
Si el recorrido de una colección hace uso de begin y demás, quiere decir que se comienza en el
ítem de la colección situado en posición comienzo. Si hay menos ítems que comienzo,
entonces el bucle ni se ejecuta. El primer elemento de la colección está en la posición 0.
El <c:forEach> se usa para recorrer una colección de forma que cada elemento visitado es
apuntado por nombreVar
Si la colección es un mapa, lo que se recorren son las entradas, que son del tipo Map.Entry.
Como colección también puede indicarse un array tradicional e incluso un String. En este último
caso, se supone que el String posee palabras separadas por comas, y el <c:forEach> se
ejecuta para cada una de tales palabras. La coma hace las veces de carácter delimitador.
Ejemplo de recorrido de los elementos de la cabecera (header):
<c:forEach var="elemento" items="${header}">

${elemento}<br>
-> ${elemento.value}<br>
</c:forEach>

Instalación y configuración ( 1 )
La librería JSTL es distribuida como un conjunto de archivos JAR que simplemente

tenemos que agregarlo en el classpath del contenedor de servlets.
1. Debemos usar un contenedor de servlets compatible con la versión JSP 2.0

para usar el JSTL 1.1. El Apache Tomcat 5.0 [http://jakarta.apache.org/tomcat/]
por ejemplo. En caso contrario, es posible usar el JSTL 1.0 en un contenedor que
soporte por lo menos el JSP 1.2 y servlets 2.3.
2. Descargar la implementación JSTL de la página de proyecto Jakarta TagLibs

[http://mirrors.isc.org/pub/apache/jakarta/taglibs/standard/]. La distribución binaria
viene empaquetada como .zip o tar.gz. Desempaquete estos archivos en un
directorio temporal.
3. Del directorio temporal, copie todos los archivos s tandard.jar y jstl.jar que
se encuentran en jakarta-taglibs-standard-1.1.2/lib al directorio /WEB-INF/lib de su
aplicación Web.También copiaremos el contenido de la carpeta jakarta-taglibs-
standard-1.1.2/conf a un /WEB-INF/conf.

Instalación y configuración ( 2 )
4. A continuación debemos mapear en el web.xml las librerías que vayamoa a

utilizar de la siguiente forma:.
<taglib>
<taglib-uri>/WEB-INF/c</taglib-uri>
<taglib-location>/WEB-INF/conf/c.tld</taglib-location>
</taglib>
5.Ahora, creamos una página JSP y probamos algunas etiquetas simples para
asegurarnos que la configuración del JSTL está bien hecha.
<%@ taglib prefix="c" uri="/WEB-INF/c" %>
<c:set var="hello" value="Hola mundo"/>

<div>
<c:out value="${hello}"/>
</div>

Ejemplo ( 1 )
<%@ taglib prefix="c" uri="/WEB-INF/c" %>
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">
<title>JSTL - Ejemplo 1</title>
</head>
<body>
<c:set var="nombre" value="Mi nombre es Jorge" />
<div><c:out value="${nombre}" default="Valor por defecto;" /></div>
<div><c:out value="${variableInexistente}" default=”Valor por defecto"/></div>
<hr/>

Ejemplo ( 2 )
<div>Cabecera: </div>
<ul>
<c:forEach var="elemento" items="${header}">
<li><strong>${elemento.key}:</strong> ${elemento.value}</li>
</c:forEach>
</ul>
<hr/>
<ul>
<c:forEach var="unaCookie" items="${cookie}">
<li><strong>${unaCookie.key}:</strong> ${unaCookie.value}</li>
</c:forEach>
<ul/>
</body></html>

Ejercicio
Ejercicio 1:

Curso JSP Mas

Cargado por

Copyright:

Formatos disponibles

Curso JSP Mas

Cargado por

Información del documento

Descripción original:

Título original

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

Curso JSP Mas

Cargado por

Copyright:

Formatos disponibles

JAVASERVER PAGES

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 1

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 2

¿Cuál es el funcionamiento básico? Muy sencillo:

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 3

Además, separando el formato del contenido podemos poner diferentes personas

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 4

Un fichero JSP empieza con un comentario del lado del serviros:

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 5

<%@ page session = ”true” %>

Si la longitod de cualquier directivam excede de la anchura normal de una página

<%@ page session = ”true”

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 6

Tal y como podemos ver, la directiva page posee variso atributos:

languaje = ”java”: Comunica al servidor el lenguaje que va a ser utilizado en

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 7

<%@ include file="url relativa" %>

La URL especificada normalmente se interpreta como relativa a la página JSP a la

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 8

<%@ taglib uri=”URI1” prefix=”tagprefix1” %>

Al igual que la directiva page, si la longitud de una directiva taglib excede la

Solo deberíamos importar librerías de etiquetas que realmente se van a utilizar en

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 9

Las declaraciones JSP declaran métodos y variable pertenecientes a la JSP.

Bloque de declaraciones Bloque de declaraciones

<%! private int cont; %> <%!

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 10

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 11

JSP incorpora ocho variables ya definidas, llamadas también objetos implicitos.

request: Hace referencia a HttpServletRequest. Es la petición del cliente.

La mayoría de estas variables de referencia se han visto y utilizado con servlets y

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 12

Los comentarios se utilizan para descubrir información adicional o los propósitos

<%-- Comentario de JSP --%>

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 13

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<%@ page language="java"

<meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1">

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 14

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 15

Dichos usuarios se almacenarán en una tabla de una base de datos que

Para acceder a la zona de administración debemos de validarnos en un

Tendremos que crear un usuarioVO, un usuarioDAO y los servlets que

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 16

Las acciones JSP usan construcciones de síntaxis XML para controlar el

A continuación veremos las siguientes acciones:

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 17

<jsp:include page="relative URL" flush="true" />

Al contrario que la directiva include, que inserta el fichero en el momento de la

<jsp:include page="pagina.jsp" flush="true">

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 18

<jsp:forward page=”pagina.jsp” />

También permite incorporar parámetros en la petición de la nueva página:

<jsp:forward page=”pagina.jsp” >

El significado de ejemplo anterior sería equivalente a :

Módulo: J2EE Tema: JavaServer Pages ( JSP ) 19

Los JavaBeans se idearon como un mecanismo para diseñar componentes,

Para ello el interfaz de un JavaBean debía ser capaz de mostrar su contenido en