JSTL (JavaServer Pages Standard Tag Library) es una librería de tags estándar que encapsula, en forma de tags, muchas funcionalidades comunes en aplicaciones JSP, de forma que, en lugar que tener que recurrir a varias librerías de tags de distintos distribuidores, sólo necesitaremos tener presente esta librería que, además, por el hecho de ser estándar, funciona de la misma forma en cualquier parte, y los contenedores pueden reconocerla y optimizar sus implementaciones.

JSTL permite realizar tareas como iteraciones, estructuras condicionales, tags de manipulación de documentos XML, tags SQL, etc. También introduce un lenguaje de expresiones que simplifica el desarrollo de las páginas, y proporciona un API para simplificar la configuración de los tags JSTL y el desarrollo de tags personalizados que sean conformes a las convenciones de JSTL.

Se puede emplear JSTL a partir de la versión 2.3 de servlets, y 1.2 de JSP. Podéis encontrar más información sobre JSTL en:

http://java.sun.com/products/jsp/jstl

3.5.1. Uso de JSTL

JSTL contiene una gran variedad de tags que permiten hacer distintos tipos de tareas, subdivididas en áreas. Así, JSTL proporciona varios ficheros TLD, para describir cada una de las áreas que abarca, y dar así a cada área su propio espacio de nombres. 

En la siguientes tablas se muestran las áreas cubiertas por JSTL (cada una con una librería):

Librería EL:

Librería RT:

Se tienen dos versiones de JSTL (la razón de ello se explica más adelante), aunque la utilidad de las librerías es la misma para las dos:

• Core se utiliza para funciones de propósito general (manejo de expresiones, sentencias de control de flujo, etc). 
• XML se emplea para procesamiento de ficheros XML.
• La librería de internationalización se usa para dar soporte a páginas multilenguaje, y a multiformatos de números, monedas, etc, en función de la región en que se tenga la aplicación. 
• SQL sirve para acceder y manipular bases de datos relacionales. 

Las URIs y prefijos que se indican en la tabla pueden emplearse (aunque no es obligatorio) para utilizar las librerías en nuestras aplicaciones.

EJEMPLO

Para utilizar, por ejemplo, los tags del área core en una página JSP, seguimos pasos similares a los realizados para utilizar las librerías de tags vistas anteriormente:

• Colocar al principio de cada página JSP donde vayamos a utilizar la librería core la línea:

<%@ taglib uri="/jstl-core" prefix="c" %>

donde la uri y el prefix tendrán los valores que queramos darles.

• Las librerías JSTL vienen en dos versiones: los ficheros TLD para la librería JSTL-EL vienen nombrados como prefix.tld (siendo prefix el prefijo para la librería), y los de la librería JSTL-RT vienen nombrados como prefix-rt.tld. Así, por ejemplo, para indicar en el descriptor de despliegue (web.xml) que vamos a utilizar la librería de core, pondríamos algo como:

<taglib> 
	<taglib-uri>/jstl-c</taglib-uri> 
	<taglib-location>
	/WEB-INF/c.tld
	</taglib-location> 
</taglib>

Si utilizamos las uris absolutas que se han indicado anteriormente, no tenemos que añadir este elemento <taglib> en el descriptor de despliegue. El contenedor JSP localiza automáticamente el TLD.

• Finalmente, tenemos que tener accesible una implementación de la librería que vamos a utilizar. Hay que copiar los ficheros JAR correspondientes en el directorio WEB-INF/lib de nuestra aplicación.

3.5.2. Lenguaje de expresiones

Una característica muy importante de JSTL es el soporte que ofrece para un lenguaje de expresiones propio. Hasta ahora, en una página JSP teníamos que utilizar bloques del tipo <%= valor %> para acceder al valor de un determinado componente. Con el lenguaje de expresiones podemos acceder a estos elementos de forma más sencilla. Por ejemplo: 

<c:if test="${persona.edad} > 18">
	...
</c:if>

Comprobamos si en los datos de una persona consta que es mayor de edad. 

3.5.2.1. Versiones de JSTL

Por motivos de compatibilidad con JSP 1.2, las librerías de JSTL vienen en dos versiones, que se diferencian en la forma en que dan soporte a expresiones en tiempo de ejecución para valores de atributos:

• En JSTL-RT las expresiones se especifican en el lenguaje script de la página, igual que como funcionan en las librerías actuales. Así, se evalúan en tiempo de ejecución.
• En JSTL-EL las expresiones se especifican en un lenguaje de expresiones (EL) de JSTL. Así, una expresión será una cadena (String) con la sintaxis del lenguaje en cuestión. Es responsabilidad del lenguaje definir metacaracteres para distinguir expresiones de simples cadenas de caracteres (por ejemplo, comenzar las expresiones con un '$'). Con esta versión de JSTL no podemos utilizar lenguaje script para obtener valores de atributos, y el hecho de definir expresiones permite evaluar su sintaxis en tiempo de traducción.

Podemos utilizar las dos librerías conjuntamente, como en este ejemplo, que utiliza las dos librerías de internacionalización (prefijo fmt):

<fmt:message key="clave">
	<fmt:param value="${miParametro}"/>
	<fmt_rt:param value="<%= miParametro %>"/>
</fmt:message>

3.5.2.2. Definición del lenguaje

Se describe a continuación, y a grandes rasgos, el lenguaje de expresiones incluido en JSTL 1.0. Se espera que dicho lenguaje, salvo algunas modificaciones que puedan surgir, sea completamente compatible con JSP 1.3, cuando salga dicha versión.

El lenguaje está inspirado en los lenguajes ECMAScript y XPath, y está basado en espacios de nombres (atributos PageContext),  propiedades de elementos, operadores relacionales, lógicos y aritméticos, y un conjunto de objetos implícitos. 

3.5.2.2.1. Atributos y expresiones

En JSTL, podremos utilizar este lenguaje de expresiones sólo en atributos de etiquetas (en JSP 1.3 también se puede utilizar fuera de ellas). Se invoca a este lenguaje mediante el elemento ${...}:

${expresion}

Hay 3 formas de utilizar expresiones en atributos:

• Cuando el atributo contiene una sola expresión:

<pref:etiq value="${expresion}"/>

En este caso, se evalúa la expresión y el resultado se convierte al tipo de dato del atributo, siguiendo las reglas de conversión internas del lenguaje.

• Cuando el atributo contiene varias expresiones, separadas (o no) por texto:

<pref:etiq 
 value="texto${e1}y ${e2}texto"/>

Aquí, las expresiones se evalúan de izquierda a derecha, y se intercalan entre el texto, convirtiéndolas a String (siguiendo reglas de conversión internas). Luego, la cadena resultante se convierte al tipo del atributo.

• Cuando el atributo contiene sólo texto:

<pref:etiq value="Un texto"/>

En este caso, la cadena se convierte al tipo de dato del atributo.

Para cadenas que contengan la secuencia '${' sin que sea propiamente una expresión, se encapsula esa secuencia así: ${'${'}. Por ejemplo:

<pref:etiq value="Cadena con ${'${'}expr}"/>

Mostraría: "Cadena con ${expr}"

EJEMPLOS

<c:if test="${bean1.a > 10}"/>
	...
</c:if>

Comprueba si una propiedad a de un bean es menor que 10.

<c:if test="true"/>
	...
</c:if>

Asigna directamente el valor verdadero a la condición.

3.5.2.2.2. Operadores

• Operadores '[ ]' y '.': se unifican los operadores [ ] y . de forma que son equivalentes:

expr.campo
expr["campo"]

• Operadores aritméticos:
  • +, -, *, /: suma, resta, multiplicación y división
  • div: división entera
  • %, mod: resto (se mantienen los dos por compatibilidad con XPath y ECMAScript)
  • -: cambio de signo
• Operadores relacionales: 
  • >, gt: mayor que
  • <, lt: menor que
  • >=, ge: mayor o igual que
  • <=, le: menor o igual que
  • ==, eq: igual que
  • !=, ne: distinto que
• Operadores lógicos:
  • &&, and: Y lógica
  • ||, or: O lógica
  • !, not: NO lógica
• Operador empty: utilizado delante de un elemento, para indicar si el elemento es nulo o vacío (devolvería true) o no (devolvería false). Por ejemplo:

${empty A}

PRECEDENCIA

• [ ], .
• ( )
• - (cambio de signo), not, !, empty
• *, /, div, %, mod
• +, -
• <, >, <=, >=, lt, gt, le, ge
• ==, !=, eq, ne
• &&, and
• ||, or

3.5.2.2.3. Nombres de variables

El lenguaje de expresiones evalúa un identificador o nombre de elemento mirando su valor como un atributo, según el comportamiento del método PageContext.findAttribute(String). Por ejemplo, si ponemos:

${valor}

Se buscará el atributo valor en los ámbitos de página (page), petición (request), sesión (session) y aplicación (application), y si lo encuentra devuelve su valor. Si no, se devuelve null.

Objetos implícitos

Cuando como nombre de atributo se utiliza alguno de los que el lenguaje de expresiones considera como implícitos, se devolverá el objeto asociado. Dichos objetos implícitos son:

• pageContext: el objeto PageContext actual
• pageScope, requestScope, sessionScope, applicationScope: para obtener valores de atributos de página / petición / sesión / aplicación, respectivamente.
• param: para obtener el valor de un parámetro de petición. Se obtiene un tipo String (utilizando el método ServletRequest.getParameter(String))
• paramValues: para obtener los valores de un parámetro de petición. Se obtiene un tipo String[ ] (utilizando el método ServletRequest.getParameterValues(String)).
• header: para obtener el valor de un parámetro de cabecera. Se obtiene un tipo String (utilizando el método ServletRequest.getHeader(String))
• headerValues: para obtener los valores de un parámetro de cabecera. Se obtiene un tipo String[ ] (utilizando el método ServletRequest.getHeaderValues(String)).
• cookie: para obtener el valor de una cookie. Se obtiene un objeto Cookie. Las cookies se buscan con HttpServletRequest.getCookies()
• initParam: para obtener el valor de un parámetro de inicialización. Se obtiene un tipo String (utilizando el método ServletContext.getInitParameter(String))

EJEMPLOS

${sessionScope.profile}

Se obtiene el atributo profile de la sesión

${param.id}

Se obtiene el valor del parámetro id, o null si no se encuentra.

Palabras reservadas

Se tienen algunos identificadores que no podemos utilizar como nombres de atributos, como son and, eq, gt, true, instanceof, or, ne, le, false, empty, not, lt, ge, null, div y mod.

3.5.3. La librería Core

Los tags core incluyen tags de propósito general. En esta librería se tienen etiquetas para:

• Funciones de propósito general: evaluar expresiones, establecer valores de parámetros, etc.
• Funciones de control de flujo: condiciones para ejecutar unos bloques de código u otro, iteradores, etc.
• Funciones de acceso a URLs: para importar URLS en la página actual, etc.

Los tags de esta librería se presentan con el prefijo "c".

1. Tags de propósito general

out

El tag out evalúa el resultado de una expresión y lo pone en el objeto JspWriter actual. Es equivalente a la sintaxis <%= ... %> de JSP.

SINTAXIS:

Dar el valor por defecto mediante un atributo default:

<c:out value="valor" 
 [escapeXML="true|false"] 
 [default="valor"]/>

Dar el valor por defecto mediante el cuerpo del tag:

<c:out value="valor" 
 [escapeXML="true|false"]>
	Valor por defecto
</c:out>

ATRIBUTOS:

• value: expresión que se tiene que evaluar.
• escapeXML: a true (valor por defecto) indica que los caracteres <, >, &, ', " que haya en la cadena resultado se deben convertir a sus códigos correspondientes (&lt;, &gt;, &amp;, &#039;, &#034;, respectivamente).
• default: valor por defecto si el resultado es null. Se puede indicar por el atributo o por el cuerpo del tag.

EJEMPLO:

<c:out value="${datos.ciudad}" 
 default="desconocida"/>

Sacaría el valor del campo ciudad del objeto datos, o mostraría "desconocida" si dicho valor es nulo.

set

El tag set establece el valor de un atributo en cualquier campo JSP (page, request, session, application). Si el atributo no existe, se crea. 

SINTAXIS:

Dar valor a una variable utilizando el atributo value:

<c:set value="valor" var="variable" 
 [scope="page|request|session|application"]/>

Dar valor a una variable utilizando el cuerpo del tag:

<c:set var="variable" 
 [scope="page|request|session|application"]>
	Valor
</c:set>

Dar valor a una propiedad de un objeto utilizando el atributo value:

<c:set value="valor" target="objeto" 
 property="propiedad"/>

Dar valor a una propiedad de un objeto utilizando el cuerpo del tag:

<c:set target="objeto" property="propiedad">
	Valor
</c:set>

ATRIBUTOS:

• value: valor que se asigna. Podemos dar el valor con este atributo o con el cuerpo del tag.
• var: variable a la que se asigna el valor.
• scope: ámbito de la variable a la que se asigna el valor.
• target: objeto al que se le modifica una propiedad. Debe ser un objeto JavaBeans con una propiedad propiedad que pueda establecerse, o un objeto java.util.Map.
• property: propiedad a la que se le asigna valor en el objeto target.

EJEMPLO:

<c:set var="foo" value="2"/>

Asignaría a la variable foo el valor "2".

Otras Etiquetas

Existen otras etiquetas, como remove o catch, que no se comentan aquí.

2. Tags de control de flujo

if

El tag if permite ejecutar su código si se cumple la condición que contiene su atributo test.

SINTAXIS:

Sin cuerpo:

<c:if test="condicion" var="variable" 
 [scope="page|request|session|application"]/>

Con cuerpo:

<c:if test="condicion" [var="variable"] 
 [scope="page|request|session|application"]>
	Cuerpo
</c:if>

ATRIBUTOS:

• test: condicion que debe cumplirse para ejecutar el if.
• var: variable donde se guarda el resultado de evaluar la expresión. El tipo de esta variable debe ser Boolean.
• scope: ámbito de la variable a la que se asigna el valor de la condición.

EJEMPLO:

<c:if test="${visitas} > 1000">
<h1>¡Mas de 1000 visitas!</h1>
</c:if>

Sacaría el mensaje "¡Mas de 1000 visitas!" si el contador visitas fuese mayor que 1000.

choose

El tag choose permite definir varios bloques de código y ejecutar uno de ellos en función de una condición. Dentro del choose puede haber espacios en blanco, una o varias etiquetas when y cero o una etiquetas otherwise.

El funcionamiento es el siguiente: se ejecutará el código de la primera etiqueta when que cumpla la condición de su atributo test. Si ninguna etiqueta when cumple su condición, se ejecutará el código de la etiqueta otherwise (esta etiqueta, si aparece, debe ser la última hija de choose).

SINTAXIS:

<c:choose>
	<c:when test="condicion1">
		codigo1
	</c:when>
	<c:when test="condicion2">
		codigo2
	</c:when>
	...
	<c:when test="condicionN">
		codigoN
	</c:when>
	<c:otherwise>
		codigo
	</c:otherwhise>
</c:choose>

EJEMPLO:

<c:choose>
	<c:when test="${a} < 0">
	<h1>a menor que 0</h1>
	</c:when>
	<c:when test="${a} > 10">
	<h1>a mayor que 10</h1>
	</c:when>
	<c:otherwise>
	<h1>a entre 1 y 10</h1>
	</c:otherwhise>
</c:choose>

Sacaría el mensaje "a es menor que 0" si la variable a es menor que 0, el mensaje "a es mayor que 10" si es mayor que 10, y el mensaje "a esta entre 1 y 10" si no se cumple ninguna de las dos anteriores.

forEach

El tag forEach permite repetir su código recorriendo un conjunto de objetos, o durante un número determinado de iteraciones.

SINTAXIS:

Para iterar sobre un conjunto de objetos:

<c:forEach [var="variable"] items="conjunto" 
[varStatus="variableEstado"] [begin="comienzo"] 
[end="final"] [step="incremento"]>
	codigo
</c:forEach>

Para iterar un determinado número de veces:

<c:forEach [var="variable"] 
 [varStatus="variableEstado"] begin="comienzo" 
 end="final" [step="incremento"]>
	codigo
</c:forEach>

ATRIBUTOS:

• var: variable donde guardar el elemento actual que se está explorando en la iteración. El tipo de este objeto depende del tipo de conjunto que se esté recorriendo.
• items: conjunto de elementos que recorre la iteración. Pueden recorrerse varios tipos: 
  • Array: tanto de tipos primitivos como de tipos complejos. Para los tipos primitivos, cada dato se convierte en su correspondiente wrapper (Integer para int, Float para float, etc)
  • java.util.Collection: mediante el método iterator() se obtiene el conjunto, que se procesa en el orden que devuelve dicho método.
  • java.util.Iterator
  • java.util.Enumeration
  • java.util.Map:el objeto del atributo var es entonces de tipo Map.Entry, y se obtiene un Set con los mapeos. Llamando al método iterator() del mismo se obtiene el conjunto a recorrer.
  • String: la cadena representa un conjunto de valores separados por comas, que se van recorriendo en el orden en que están.
• varStatus: variable donde guardar el estado actual de la iteración. Es del tipo javax.servlet.jsp.jstl.core.LoopTagStatus.
• begin: indica el valor a partir del cual comenzar la iteración. Si se está recorriendo un conjunto de objetos, indica el índice del primer objeto a explorar (el primero es el 0), y si no, indica el valor inicial del contador. Si se indica este atributo, debe ser mayor o igual que 0.
• end: indica el valor donde terminar la iteración. Si se está recorriendo un conjunto de objetos, indica el índice del último objeto a explorar (inclusive), y si no, indica el valor final del contador. Si se indica este atributo, debe ser mayor o igual que begin.
• step: indica cuántas unidades incrementar el contador cada iteración, para ir de begin a end. Por defecto es 1 unidad. Si se indica este atributo, debe ser mayor o igual que 1.

EJEMPLO:

<c:forEach var="item" 
 items="${cart.items}"> 
	<tr> 
		<td>
		<c:out value="${item.valor}"/>
		</td> 
	</tr>
</c:forEach>

Muestra el valor de todos los items.

forTokens

El tag forTokens es similar al tag foreach, pero permite recorrer una serie de tokens (cadenas de caracteres), separadas por el/los delimitador(es) que se indique(n).

SINTAXIS

La sintaxis es la misma que foreach, salvo que se tiene un atributo delims, obligatorio.

ATRIBUTOS

• var: igual que para foreach
• items: cadena que contiene los tokens a recorrer 
• delims:conjunto de delimitadores que se utilizan para separar los tokens de la cadena de entrada (colocados igual que los utiliza un StringTokenizer).
• varStatus: igual que para foreach
• begin: indica el índice del token a partir del cual comenzar la iteración.
• end: indica el índice del token donde terminar la iteración.
• step: igual que para foreach.

EJEMPLO:

<c:forTokens var="item"
 items="un#token otro#otromas" delims="# "> 
	<tr> 
		<td>
		<c:out value="${item}"/>
		</td> 
	</tr>
</c:forEach>

Definimos dos separadores: el '#' y el espacio ' '. Así habrá 4 iteraciones, recorriendo los tokens "un", "token", "otro" y "otromas".

3. Tags de manejo de URLs

import

El tag import permite importar el contenido de una URL.

SINTAXIS:

Para copiar el contenido de la URL en una cadena:

<c:import url="url" [context="contexto"] 
 [var="variable"] 
 [scope="page|request|session|application"] 
 [charEncoding="codificacion"]>
	cuerpo para tags "param" opcionales
</c:import>

Para copiar el contenido de la URL en un Reader:

<c:import url="url" [context="contexto"] 
 varReader="variableReader" 
 [charEncoding="codificacion"]>
	codigo para leer del Reader
</c:import>

ATRIBUTOS:

• url: URL de la que importar datos
• context: contexto para URLs que pertenecen a contextos distintos al actual. 
• var: variable (String) donde guardar el contenido de la URL
• varReader: variable (Reader) donde guardar el contenido de la URL
• scope: ámbito para la variable var
• charEncoding: codificación de caracteres de la URL

EJEMPLO:

<c:import url="http://www.ua.es" 
 var="universidad">
	<c:out value="${universidad}"/>
</c:import>

Obtiene y muestra el contenido de la URL indicada.

param

El tag param se utiliza dentro del tag import y de otros tags (redirect, url) para indicar parámetros de la URL solicitada. Dentro del tag import sólo se utiliza si la URL se guarda en una cadena. Para los Readers no se emplean parámetros.

SINTAXIS:

Sin cuerpo:

<c:param name="nombre" value="valor"/>

Con cuerpo:

<c:param name="nombre">
	Valor
</c:param>

ATRIBUTOS:

• name: nombre del parámetro
• value: valor del parámetro. Puede indicarse bien mediante este atributo, bien en el cuerpo del tag.

EJEMPLO:

<c:import url="http://localhost/mipagina.jsp" 
 var="universidad"> 
	<c:param name="id" value="12"/>
</c:import>

Obtiene la página mipagina.jsp?id=12 (le pasa como parámetro id el valor 12).

Otras Etiquetas

Existen otras etiquetas, como url o redirect, que no se comentan aquí.

EJEMPLO

Vemos cómo quedaría el ejemplo visto en la sesión anterior para la librería request adaptado a la librería core. Partiendo del mismo formulario inicial:

<html>
<body>
	<form action="request.jsp">
		Nombre: 
		<input type="text" name="nombre">
		<br>
		Descripcion: 
		<input type="text" name="descripcion">
		<br>
		<input type="submit" value="Enviar">
	</form>
</body>
</html>

Para obtener los parámetros podríamos tener una página como esta:

<%@ taglib uri="core" prefix="c" %>
<%@ taglib uri="corert" prefix="c_rt" %>

<html>
<body>
	Nombre: <c:out value="${param.nombre}"/>
	<br>
	<% String descr = request.getParameter("descripcion"); %>
	Descripcion: <c_rt:out value="<%= descr %>"/>
	<br>
</body>
</html>

Hemos utilizado en este caso, como ejemplo, tanto los tags de la librería EL como los de la librería RT, para ver que se pueden emplear juntos. Para probar el ejemplo, copiad este fichero WAR en el directorio webapps de Tomcat, reiniciar el servidor y ejecutad:

http://localhost:8080/ejemplojstlcore/index.html 

3.5.4. La librería SQL

Los tags de la librería SQL permiten acceder y manipular información de bases de datos relacionales. Vienen definidos con el prefijo "sql".

Con esta librería podremos:

• Establecer la base de datos a la que acceder
• Realizar consultas a bases de datos (select)
• Acceder a los resultados de las consultas realizadas
• Realizar actualizaciones sobre la base de datos (insert, update, delete)
• Agrupar operaciones en una sola transacción

Estas acciones se realizan sobre objetos de tipo javax.sql.DataSource, que proporciona conexiones a la fuente de datos que representa. Así, se obtiene un objeto Connection de dicho DataSource, y con él podremos ejecutar sentencias y obtener resultados. Podemos definir el DataSource mediante la etiqueta setDataSource y luego acceder a ese DataSource con los atributos dataSource de las etiquetas de la librería.

setDataSource

El tag setDataSource permite definir el objeto DataSource con el que trabajar, y dejarlo asignado en una variable.

SINTAXIS:

<sql:setDataSource {dataSource="DataSource" | 
 url="url" [driver="driver"] [user="usuario"] 
 [password="password"]} [var="variable"]
 [scope="page|request|session|application"]/>

ATRIBUTOS:

• dataSource: objeto DataSource al que queremos enlazar (en caso de que esté creado de antemano).
• url: URL de la base de datos a acceder
• driver: driver con que conectar con la base de datos
• user: nombre de usuario con que conectar a la base de datos
• password: password con que conectar a la base de datos
• var: variable donde guardar el DataSource que se obtenga
• scope: ámbito de la variable var

Notar que se puede obtener el DataSource tanto indicándolo directamente en el atributo dataSource como indicando url, driver, user y password (los tres últimos opcionales).

query

El tag query permite definir una consulta (select) en una base de datos.

SINTAXIS:

Sin cuerpo:

<sql:query sql="consulta" var="variable" 
 [scope="page|request|session|application"] 
 [dataSource="DataSource"] [maxRows="max"] 
 [startRow="inicio"]/>

Con cuerpo donde indicar parámetros de la consulta:

<sql:query sql="consulta" var="variable" 
 [scope="page|request|session|application"] 
 [dataSource="DataSource"] [maxRows="max"] 
 [startRow="inicio"]>
	Campos <sql:param>
</sql:query>

Con cuerpo donde indicar la propia consulta y los parámetros de la consulta:

<sql:query var="variable" 
 [scope="page|request|session|application"] 
 [dataSource="DataSource"] [maxRows="max"] 
 [startRow="inicio"]>
	Consulta
	Campos <sql:param>
</sql:query>

ATRIBUTOS:

• sql: consulta a realizar (en formato SQL). Puede indicarse la consulta tanto en este atributo como en el cuerpo de la etiqueta.
• dataSource: objeto DataSource asociado a la base de datos a la que se accede. Si especificamos este campo, no podemos incluir esta etiqueta dentro de una transacción (etiqueta transaction).
• maxRows: máximo número de filas que se devuelven como resultado
• startRow: fila a partir de la cual devolver resultados. Por defecto es la 0.
• var: variable donde guardar el resultado. Es de tipo javax.servlet.jsp.jstl.sql.Result.
• scope: ámbito de la variable var.

update

El tag update permite definir una actualización (insert, update, delete) en una base de datos.

SINTAXIS:

Sin cuerpo:

<sql:update sql="actualizacion" 
 [dataSource="DataSource"] [var="variable"] 
 [scope="page|request|session|application"]/>

Con cuerpo donde indicar parámetros de la actualización:

<sql:update sql="actualizacion" 
 [dataSource="DataSource"] [var="variable"] 
 [scope="page|request|session|application"]>
	Campos <sql:param>
</sql:update>

Con cuerpo donde indicar la propia actualización y los parámetros de la misma:

<sql:update [dataSource="DataSource"] [var="variable"] 
 [scope="page|request|session|application"]>
	Actualización
	Campos <sql:param>
</sql:update>

ATRIBUTOS:

• sql: actualización a realizar (en formato SQL). Puede indicarse tanto en este atributo como en el cuerpo de la etiqueta.
• dataSource: objeto DataSource asociado a la base de datos a la que se accede. Si especificamos este campo, no podemos incluir esta etiqueta dentro de una transacción (etiqueta transaction).
• var: variable donde guardar el resultado. Es de tipo Integer (se devuelve el número de filas afectadas por la actualización).
• scope: ámbito de la variable var.

transaction

El tag transaction permite agrupar dentro de él varios tags query y/o update, de forma que se define una transacción con ellos.

SINTAXIS:

<sql:transaction [dataSource="DataSource"] 
 [isolation="nivel"]>
	Conjunto de etiquetas query y/o update
</sql:transaction>

ATRIBUTOS:

• dataSource: objeto DataSource asociado a la base de datos a la que se accede. Se utiliza este DataSource por todas las operaciones query y update que se definan dentro.
• isolation: nivel de aislamiento de la transacción, que puede ser "read_committed", "read_uncommitted", "repeatable_read" o "serializable".

param

El tag param permite definir parámetros a la hora de ejecutar consultas (query) o actualizaciones (update). Así, se sustituyen las marcas "?" que pueda haber en consultas o actualizaciones, por los valores de los parámetros que se indiquen.

SINTAXIS:

Sin cuerpo:

<sql:param value="valor"/>

Con cuerpo:

<sql:param>
	Valor
</sql:param>

ATRIBUTOS:

• value: valor del parámetro. Puede indicarse mediante este atributo o como cuerpo del tag.

Los valores de los parámetros se sustituyen en las etiquetas en el orden en que se van definiendo. Veremos un ejemplo más adelante.

Otras Etiquetas

Se tienen otras etiquetas, como dateParam, que es igual que param pero para parámetros de tipo Date (fechas). No la veremos con más detalle aquí.

EJEMPLO

Vemos un ejemplo de uso de las etiquetas explicadas.

• Creamos un DataSource mediante una etiqueta setDataSource, que se conecta a la base de datos miBD, de MySQL. Guardamos el DataSource en la variable miDataSource:

<sql:setDataSource 
	url="jdbc:mysql//localhost/miBD" 
	driver="org.gjt.mm.mysql.Driver"
	user="root" password="mysql"
	var="miDataSource"
/>

• Ejecutamos una consulta (query) que muestra todos los nombres de la tabla nombres. Guardamos el resultado en la variable miConsulta:

<sql:query var="miConsulta" 
 dataSource="${miDataSource}">
	SELECT nombre FROM nombres
</sql:query>

<c:foreach var="fila" items="${miConsulta.rows}">
	<c:out value="${fila.nombre}"/><br>
</c:foreach>

• Ejecutamos una actualización que actualice el nombre que tenga id = 1 o id = 2:

<sql:update dataSource="${miDataSource}">
	UPDATE nombres SET nombre='pepe' 
	WHERE id=1 OR id=2
</sql:update>

• Utilizamos dos etiquetas param para pasar como parámetros los id de los nombres que se tienen que actualizar:

<sql:update dataSource="${miDataSource}">
	UPDATE nombres SET nombre='pepe' 
	WHERE id=? OR id=?
	<sql:param value="${param.id1}"/>
	<sql:param value="${param.id2}"/>
</sql:update>

Se sustituiría la primera ? por el primer param y la segunda ? por el segundo param. Los dos parámetros se toman en este ejemplo de la petición request. Pueden tomarse de cualquier otro sitio (constantes, variables, etc).

• Vemos cómo quedarían las dos operaciones anteriores en una transacción (transaction):

<sql:transaction dataSource="${miDataSource}">

	<sql:query var="miConsulta">
		SELECT nombre FROM nombres
	</sql:query>

	<c:foreach var="fila" 
	 items="${miConsulta.rows}">
		<c:out value="${fila.nombre}"/><br>
	</c:foreach>

	<sql:update dataSource="${miDataSource}">
		UPDATE nombres SET nombre='pepe' 
		WHERE id=? OR id=?
		<sql:param value="${param.id1}"/>
		<sql:param value="${param.id2}"/>
	</sql:update>

</sql:transaction>

EJEMPLO

Vemos cómo quedaría el ejemplo visto en la sesión anterior para la librería dbtags adaptado a la librería sql. 

<%@ taglib uri="sql" prefix="sql" %>
<%@ taglib uri="core" prefix="c" %>

<html>
<body>
	<sql:setDataSource url="jdbc:mysql://localhost/prueba" 
	 driver="org.gjt.mm.mysql.Driver" 
	 user="root" password="mysql" var="miDataSource"/>

	<sql:query var="miConsulta" dataSource="${miDataSource}">
		SELECT * FROM datos
	</sql:query>

	<c:forEach var="fila" items="${miConsulta.rows}">
	Nombre: <c:out value="${fila.nombre}"/><br>
	Descripcion: <c:out value="${fila.descripcion}"/><br>
	</c:forEach>
</body>
</html>

Utilizamos la librería sql y la core para recorrer todos los registros encontrados. Para probar el ejemplo, copiad este fichero WAR en el directorio webapps de Tomcat, reiniciar el servidor y ejecutad:

http://localhost:8080/ejemplojstlsql/dbtags.jsp 

3.5.5. La librería XML

Los tags de la librería de XML permiten tener acceso y procesar el contenido de documentos XML, utilizando la recomendación XPath del W3C como un lenguaje de expresiones local. Esta librería se utiliza con el prefijo "x".

Dentro de la librería, distinguimos entre los tags principales (que nos permiten explorar el contenido de un fichero XML), tags de control de flujo (para realizar código en función de dicho contenido), y tags de transformación (que permite transformar ficheros XML aplicando hojas de estilo XSLT).

3.5.6. La librería de internacionalización

Los tags de la librería de internacionalización (o I18n)  permiten adaptar aplicaciones Web a las convenciones de idioma y formato de los clientes para un determinado origen (locale). Los tags de esta librería se presentan con el prefijo "fmt".

En la librería tenemos tags para la internacionalización propiamente dicha, y para el formato de determinados elementos según la región (podremos formatear números, fechas, monedas, etc, dependiendo del idioma o región que se trate).