JSP(II) - Aula Virtual

JSP (II)
Aplicaciones Distribuidas
Contenido
•
JSP 2.0
•
Expression Language (EL)
•
Validadores de bibliotecas (TLVs)
•
JSTL 1.1
•
Funciones JSP 2.0
•
Simples Custom Tags
•
Ficheros TAG
2
JSP 2.0
•
¿Qué añade JSP 2.0 frente a JSP 1.x?
• Lenguaje de expresiones. Anteriormente sólo disponible en JSTL
• JSP Documents
• Páginas JSP en sintaxis XML
• JSP 1.2 también permitía escribir documentos JSP, pero de una manera más
incómoda
•
Implementar tags a medida utilizando la propia tecnología JSP
• Se implementan en páginas JSP
• Más sencillo que el API de extensión de tags (javax.servlet.jsp.tagext), pero
menos potente
• Útil para tags orientados a presentación, para tags que hagan uso de librerías
existentes y para desarrolladores de páginas JSP que no dispongan de
conocimientos de Java
•
Compatibilidad con JSP 1.x
• Un contenedor de JSP 2.0 ejecuta aplicaciones con sintaxis JSP 1.x
• Es posible migrar una aplicación JSP 1.x a sintaxis JSP 2.0 página a página
3
Lenguaje de Expresiones
(EL)
• EL no es un lenguaje de programación en sí
mismo, su único propósito es:
• Referenciar objetos y sus propiedades
• Escribir expresiones simples.
4
Lenguaje de Expresiones
(EL)
•
En JSP 1.x si se desea dar valor a un atributo de un tag, es preciso usar
una expresión <%= ... %>
• Ejemplo
<jsp:useBean id="shoppingCart" scope="session"
class="org.acme.ShoppingCart"/>
<xxx:if test="<%= shoppingCart.getNumberOfProducts() > 0 %>” > …
</xxx:if>
•
JSP 2.0 proporciona un lenguaje de expresiones para facilitar su
construcción
• Ejemplo
<xxx:if test="${sessionScope.shoppingCart.numberOfProducts > 0}">
...
</xxx:if>
5
• Las expresiones JSTL comienzan con ${ y terminan con }. Lo que hay
en medio es tratado como una expresión.
•
EL se basa en las siguientes normas:
• Las expresiones se componen de:
• Identificadores. Hay once identificadores reservados que corresponden a once
objetos implícitos. 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.
• Los literales que incluyen el símbolo ${, deben ir dentro de ${' y '}
• Ejemplo:
<xxx:aTag att="This literal includes ${'${'} character"/>
6
• 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}".
• Las expresiones pueden contener operaciones aritméticas y
lógicas, operaciones booleanas, y agruparse mediante
paréntesis. También pueden decidir cuando una variable
existe o no (usando empty).
7
•
Acceso a atributos de objetos Java en expresiones
• Se puede acceder a las propiedades de un JavaBean, y a objetos de un
Map, List o Vector usando el operador punto, o el operador corchete
• ${bean.propiedad}
• ${map.elemento}
• ${header['User-Agent']}
• Equivalencias
${user.firstName} user.getFirstName()
${user.address.city} user.getAddress().getCity()
${user.preferencesMap["shipping"]} user.getPreferencesMap().get("shipping")
${user.preferencesList[0]} user.getPreferencesList().get(0)
• Si un campo de un bean es otro bean, podemos encadenar puntos para
acceder a una propiedad del segundo bean:
• ${bean1.bean2.propiedad}
8
9
• Las expresiones pueden aparecer como parte del valor de
un atributo de una etiqueta:
<c:out value="${2+2}"/>
<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}"/>
10
•
Ejemplo:
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>
<%-- ACCESO A TODOS LOS ELEMENTOS --%>
<c:forEach items="${header}" var="item">
<c:out value="${item}"/><br/>
</c:forEach>
<br/>
<%-- ACCESO POR NOMBRE CON PUNTO: objeto.propiedad --%>
Host: <c:out value="${header.Host}"/> <br/>
<%-- ACCESO POR NOMBRE CON CORCHETES: objeto['propiedad']
Usar este formato evita que se interprete el nombre como una expresión.
Por ejemplo: queremos la propiedad "Accept-Language" no una resta entre
las variables Accept y Language.
--%>
Host: <c:out value="${header['Host']}"/> <br/>
Accept-Language: <c:out value="${header['Accept-Language']}"/> <br/>
11
•
El resultado es:
accept-encoding=gzip, deflate
cache-control=no-cache
connection=Keep-Alive
referer=http://127.0.0.1:8080/sampleJSTL/
host=127.0.0.1:8080
accept-language=es
user-agent=Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1; MyIE2;
.NET CLR1.1.4322)
cookie=JSESSIONID=E58368E8FFA066A654750C4CED08AA88
accept=*/*
Host: 127.0.0.1:8080
Host: 127.0.0.1:8080
Accept-Language: es
12
•
Operador
• .
• []
• ()
• :?
•
•
•
•
Descripción
Acceso a propiedad o elemento de un Map.
Acceso a elemento de un array o de un List.
Agrupación de expresiones.
Expresión condicional: condición ?
valorSiCierto:valorSiFalso
+, -, *, / (o div), % (o mod)
Suma, resta, multiplicación, división, resto.
== (o eq), != (o ne), < (o lt),> (o gt), <= (o le), >= (o ge)
Igualdad, desigualdad, menor que, mayor, menor o igual que,
mayor o
igual que.
&& (o and), || (o or), ! (o not)
Operadores lógicos and, or, y not.
empty
Comprueba si una colección (array, Map, Collection) es null o
vacía.
Ejemplo:
<xxx:if test="${!empty requestScope.previous}">...</xxx:if>
• función(argumentos)
Llamada a una función.
13
• Resumen de precedencia de operadores
• [], .
• ()
• - unario, not, !, empty
• *, /, div, %, mod
• +, - binario
• (), <, >, <=, >=, lt, gt, le, ge
• ==, !=, eq, ne
• && (o and)
• || (o or)
14
• Literales
• En expresiones EL podemos usar números, caracteres,
booleanos (palabras clave true, false), y null (palabra
clave null).
15
•
Objetos implícitos
•
•
Ciertos objetos son automáticamente accesibles a cualquier etiqueta JSP.
A través de ellos es posible acceder a cualquier variable de los ámbitos page, request, session,
application, a parámetros HTTP, cookies, valores de cabeceras, contexto de la página, y
parámetros de inicialización del contexto.
•
Todos, excepto pageContext, están implementados usando la clase java.util.Map.
•
Objetos implicitos
contiene
pageScope
requestScope
sessionScope
applicationScope
param
paramValues
header
headerValues
cookie
initParam
pageContext
Variables de ámbito página.
Variables de ámbito request.
Variables de ámbito session.
Variables de ámbito application.
Parametros del request como cadenas.
Parametros del request como array de cadenas.
Cabeceras del request HTTP como cadenas.
Cabeceras del request HTTP como array de cadenas.
Valores de las cookies recibidas en el request.
Parametros de inicialización de la aplicación Web.
El objeto PageContext de la página actual.
16
• Cuando se usa un objeto sin especificar su ámbito
(el objeto implícito en el que está contenido), se
busca en los ámbitos page, request, session y
application (en este orden)
• Ejemplo
<xxx:if test="${shoppingCart.numberOfProducts > 0}">
...
</xxx:if>
17
•
pageContext
• Consultar en el javadoc. Existe correspondencia:
•
Ej: pageContext.request.authType ejecuta el método HttpServletRequest.getAuthType().
Expresión
Descripción
${pageContext.exception.message}
Devuelve una descripción del error cuando la
página en curso es una página de error JSP.
${pageContext.errorData}
Información de un error JSP.
${pageContext.request.authType}
Tipo de autentificación usado en la página.
${pageContext.request.remoteUser}
Identificador del usuario (cuando esta en uso la
autentificación del contenedor).
${pageContext.request.contextPath}
Nombre o contexto de la aplicación.
${pageContext.request.cookies}
Array de cookies.
${pageContext.request.method}
Método HTTP usado para acceder a la página.
${pageContext.request.requestURL}
URL usada para acceder a la página.
${pageContext.session.new}
Contiene true si la sesión es nueva, false si no lo es.
${pageContext.servletContext.serverInfo}
Información sobre el contenedor JSP.
18
•
En JSP 2.0, cuando se produce un error la excepción ocurrida está
disponible en el ámbito request con el nombre javax.servlet.error.exception.
Ademas, se adjunta al contexto de la página información adicional en
forma de bean con nombre errorData (declaracion de página de error en
JSP)
Propiedad
Tipo Java
Descripción
requestURI
String
URI de la petición fallida.
servletName
lanzó
String
Nombre de la página o servlet que
la excepción.
statusCode
int
Código HTTP del fallo.
throwable
Throwable
19
La excepción que produjo el
fallo.
•
Funciones EL:
• Las funciones representan un modo de extender la funcionalidad del
lenguaje de expresiones. Se usan dentro de cualquier expresión EL,
ejemplo:
• Mi nombre de usuario tiene ${fn:length(username)} letras.
•
En el descriptor de la biblioteca de funciones, se establece una
correspondencia entre el nombre de la función y un método
estático de una clase Java.
<function>
<description> Returns the number of items in a collection or the number of
characters in a string. </description>
<name>length</name>
<function-class> org.apache.taglibs.standard.functions.Functions
</function-class>
<function-signature>int length(java.lang.Object) </function-signature>
</function>
20
•
Existen 16 funciones de manipulación de cadenas:
• Alternar una cadena entre mayúsculas/minúsculas: toLowerCase, toUpperCase.
• Obtener una subcadena: substring, substringAfter, substringBefore.
• Eliminar el espacio en blanco en ambos extremos de una cadena: trim.
• Reemplazar caracteres en una cadena: replace.
• Comprobar si una cadena contiene a otra: indexOf, startsWith,endsWith,
contains, containsIgnoreCase.
• Convertir una cadena en array (split), o un array en cadena (join).
• Codificar los caracteres especiales del XML: escapeXml.
• Obtener la longitud de una cadena: length.
•
La función length también puede aplicarse a instancias de java.util.Collection, caso en
el cual devolverá el número de elementos de una colección.
•
Todas las funciones EL interpretan las variables no definidas o definidas con valor
igual a null, como cadenas vacías.
21
•
Fichero descriptor
<jsp-config>
<jsp-property-group>
•Indicar que queremos interpretar EL
<el-ignored>false</el-ignored>
•Indicar que no soportamos scriplet
<scripting-invalid>true</scripting-invalid>
•Cabecera por defecto
<include-prelude>prelude.jsp</include-prelude>
•Pie por defecto
<include-coda>coda.jsp</include-coda>
22
•
Ejemplo
<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app >
<description>Ejemplos de EL</description>
<display-name>Ejemplos de JSP 2.0 </display-name>
<jsp-config>
<jsp-property-group>
<description>Definicion de atributos</description>
<display-name>ConfiguracionJSP</display-name>
<url-pattern>/*</url-pattern>
<el-ignored>false</el-ignored>
<page-encoding>ISO-8859-1</page-encoding>
<scripting-invalid>true</scripting-invalid>
<include-prelude>prelude.jspf</include-prelude>
<include-coda>coda.jspf</include-coda>
</jsp-property-group>
</jsp-config>
</web-app>
23
Validadores de bibliotecas
(TLVs)
•
¿Que es un TLV?
•
•
Los TLVs (Tag Library Validators) son validadores asociados a bibliotecas de etiquetas. Antes de
ejecutar cada etiqueta, el contenedor ejecuta automáticamente los TLV que tenga asociados (si
existe alguno).
ScriptFree: Permite restringir los elementos de scripting de una página JSP. Sus
parámetros son:
parámetro
allowRTExpressions
restringe
Valores dependientes del request.
por defecto
true
Ejemplo: <c:out value="<%=request%>"/>
allowExpressions
Expresiones: <%= ... %>
true
allowScriptlets
Scriptlets: <% ... %>
true
allowDeclarations
Declaraciones: <%! ...%>
true
•
Su implementación es la clase ScriptFreeTLV y se define en el fichero: scriptfree.tld.
•
En JSP 2.0 también es posible usar el elemento scripting-invalid para impedir el uso
de código java en las páginas JSP.
24
•
PermittedTaglibs: Permite restringir los tld a importar en una página. Su
implementación es la clase PermittedTaglibsTLV y se define en el fichero
tld permittedTaglibs.tld.
•
•
Acepta un único parámetro (permittedTaglibs) que contiene las uris permitidas separadas por
un espacio.
El fichero permittedTaglibs.tld tiene la siguiente configuración:
<validator>
<validator-class> javax.servlet.jsp.jstl.tlv.PermittedTaglibsTLV </validator-class>
<init-param>
<param-name>permittedTaglibs</param-name>
<param-value>
http://java.sun.com/jstl/core
http://java.sun.com/jstl/fmt
http://java.sun.com/jstl/sql
http://java.sun.com/jstl/xml
</param-value>
<description>Whitespace-separated list of taglib URIs to permit.</description>
</init-param>
</validator>
25
•
Si queremos usarlos en nuestra biblioteca de etiquetas, podemos
indicarlo en el fichero taglib o directamente en la página
adjuntando la directiva taglib correspondiente. Por ejemplo:
<%@ taglib prefix="scriptfree" uri=http://jakarta.apache.org/taglibs/standard/scriptfree …
•
Con la línea anterior indicamos el uso de ScriptFreeTLV con los
parámetros que figuran en el fichero scriptfree.tld
•
Si queremos personalizarlo podemos editar el .tld y copiar el
elemento validator al tld de nuestras etiquetas, ajustando los
parámetros según nos convenga.
26
JSTL
• En el pasado existían numerosas librerías de tags
JSP que permitían
• Iterar sobre colecciones
• Imprimir valores de propiedades de JavaBeans de
forma segura
• Internacionalización de mensajes, números, fechas,
etc.
• Generación de URLs aplicando URL rewriting
• Acceso a documentos XML
• Etc…
27
•
Se decidió estandarizar una librería general de tags, llamada JSTL (JSP Standard Tag
Library)
•
Core
•
•
•
I18n (internacionalización)
•
•
•
Soporte para internacionalización: establecimiento del Locale, generación de mensajes, formateo de
números, cantidades monetarias, fechas, etc.
XML
•
Parsing de un documento XML
•
•
Flujo de control para recorrer un documento XML (alternativa a XSL para casos sencillos)
Tags para lanzar transformaciones XSL
Acceso a BDs
•
•
•
Control de flujo
Soporte para URLs
Permiten lanzar sentencias SQL a BDs relacionales
Sólo deberían usarse para prototipado rápido o aplicaciones muy simples
Funciones
•
•
JSP 2.0 define un mecanismo para añadir funciones al lenguaje de expresiones
JSTL 1.1 define un conjunto de funciones estándar: length (aplicable a Collection y String),
toLowerCase,toUpperCase, substring, contains, etc…
28
•
Crear una página JSP con JSTL
•
En toda página JSP hay que declarar la biblioteca a la que pertenece cada etiqueta que usemos.
•
Puesto que son varias líneas, podemos hacer las declaraciones en un fichero aparte, y luego
incluir dicho fichero en nuestras páginas JSP. Este sistema evita repetir el mismo texto en todas
las páginas, y si en el futuro añadimos más bibliotecas, solo tendremos que modificar un único
fichero.
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jstl/xml" %>
<%@ taglib prefix="sql" uri="http://java.sun.com/jstl/sql" %>
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
•
Luego usando la directiva include:
<%@include file="taglibs.jsp" %>
<html>
<body>
<c:out value="Hola mundo"/>
</body>
</html>
29
•
Objetivo JSTL
• “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
Para usarlas en un JSP:
<%@ taglib prefix="c“ uri=http://java.sun.com/jsp/jstl/core %>
30
•
Para cualquier aplicación web desde la cual se quiera usar JSTL, hay que copiar los
ficheros .tld al directorio WEB-INF de la aplicación web.
•
Editar el web.xml de la aplicación web añadiendo las siguientes entradas
<taglib>
<taglib-uri>http://java.sun.com/jsp/jstl/fmt</taglib-uri>
<taglib-location>/WEB-INF/fmt.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>http://java.sun.com/jsp/jstl/core</taglib-uri>
<taglib-location>/WEB-INF/c.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>http://java.sun.com/jsp/jstl/sql</taglib-uri>
<taglib-location>/WEB-INF/sql.tld</taglib-location>
</taglib>
<taglib>
<taglib-uri>http://java.sun.com/jsp/jstl/x</taglib-uri>
<taglib-location>/WEB-INF/x.tld</taglib-location>
</taglib>
31
Tags en JSP 2.0
•
Declaración de funciones en JSP 2.0
•
•
JSP 2.0 permite la declaración en un fichero TLD de funciones invocables desde cualquier JSP
EL de JSP 2.0 permite invocar a un método público de una clase usando la siguiente
sintáxis:
${prefix:methodName(param1, param2, ...)}
•
La función JSP debe ser declarada en un tag library descriptor (TLD):
<function>
<name>methodName</name>
<function-class>className</function-class>
<function-signature>
returnType methodName(param1Type, param2Type, ...)
</function-signature>
</function>
32
•
La clase Java que implementa la función no tiene que utilizar ninguna
interfaz especial, el método debe ser público y estático. Ejemplo fichero
TLD:
<?xml version="1.0" encoding="UTF-8" ?>
<taglib>
<tlib-version>1.0</tlib-version>
<short-name>tf</short-name>
<uri>http://www.um.es/dad/TestFunction.tld</uri>
<function>
<name>testMethod</name>
<function-class> um.es.dad.TestFunction </function-class>
<function-signature>
java.lang.String testMethod(um.es.dad.TestBean, java.lang.String, int, boolean)
</function-signature>
</function>
</taglib>
33
•
JSP 2.0 define Simple Tag Handler API, apropiada para etiquetas
personalizadas
•
Simple Custom Tags
• Son introducidos en JSP 2.0.
• Tienen un ciclo de vida más sencillo que los custom tags clásicos y pueden ser
escritos en Java o en JSP.
• Son simples por dos razones:
•
Son más simples de usar y de escribir.
•
Su funcionalidad está basada en la interface javax.servlet.jsp.SimpleTag (no relacionada con
la interface Tag).
• El método más importante de la interface es el doTag()
• La API de JSP provee un clase que implementa la interfaceSimpleTag:
javax.servlet.jsp.tagext.SimpleTagSupport.
• Hay que añadir elementos setter por cada atributo e implementar doTag
•
Sólo se invoca un método no tres como antes: doStartTag(), doAfterBody(), doEndTag()
34
•
El ciclo de vida tiene pues, dos partes: la inicialización y la ejecución del método
doTag().
•
Los atributos pueden ser:
• Estáticos
•
•
Es obligatorio declararlos en el TLD.
La clase que implementa el custom tag debe implementar los métodos set|get de acuerdo con
la especificación de JavaBeans.
• Dinámicos
•
•
•
No necesitan ser declarados individualmente en el TLD.
En el TLD hay que indicar que el tag usará atributos dinámicos, agregando el elemento
<dynamic-attributes>true<../> como elemento hijo de <tag>.
Un custom tag que implementa atributos dinámicos debe implementar la interface:ºº
javax.servlet.jsp.tagext.DynamicAttributes.setDynamicAttribute(String uri, String
localName, Object value)
•
IMPORTANTE: no se permiten elementos de scripting en el cuerpo del elemento
siempre que la custom tag utilice un simple tag handler
35
• Ficheros TAG
• JSP 2.0 permite desarrollar una acción propietaria como
un fichero de tag (tag file).
• Introduce los archivos .tag, y así es posible escribir
custom tags en JSP.
• Un tag file es un fichero de texto donde se utilizan
elementos JSP para todas las partes dinámicas (tiene la
misma funcionalidad que un Tag Handler)
• Se diferencia de un JSP en que:
• Tiene extensión .tag
• Usa una directiva tag en vez de page
• Permite especificar entrada y salida con directivas válidas sólo
en tag files.
36
•
Los archivos .tag mezclan scriptlets y expresiones, y se ubican el
el directorio WEB-INF/tags o en un subdirectorio de tags.
•
¡No es necesario TLD ni mapeo en el web.xml!.
•
JSP 2.0 introduce el atributo tagdir a la directiva page:
<%@ taglib prefix=“test” tagdir=“/WEB-INF/tags” %>
•
Las directivas disponibles para uso en los archivos .tag: @taglib,
@include, @tag, @attribute y @variable
•
Las directivas @tag, @attribute y @variable están disponibles
solamente en archivos .tag e imitan la funcionalidad provista por
los elementos del archivo TLD.
•
Básicamente son análogas a los elementos del TLD con igual
nombre.
37
•
La directiva tag es similar a page
• Declara características generales del fichero.
• Su atributo body-content indica:
• empty el elemento XML representando la acción no tiene cuerpo
• scriptless el cuerpo no puede contener código Java
• tagdependent el contenedor pasa el cuerpo al evaluador de la tag
•
La directiva attribute declara atributos válidos para la acción
definida
• Su atributo type indica el tipo de datos, por defecto String
•
Ejemplo fichero .tag:
<%@ tag body-content="empty" %>
<%@ attribute name="url" required="true" %>
<%@ attribute name="texto" required="true"%>
<a href="${url}">${texto}</a>
38
ANEXOS
39
40
41
42
43
•
Anexo B (Librerias JSTL)
CORE
Permiten llevar a cabo las siguientes acciones:
•
Visualizar/asignar valores y manejar excepciones
•
Control de flujo
•
Otras acciones de utilidad
Para visualizar valores utilizamos:
<c:out: value="${applicationScope.product.inventoryCount}" 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="$param.customerNumber" scope="session" />
•
scope indica el contexto en el que se define la variable
44
También podemos asignar el contenido de una etiqueta a una variable:
<c:set var="cellContents">
<td>
<c:out value="${myCell}"/>
</td>
</c:set>
45
46
•
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>
•
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>
47
•
Para codificar URLs se puede utilizar c:url:
<c:url value="http://acme.com/exec/register" var="myUrl">
<c:param name="name" value="${param.name}"/>
<c:param name="country" value="${param.country}"/>
</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 a
jsp:include)
•
Para manejar redireccionamiento se puede utilizar la etiqueta c:redirect
•
Cuando EL se migró de la especificación JSTL a JSP, se le añadió una nueva funcionalidad: la invocación a
funciones.
•
Su uso es trivial: nombre-func(lista-params)
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
${fn:length(myCollection)}
48
Internacionalizacion / Formateo
•
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="java.util.Date" />
<fmt:formatDate value="${now}" timeStyle="long" dateStyle="long"/>
<fmt:parseDate value="${dateInput}" pattern="MM dd, YYYY" />
49
•
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>
50
SQL/DB
•
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
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<sql:setDataSource driver="com.cheapDrivers.jdbcDriver“ 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="${orderItems.rows}">
<tr>
<td><c:out value="${row.itemName}"/></td>
<td><c:out value="${row.price}"/></td>
<td><c:out value="${row.weight}"/></td>
</tr>
</c:forEach>
</table>
51
•
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>
52
•
Es necesario definir un DataSource: (1) añadir el siguiente párrafo a
$CATALINA_HOME/conf/server.xml:
<Context path="/DBTest" docBase="DBTest"
debug="5" reloadable="true" crossContext="true">
<Resource name="jdbc/TestDB" auth="Container" type="javax.sql.DataSource"
maxActive="100" maxIdle="30" maxWait="10000"
username="javauser" password="javadude"
driverClassName="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/javatest?autoReconnect=true"/>
</Context>
•
Y crear un fichero de configuración para esta aplicación WEB-INF/web.xml:
<web-app>
<description>MySQL Test App</description>
<resource-ref>
<description>DB Connection</description>
<res-ref-name>jdbc/TestDB</res-ref-name>
<res-type>javax.sql.DataSource</res-type>
<res-auth>Container</res-auth>
</resource-ref>
</web-app>
53
Para el ejemplo anterior se puede probar:
<%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" 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="${rs.rows}">
Foo ${row.foo}<br/>
Bar ${row.bar}<br/>
</c:forEach>
</body>
</html>
54
Procesamiento XML
•
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.
Accion 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="http://www.cheapstuff.com/orderStatus?id=2435" 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"/>
55
JSTL se integra bien con XSTL