JSP (II) - aulavirtual.um.es · • EL se basa en las siguientes normas: • Las expresiones se...

JSP (II)Aplicaciones Distribuidas

2

Contenido

• JSP 2.0

• Expression Language (EL)

• Validadores de bibliotecas (TLVs)

• JSTL 1.1

• Funciones JSP 2.0

• Simples Custom Tags

• Ficheros TAG

3

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

4

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.

5

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 suconstrucción

• Ejemplo<xxx:if test="${sessionScope.shoppingCart.numberOfProducts > 0}">

...

</xxx:if>

6

• 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"/>

7

• 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).

8

• 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}

10

• 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}"/>

11

• 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/>

12

• 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

13

• 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.

14

• Resumen de precedencia de operadores

• [], .

• ()

• - unario, not, !, empty

• *, /, div, %, mod

• +, - binario

• (), <, >, <=, >=, lt, gt, le, ge

• ==, !=, eq, ne

• && (o and)

• || (o or)

15

• Literales

• En expresiones EL podemos usar números, caracteres, booleanos (palabras clave true, false), y null (palabra clave null).

16

• 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 Variables de ámbito página.

requestScope Variables de ámbito request.

sessionScope Variables de ámbito session.

applicationScope Variables de ámbito application.

param Parametros del request como cadenas.

paramValues Parametros del request como array de cadenas.

header Cabeceras del request HTTP como cadenas.

headerValues Cabeceras del request HTTP como array de cadenas.

cookie Valores de las cookies recibidas en el request.

initParam Parametros de inicialización de la aplicación Web.

pageContext El objeto PageContext de la página actual.

17

• 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>

18

• 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 lapá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 laautentificació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.

19

• 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 String Nombre de la página o servlet que lanzó la excepción.

statusCode int Código HTTP del fallo.

throwable Throwable La excepción que produjo el fallo.

20

• 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 unacorrespondencia 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>

21

• 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.

22

• 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>

23

• 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>

24

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 restringe por defecto

allowRTExpressions Valores dependientes del request. trueEjemplo: <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.

25

• 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>

26

• 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.

27

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…

28

• Se decidió estandarizar una librería general de tags, llamada JSTL (JSP Standard Tag Library)• Core

• Control de flujo

• Soporte para URLs

• 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

• 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…

29

• 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>

30

• 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 %>

• 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

32

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>

33

• 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>

34

• 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()

35

• 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

36

• 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.

37

• 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.

38

• 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>

39

ANEXOS

44

• 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

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

47

• 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>

48

• 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)}

49

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" />

50

• Acciones de internacionalización:• Una pieza importante de la localización en Java es la clase

ResourceBundle. Las acciones JSTL que permiten trabajar con estaclase 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>

51

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>

52

• 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>

53

• 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>

54

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>

55

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

<c:import url="http://www.cheapstuff.com/orderStatus?id=2435" var="xml"/>

<x:parse xml="${xml}" var="doc"/>



<x:out select="$doc/name"/>

<x:out select="$doc/shippingAddress"/>

<x:out select="$doc/deliveryDate"/>



<x:set var="custName" scope="request" select="$doc/name"/>

JSTL se integra bien con XSTL

JSP (II) - aulavirtual.um.es · • EL se basa en las siguientes normas: • Las expresiones se...

Documents

Transcript of JSP (II) - aulavirtual.um.es · • EL se basa en las siguientes normas: • Las expresiones se...