JavaServer Pages Standard

Tag Library (JSTL)

Dr. Diego Lz. de Ipiña Gz. de Artaza

[Link]
[Link]
dipina@[Link]
JSTL
 Objetivo:
 Simplificar y agilizar el desarrollo de
aplicaciones web
 3ra iteración después de servlets y JSPs
 Sirven para la generación dinámica de
páginas web
Instalar JSTL
 Asumimos que ya has instalado Tomcat 5 en
tu máquina, si no consíguelo de:
 [Link]
5/v5.5.7/bin/[Link]
 Bajar JSTL 1.1 de:
 [Link]
taglibs/nightly/[Link]
 Copiar archivos [Link] y [Link]
a %TOMCAT_HOME%\common\lib
 [Link]
JSTL 1.0 vs JSTL 1.1
 JSTL 1.1 es una pequeña mejora de JSTL 1.0
creada para alinear JSTL con JSP 2.0.
 Antes había una versión de cada librería
dependiendo de si utilizabamos expresiones
EL o Java, ahora es la misma librería.
 Ha cambiado el nombre de los identificadores de
las librerías, se ha añadido un elemento del path
/jsp a todos ellos
Usar JSTL en una aplicación
Web
 Para cualquier aplicación web desde la cual quieres usar JSTL, copiar los ficheros .tld al
directorio WEB-INF de tu aplicación web.
 Edita el [Link] de tu aplicación web añadiendo las siguientes entradas
<taglib>
<taglib-uri>[Link]
<taglib-location>/WEB-INF/[Link]</taglib-location>
</taglib>
<taglib>
<taglib-uri>[Link]
<taglib-location>/WEB-INF/[Link]</taglib-location>
</taglib>
<taglib>
<taglib-uri>[Link]
<taglib-location>/WEB-INF/[Link]</taglib-location>
</taglib>
<taglib>
<taglib-uri>[Link]
<taglib-location>/WEB-INF/[Link]</taglib-location>
</taglib>

 Estas entradas permiten a tu aplicación web usar las librerías de etiquetas JSTL que usan el
lenguaje de expresiones. La posición de estas entradas tiene importancia.
Características
 Las páginas JSTL son también páginas JSP. JSTL es un
superconjunto de JSP.
 JSTL provee un conjunto de cinco librerías estándar:
 Core
 Internationalization/format
 XML
 SQL y
 Funciones
 Además JSTL define un nuevo lenguaje de expresiones llamado
EL, que ha sido luego adoptado por JSP 2.0
 Una etiqueta JSTL corresponde a una acción; llamándolas
acción nos indica que añaden comportamiento dinámico a una,
de otra manera, página estática.
Soporte para EL I
 El lenguaje de expresiones EL simplemente
define un poderoso mecanismo para expresar
expresiones simples en una sintáxis muy
sencilla.
 Es algo entre JavaScript y Perl.
 Su combinación con las etiquetas de las 4 librerías
antes mencionadas proveen mucha flexibilidad y
poder para el desarrollo de páginas dinámicas.
 En EL las expresiones están delimitadas por
${ }.
Soporte para EL II
 Algunos ejemplos del uso de EL son:
 ${anExpression}
 ${aList[4]}
 ${aList[someVariable]}  acceso a un elemento de una colección
 ${[Link]}  acceso a la propiedad de un objeto
 ${anObject["aPropertyName"]}  entrada en un mapa con propiedad
aPropertyName
 ${anObject[aVariableContainingPropertyName]}

 Existen una serie de variables implícitas definidas en EL:

 pageContext: el contexto del JSP actual
 pageScope, requestScope, sessionScope, and applicationScope:
colecciones de mapas que mapean nombres de variables en esos contextos
a valores
 param and paramValues: parámetros pasados con la petición de la
página, lo mismo que en JSP
 header and headerValues: cabeceras pasadas en la petición de la
página
 cookie: mapa que mapea nombres de cookies a los valores de las mismas
 JSTL Tag Libraries

Librería URI Prefijo

Librería
Core [Link] c

Internationalization [Link] fmt

I18N formateo
SQL/DB support [Link] sql

Procesamiento XML [Link] x

Functions [Link] fn
 Uso de las librerías JSTL en un
JSP
 La siguiente directiva ha de incluirse al comienzo
de la página:
<%@ taglib prefix="c"
uri=[Link]
%>
 Para utilizar una etiqueta de una librería
simplemente se ha de preceder con el prefijo de la
librería utilizada:
<c:out value="${anExpression}"/>
La librería de etiquetas Core
 Permiten llevar a cabo las siguientes
acciones:
 Visualizar/asignar valores y manejar
excepciones
 Control de flujo
 Otras acciones de utilidad
Visualizar/asignar valores y
manejar excepciones con Core I
 Para visualizar valores utilizamos:
<c:out:
value="${[Link]}"
escapeXml="true" default="0" /> of those items in
stock.
 escapeXml indica si hay que aplicar códigos de escape a los caracteres <,
>, & y .
 Asignar una variable en una página:
<c:set var="customerID" value="$[Link]"
scope="session" />
 scope indica el contexto en el que se define la variable
 También podemos asignar el contenido de una etiqueta a una variable:
<c:set var="cellContents">
<td>
<c:out value="${myCell}"/>
</td>
</c:set>
Visualizar/asignar valores y
manejar excepciones con Core II
 Normalmente en un JSP o incluimos un
bloque try/catch o usamos la directiva
errorPage:
<c:catch>
<!--. . . some set of nested
JSTL tags below which would be
hit on an exception-->
</c:catch>
 Para borrar una variable se puede utilizar
<c:remove>
Control de flujo con JSTL Core
I
 Para llevar a cabo simples condiciones (c:if):
<c:if test="${[Link] == 1000000}" var="visits">
You are the millionth visitor to our
site! Congratulations!
</c:if>
 El switch de un lenguaje de programación se puede emular con c:choose:
<c:choose>
<c:when test="${[Link] == 'book'}">
...
</c:when>
<c:when test="${[Link] == 'electronics'}">
...
</c:when>
<c:when test="${[Link] == 'toy'}">
...
</c:when>
<c:otherwise>
...
</c:otherwise>
</c:choose>
Control de flujo con JSTL Core
II
 Para iterar sobre una colección se define
c:foreach. Se pueden especificar índice de
comienzo, final e incremento con los atributos
begin, end y step.

<table>
<c:forEach var="name" items="${customerNames}">
<tr><td><c:out value="${name}"/></td></tr>
</c:forEach>
</table>
Control de flujo con JSTL Core
III
 Funcionalidad similar a StringTokenizer puede
ser obtenida en JSTL con c:forTokens:

<table>
<c:forTokens
items="47,52,53,55,46,22,16,2"
delims="," var="dailyPrice">
<tr><td><c:out
value="${dailyPrice}"/></td></tr>
</c:forTokens>
</table>
 Listar todos los parámetros
pasados a una petición
<%@ taglib uri="[Link] prefix="c" %>
<html>
<body>
<head>
<title>Parameter Listing Example</title>
</head>
<br>
<b>Parameter values passed to this page for each parameter: </b>
<table border="2">
<c:forEach var="current" items="${param}">
<tr>
<td>
<b><c:out value="${[Link]}" /></b>
</td>
<c:forEach var="aVal" items="${paramValues[[Link]]}">
<td>
<c:out value="${aVal}" />
</td>
</c:forEach>
</tr>
</c:forEach>
</table>
</body>
</html>
Otras acciones
 Para codificar URLs se puede utilizar c:url:
<c:url
value="[Link]
var="myUrl">
<c:param name="name"
value="${[Link]}"/>
<c:param name="country"
value="${[Link]}"/>
</c:url>
<a href='<c:out
value="${myUrl}"/>'>Register</a>
 Se pueden importar otros JSPs o incluso otros
recursos en una URL arbitraria usando c:import
(análogo to jsp:include)
 Para manejar redireccionamiento se puede utilizar la
etiqueta c:redirect
La Nueva Librería de
Funciones de EL
 Cuando EL se migró de la especificación JSTL
a JSP, se le añadío una nueva funcionalidad:
la invocación a funciones.
 Su uso es trivial: nombre-func(lista-
params)
<%@ taglib prefix="fn"
uri="[Link]
ctions" %>
${fn:length(myCollection)}
 Contiene un grupo de funciones utilizadas
comúnmente
 Funciones en EL
Función Descripción
fn:contains(string,
Devuelve true si el string contiene substring.
substring)
fn:containsIgnoreCase
Devuelve true si el string contiene a substring, ignorando capitalización.
(string, substring)
fn:endsWith(string,
Devuelve true si el string termina con suffix.
suffix)
fn:escapeXml(string) Devuelve el string con todos aquellos caracteres con especial significado en XML y HTML
convertidos a sus códigos de escape pertinentes.
fn:indexOf(string,
Devuelve la primera ocurrencia de substring en el string.
substring)
fn:join(array,
Devuelve un string compuesto por los elementos del array, separados por separator.
separator)
fn:length(item) Devuelve el número de elementos en item (si un array o colección), o el número de
caracteres (es un string).
 Funciones en EL
Función Descripción
fn:replace(string, before, Devuelve un string donde todas las ocurrencias del string before han sido
after) reemplazadas por el string after.
fn:split(string, Devuelve un array donde los elementos son las partes del string separadas por
separator) separator.
fn:startsWith(string,
Devuelve true si el string comienza por prefix.
prefix)
fn:substring(string, Devuelve la parte del string que comienza por el índice begin y que acaba en el
begin, end) índice end.
fn:substringAfter(string,
Devuelve la parte del string que sigue a substring.
substring)
fn:substringBefore(string,
Devuelve la parte de string que precede a substring.
substring)
fn:toLowerCase(string) Devuelve un string con todos los caracteres de la entrada convertidos a
minúsculas.
fn:toUpperCase(string) Devuelve un string con todos los caracteres de la entrada convertidos a mayúsculas.
fn:trim(string) Devuelve un string sin espacios en sus laterales.
 La librería de etiquetas de
internacionalización I
 Cubre dos áreas:
 Etiquetas (acciones) de formateo
 Acciones de internacionalización

 Acciones de formateo:
 Inspiradas en el funcionamiento de las clases DateFormat y NumberFormat
 Para formatear un número usamos formatNumber con los atributos number
para el número y pattern para el patrón de formateo a aplicar.
<fmt:formatNumber value="1000.001" pattern="#,#00.0#"/>
 Si queremos parsear un número a partir de un string usamos parseNumber:
<fmt:parseNumber value="${currencyInput}" type="currency"
var="parsedNumber"/>
 Para formatear una fecha usamos formatDate y para parsear un string
parseDate:
<jsp:useBean id="now" class="[Link]" />
<fmt:formatDate value="${now}" timeStyle="long"
dateStyle="long"/>
<fmt:parseDate value="${dateInput}" pattern="MM dd, YYYY" />
La librería de etiquetas de
internacionalización II
 Acciones de internacionalización:
 Una pieza importante de la localización en Java es la clase
ResourceBundle. Las acciones JSTL que permiten trabajar con
esta clase son:
 fmt:bundle para obtener un ResourceBundle correspondiente al
Locale actual y
 fmt:message para hacer lookups en el ResourceBundle
 Ejemplo:
<fmt:bundle basename="myBundle">
<%-- Use values in myBundle --%>
<fmt:message key="Introduction">
<fmt:param value="${loginName}"/>
<fmt:param value="${loginCount}"/>
</fmt:message>
<fmt:formatDate value="${now}"
var="parsedDate"/>
</fmt:bundle>
La librería de etiquetas SQL I
 JSTL permite una fácil integración con bases de datos
 No gestiona bien connection pooling, por tanto son solamente adecuadas para llevar a cabo
prototipos o aplicaciones de bajo volumen.
 Ejemplo: seleccionar y visualizar un conjunto de elementos

<sql:setDataSource
driver="[Link]"
url="jdbc:cheapDrivers:."
user="guest"
password="password"
var="dataSource" />
<sql:query var="orderItems" dataSource="${dataSource}">
SELECT * FROM items
WHERE order_id = <cout value="${orderID}"/>
ORDER BY price
</sql:query>
<table>
<c:forEach var="row" items="${[Link]}">
<tr>
<td><c:out value="${[Link]}"/></td>
<td><c:out value="${[Link]}"/></td>
<td><c:out value="${[Link]}"/></td>
</tr>
</c:forEach>
</table>
 Creando la BBDD Deusto
CREATE DATABASE deusto;

GRANT ALTER, SELECT,INSERT,UPDATE,DELETE,CREATE,DROP

ON deusto.*
TO deusto@'%'
IDENTIFIED BY 'deusto';

GRANT ALTER, SELECT,INSERT,UPDATE,DELETE,CREATE,DROP

ON deusto.*
TO deusto@localhost
IDENTIFIED BY 'deusto';

use deusto;

CREATE TABLE EVENTOS(ID int(11) NOT NULL PRIMARY KEY,

NOMBRE VARCHAR(250), LOCALIZACION VARCHAR(250), FECHA bigint(20), DESCRIPCION
VARCHAR(250));

INSERT INTO EVENTOS VALUES (0, 'SEMANA ESIDE', 'ESIDE-DEUSTO', 0, 'Charla sobre
Python');
INSERT INTO EVENTOS VALUES (1, ‘CURSO J2EE', ‘CESINE', 0, ‘Curso sobre tecnologías
Java 2 Enterprise Edition');
Recuperando Datos de Tabla
Eventos
<%@ taglib uri="[Link] prefix="c" %>
<%@ taglib prefix="sql" uri="[Link] %>
<sql:setDataSource
driver="[Link]"
url="jdbc:mysql://localhost:3306/deusto"
user="deusto"
password="deusto"
var="dataSource"/>

<sql:query var="eventItems" dataSource="${dataSource}">

select * from eventos
</sql:query>
<table>
<c:forEach var="row" items="${[Link]}">
<tr>
<td><c:out value="${[Link]}"/></td>
<td><c:out value="${[Link]}"/></td>
<td><c:out value="${[Link]}"/></td>
<td><c:out value="${[Link]}"/></td>
<td><c:out value="${[Link]}"/></td>
</tr>
</c:forEach>
</table>
La librería de etiquetas SQL II
 También se soportan acciones para manejar transacciones
(sql:transaction), sql:update soporta no sólo updates sino que también
insert y delete e incluso create, es decir todas las acciones SQL que no
devuelven un resultado:

<sql:transaction dataSource="${dataSource}">
<sql:update>
UPDATE account
SET account_balance =account_balance -?
WHERE accountNo = ?
<sql:param value="${transferAmount}"/>
<sql:param value="${sourceAccount}"/>
</sql:update>
<sql:update>
UPDATE account
SET account_balance =account_balance +?
WHERE accountNo = ?
<sql:param value="${transferAmount}"/>
<sql:param value="${destAccount}"/>
</sql:update>
</sql:transaction>
Recuperando Datos con JSTL
de MySQL
1. Instalar MySQL ([Link]
2. Instalar Connector/J, driver JDBC para MySQL
([Link]
3. Mover el driver MySQL a
$CATALINA_HOME/common/lib.
4. Asegurarse que en $CATALINA_HOME/common/lib
están las librerías de JSTL [Link] y [Link], si
no bajarlas de:
[Link]
naries/
5. Crear una tabla de prueba con el siguiente
comando: mysql –uroot < [Link]
Recuperando Datos con JSTL
de MySQL
 Contenido de [Link]:

GRANT ALL PRIVILEGES ON *.* TO javauser@localhost

IDENTIFIED BY 'javadude' WITH GRANT OPTION;
create database javatest;

use javatest;

create table testdata (

id int not null auto_increment primary key,
foo varchar(25),
bar int
);

insert into testdata values(null, 'hello', 12345);

Recuperando Datos con JSTL
de MySQL
5. Añadir el siguiente párrafo a $CATALINA_HOME/conf/[Link]:
<Context path="/DBTest" docBase="DBTest"
debug="5" reloadable="true"
crossContext="true">
<Resource name="jdbc/TestDB" auth="Container"
type="[Link]"
maxActive="100" maxIdle="30"
maxWait="10000"
username="javauser" password="javadude"
driverClassName="[Link]"

url="jdbc:mysql://localhost:3306/javatest?autoReco
nnect=true"/>
</Context>
Recuperando Datos con JSTL
de MySQL
6. Crear un fichero de configuración para esta aplicación WEB-INF/[Link]:
<web-app xmlns="[Link]
xmlns:xsi="[Link]
xsi:schemaLocation="[Link]
[Link]
version="2.4">
<description>MySQL Test App</description>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/TestDB</res-ref-name>
<res-type>[Link]</res-type>
<res-auth>Container</res-auth>
</resource-ref>
</web-app>
Recuperando Datos con JSTL
de MySQL
7. Crear un fichero [Link]:
<%@ taglib uri="[Link] prefix="sql" %>
<%@ taglib uri="[Link] prefix="c" %>

<sql:query var="rs" dataSource="jdbc/TestDB">

select id, foo, bar from testdata
</sql:query>

<html>
<head>
<title>DB Test</title>
</head>
<body>

<h2>Results</h2>

<c:forEach var="row" items="${[Link]}">

Foo ${[Link]}<br/>
Bar ${[Link]}<br/>
</c:forEach>

</body>
</html>
JSTL y Access
 Ejecutar ejemplo contenido en standard-
[Link] de JSTL:
[Link]
examples/sql/
 Crear base de datos en Access vacía como la
contenida en: sql/[Link]
 Registrar fuente de datos ODBC: Panel de Control 
Herramientas Administrativas  Fuentes de Datos (ODBC)
 JSTLSQLDB (nombre fuente de datos), seleccionar el
fichero arriba mencionado
 Configurar los detalles de la base de datos con los
siguientes parámetros:
 Driver  [Link]
 Base de datos  jdbc:odbc:JSTLSQLDB
 Ejecutar los .JSPs
 La librería de etiquetas XML I
 El soporte de XML que lleva a cabo JSTL conforma con la especificación XPath.
 Xpath provee una sintáxis clara para acceder a partes jerárquicas de un documento.
 Acciones c:import es utilizada para importar un documento, mientras x:parse
para genera un árbol DOM a partir de él. x:set crea una variable a partir de un
extracto de XML

<!-- Find and parse our XML document (somewhere on the WWW) -->
<c:import url="[Link]
var="xml"/>
<x:parse xml="${xml}" var="doc"/>
<!-- access XML data via XPath expressions -->
<x:out select="$doc/name"/>
<x:out select="$doc/shippingAddress"/>
<x:out select="$doc/deliveryDate"/>
<!-- Set a scoped variable -->
<x:set var="custName" scope="request" select="$doc/name"/>
 La librería de etiquetas XML II
 JSTL se integra fenomenálmente con XSTL

<%@ taglib uri="[Link] prefix="c" %>

<%@ taglib uri="[Link] prefix="x" %>
<c:set var="xsltSource">
<?xml version="1.0"?>
<xsl:stylesheet xmlns:xsl="[Link]
version="1.0">
<xsl:template match="/">
<xsl:apply-templates/>
</xsl:template>
<xsl:template match="music">
<html>
<head></head>
<body marginheight="0" marginwidth="0" topmargin="0" leftmargin="0">
<table cellpadding="0" cellspacing="0" border="1" bgcolor="#ffffff">
<tr>
<td><STRONG>Artist</STRONG></td>
<td><STRONG>Album</STRONG></td>
<td><STRONG>Year</STRONG></td>
<td><STRONG>Genre</STRONG></td>
</tr>
La librería de etiquetas XML
III
<!---Set up for loop to collect all the artist information //-->
<!-- <xsl:for-each select="./*[name()='artists']"> -->
<xsl:for-each select="artists">
<tr>
<td><xsl:value-of select="artist"/></td>
<td><xsl:value-of select="album"/></td>
<td><xsl:value-of select="year"/></td>
<td><xsl:value-of select="genre"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
</c:set>
<x:transform xslt="${xsltSource}" >
<music>
<artists>
<artist>Jonny B</artist>
<album>Feedback and Distortion</album>
<year>2001</year>
<genre>Rock</genre>
</artists>
<artists>
<artist>Harmony's Nieces</artist>
<album>Sappy Pop Ballads</album>
<year>2002</year>
<genre>Pop</genre>
</artists>
</music>
</x:transform>
 La librería de etiquetas XML IV
 Una manera más sencilla de realizar una
transformación XSLT sería:
<%@ taglib uri="[Link]
prefix="c"%>
<%@ taglib prefix="x"
uri="[Link] %>
<c:import var="xmlSource" url=“${someDocumentURL}" />
<c:import var="xsltSource" url=“${anotherDocumentURL}" />
<x:transform xml="${xmlSource}" xslt="${xsltSource}"/>
Ejemplos
 Copiar [Link]
contenido en la distribución estándar de
JSTL 1.1 a
%TOMCAT_HOME%\webapps\
 Ejecutar en el navegador:
[Link]
d-examples/
Recursos
 Javadoc de JSTL APIs es disponible en:
[Link]
process/final/jsr052/