Your SlideShare is downloading. ×
Jsp
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Saving this for later?

Get the SlideShare app to save on your phone or tablet. Read anywhere, anytime - even offline.

Text the download link to your phone

Standard text messaging rates apply

Jsp

2,289
views

Published on


0 Comments
0 Likes
Statistics
Notes
  • Be the first to comment

  • Be the first to like this

No Downloads
Views
Total Views
2,289
On Slideshare
0
From Embeds
0
Number of Embeds
0
Actions
Shares
0
Downloads
80
Comments
0
Likes
0
Embeds 0
No embeds

Report content
Flagged as inappropriate Flag as inappropriate
Flag as inappropriate

Select your reason for flagging this presentation as inappropriate.

Cancel
No notes for slide

Transcript

  • 1. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -1- Capítulo 15: Introducción a JSP* El estándar HTML propone el suministro de informaciónmediante páginas estáticas. De esta forma es imposiblesuministrar páginas creadas al momento en base a requisitos delcliente. Ej: consultar una base de datos desde una página HTMLy obtener otra página automáticamente sólo con los resultadosdeseados.* Otras tecnologías empleadas tradicionalmente han sido CGI,ASP, PHP. S sobre ellas son:* Las principales ventajas de JSP• Mayor encapsulamiento:G T Uso de clases• T Uso de JavaBeans Mayor escalabilidad R• Uso de tags: similitud con HTML• Mayor portabilidad• Uso de un lenguaje estándar y muy difundido* El lenguaje en que actualmente está basado JSP es Java* Realmente una página JSP se convierte en un servlet que esquien se encarga de la comunicación con el clienteCapítulo 15: Introducción a JSP.
  • 2. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -2- Funcionamiento* ¿Cuál es el funcionamiento básico? Muy sencillo:1) El cliente solicita una página .jsp (en lugar de .html)2) La solicitud llega al servidor3) El servidor «ejecuta» la página .jsp y obtiene un texto en formato html4) El servidor envía el texto html al cliente5) El navegador del cliente visualiza el texto html como si realmente hubiera estado almacenado en el servidor* ¿Que hay dentro de un fichero .jsp? Un fichero .jsp es un fichero .html que tiene dentro «algunas cosas» que se pueden ejecutar y que producen como resultado más html* El siguiente dibujo resume el funcionamiento:* Realmente, la solicitud de la página JSP le llega (en nuestrosejemplos) al motor JSP a través del puerto 8080Capítulo 15: Introducción a JSP.
  • 3. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -3- Instalación* El motor o servidor JSP puede ser el JSWDK, o bien ApacheTomcat* Usaremos Tomcat ya que tiene soporte para tags. JSWDK no* Consideraciones de instalaciones de Tomcat:• Quitar el start de la invocación a javac en tomcat.bat• Al comienzo de startup.bat poner: set JAVA_HOME=d:jdk1.3• El puerto de escucha se puede modificar en /conf/server.xml•• Los servlets se ubican en /WEB-INF/classes S Los ficheros .jsp y .tld se encuentran a partir de ROOT• G Tomcat no acepta la etiqueta bodycontent en un fichero .tld• R Modificar el classpath para que se encuentren todos los .class necesarios, especialmente jdk1.3/lib/tools.jar• Cuando se usan etiquetas, los ficheros .class que heredan de Tag deben pertenecer a un paquete• Tomcat se arranca con startup• Es conveniente crear en el directorio ROOT un directorio jsp para guardar las páginas JSP• La ubicación de los ficheros .tld se puede indicar a través del fichero /conf/web.xml* Estas consideraciones de instalación son básicas para elbuen funcionamiento del servidor TomcatCapítulo 15: Introducción a JSP.
  • 4. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -4- Componentes JSP* Los componentes que se pueden meter enmedio de una páginaHTML para hacerla dinámica (hacerla JSP) son:L Expresiones: son de la forma: <%= expresión Java %> El motor traduce la expresión por la cadena que resulta de evaluarlaL Declaraciones: son de la forma: <%! declaraciones Java %> Lo que se escriba aquí será global a toda la página JSP (realmente se inserta tal cual en el cuerpo del servlet fuera de todo método) Pueden incluirse declaraciones de variables y de funcionesL Scriplets: son de la forma: <% código Java %> Código Java que se ejecutará en el punto concreto de la página JSP en que se encuentraCapítulo 15: Introducción a JSP.
  • 5. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -5- Componentes JSPL Comentarios: son de la forma: <%-- comentario –%> No se envían al clienteL Directivas: son de la forma: <%@ directiva atributo1=" valor1" atributo2=" valor2" ... %> Permiten definir la estructura de todo el documento JSP. Realmente indican aspectos básicos del servlet en que se convertirá el fichero JSP en que se encuentra. Se procesan S en el momento de convertir la página JSP en un servlet. Las tres directivas existentes son: O <%@ page ... %> O <%@ include file=”URL relativa” %> G R Sirve para incluir un fichero dentro de otro en el momento en que la página JSP se convierte en servlet O <%@ taglib ... %>L Etiquetas jsp: son de la forma: <jsp:etiqueta atributos /> Realizan operaciones diversas. Su utilidad principal es para comunicarse con los JavaBeans de forma que el código dela página .jsp sea lo más parecido al .htmlCapítulo 15: Introducción a JSP.
  • 6. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -6- Primer ejemplo* El ejemplo más sencillo consiste en cambiarle la extensión acualquier fichero .html y ponerle .jsp, así como colocarlo en unsitio donde el servidor JSP la pueda encontrar. ¡Así de sencillo!* Con esto lo único que conseguimos es que la página nos lasirva el servidor JSP en lugar del servidor web* Una vez visto que todo funciona bien, podemos probar conalgo sencillo, tal como<HTML><HEAD><TITLE>Expresiones JSP</TITLE></HEAD><BODY><H2>Expresiones JSP</H2><UL> <LI>Fecha actual: <%= new java.util.Date().toLocaleString() %> <LI>Su máquina: <%= request.getRemoteHost() %> <LI>Su ID de sesión: <%= session.getId() %> <LI>El parámetro <CODE>testParam</CODE>: <%= request.getParameter("testParam") %></UL></BODY></HTML>* Esta página puede ser llamada como: http://localhost:8080/jsp/Ejemplo.jspo comohttp://localhost:8080/jsp/Ejemplo.jsp?testParam=alguna+cosaCapítulo 15: Introducción a JSP.
  • 7. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -7- Expresiones JSP* Las páginas JSP son especialmente úitles cuando el usuarioenvía un formulario lleno de campos en los que expresa el tipode información que solicita* Los parámetros que envía el usuario se pueden conocerenviando el mensaje getParameter(String) al objeto request,que es uno de los varios objetos que el motor JSP nos suministrapara que tengamos mayor control.* Los objetos más útiles que se nos suministran son:• request de tipo HttpServletRequest. Representa la• solicitud realizada por el cliente S response de tipo HttpServletResponse. Representa G nuestra respuesta. no tiene porqué ser una página html sino cualquier otra cosa (ver setContentType())• R session de tipo HttpSession. Representa la sesión del cliente• out de tipo JspWriter (es un PrintWriter con buffer). Es el más utilizado y representa el canal de salida de texto y datos hacia el cliente• application de tipo ServletContext. Con setAttribute y getAttribute sirve para guardar objetos globales a todas las páginas JSP• pageContext de tipo PageContext. Muy utilizado en las etiquetas para obtener el resto de objetos anteriores (que no son visibles en las etiquetas)Capítulo 15: Introducción a JSP.
  • 8. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -8- Scriptlets* Un scriptlet es un trozo de código Java* Si se ha comprendido bien el fichero .jsp anterior, se puedecomprender lo que hace un scriplet (y el funcionamiento delobjeto out) viendo la siguiente equivalencia: <LI>Fecha actual: <%= new java.util.Date().toLocaleString() %>equivale a <% String fecha new java.util.Date().toLocaleString(); out.println(“<LI>Fecha actual: “+fecha); %>* Un ejemplo más completo puede ser:<HTML><HEAD><TITLE>Prueba de colorines</TITLE></HEAD><% // Cuidado con mayúsculas y minúsculas String bgColor = request.getParameter("bgColor"); boolean hasExplicitColor; if (bgColor != null) { hasExplicitColor = true; } else { hasExplicitColor = false; bgColor = "WHITE"; }%><BODY BGCOLOR="<%= bgColor %>"><H2 ALIGN="CENTER">Color Testing</H2><% if (hasExplicitColor) { out.println("Has indicado como color de fondo " + bgColor + "."); } else { out.println("Color de fondo por defecto BLANCO. " + "Indique un valor para el atributo bgColor, " + "que puede ser una cadena RRVVAA, o un color estándar " + "si su navegador soporta colores X11."); }%></BODY></HTML>Capítulo 15: Introducción a JSP.
  • 9. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -9- Scriptlets y condiciones* Un scriptlet puede estar formado por varios trozos. Lo que hayentre ellos se considera cuerpo del scriptlet aunque sea códigoHTML.* Ejemplo:<HTML> <HEAD> <TITLE>Cuerpos dentro de bloques JSP</TITLE> </HEAD> <BODY> <H1>Cuerpos dentro de <i>Scriptlets</i></H1> <% if (Math.random() < 0.5) {%> Que tenga un buen día. <% } else { %> Que tenga mucha suerte. <% } %><p> Y ahora la tabla del 7:<br> S <% } %> G <% for (int i = 1; i <= 10; i++) { %> 7 x <%= i %> = <%= 7*i %> Perfecto <br> </BODY></HTML> RCapítulo 15: Introducción a JSP.
  • 10. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -10- Declaraciones* En las declaraciones se pueden incluir funciones y variablesque pueden utilizarse en cualquier lugar de la página<HTML> <HEAD><TITLE>Declaración de funciones</TITLE></HEAD> <%! void tabla(JspWriter out, int numero){ for (int i = 1; i <= 10; i++) try{ out.print(numero + " x " + i + " = " + numero*i+"<br>"); } catch (IOException ioe){ioe.printStackTrace();} } %> <BODY><H1>Declaración de funciones</H1> Ahora la tabla del 7 y luego la del 4:<br> <% tabla(out, 7); out.print("<p>"); tabla(out, 4); %> </BODY></HTML>* Una vez que la página JSP se carga en memoria por parte delservidor JSP se queda en ella (a menos que se modifique, encuyo caso se recompila). Ej. que lo demuestra:<HTML> <HEAD><TITLE>Declaración de variables en JSP</TITLE></HEAD> <%! private int accesos = 0; %> <BODY><H1>Declaración de variables en JSP</H1> <H2>Accesos a esta página desde que se cargó el servidor: <%= ++accesos %> . </H2> Punto indicado </BODY></HTML>* Probar a cargar la página varias veces. Luego quitar el puntoindicado y volverla a cargar varias vecesCapítulo 15: Introducción a JSP.
  • 11. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -11- Directiva page. Atributos* La directiva page se aplica a toda la página en que seencuentra. Permite los siguientes atributos:• import. Permite hacer uso de paquetes Java, de manera análoga a como se importa en un programa Java. Se puede importar un solo package o varios separándolos por comas• contentType. Permite indicar el tipo de los datos que se van a enviar al cliente enformato MIME• isThreadSafe. Una página JSP se puede ejecutar varias veces simultáneamente antes peticiones de clientes concurrentes. Si se indica isThreadSafe=”false” las peticiones se resuelven secuencialmente• S session. Un valor false indica que el objeto session no existe y se producirá un error en el momento de convertir• la página en servlet si se intenta utilizarG buffer. Cuando el servidor JSP envía la respuesta al cliente R utiliza un buffer intermedio. Con este atributo se indica su tamaño en kB, o bien la palabra none si no se quiere usar buffer• autoflush. El buffer se envía al cliente de forma automática cada vez que se llena. Si se indica false se produce un error de overflow si el buffer se llega a llenar• extends. Se usa para crear una página JSP que hereda de la clase que se indique en este atributo• errorPage. Sirve para indicar la URL de una página que se enviará al cliente en lugar de la actual si, por cualquier circunstancia, ésta se rompe• isErrorPage. Indica si la página actual es o no una página de suministro elegante de erroresCapítulo 15: Introducción a JSP.
  • 12. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -12- Ejemplo con pageFichero EjemploPage.jsp<HTML><HEAD><TITLE>Comparación entre peras y manzanas</TITLE></HEAD> <BODY><CENTER> <H2>Comparación entre peras y manzanas</H2> <%@ page errorPage="Error.html" %> <% String formato = request.getParameter("formato"); // Si el parámetro no existe se eleva un NullPointerException if (formato.equals("excel")) { response.setContentType("application/vnd.ms-excel"); } else { response.setContentType("text/plain"); } %> <TABLE BORDER=1> <TR><TH></TH><TH>Peras<TH>Manzanas <TR><TH>Primer trimestre<TD>2307<TD>4706 <TR><TH>Segundo trimestre<TD>2982<TD>5104 <TR><TH>Tercer trimestre<TD>3011<TD>5220 <TR><TH>Cuarto trimestre<TD>3055<TD>5287 </TABLE> </CENTER></BODY></HTML>Fichero Error.html<HTML><BODY>Esta página se obtiene en lugar del error tradicional<BODY><HTML>Capítulo 15: Introducción a JSP.
  • 13. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -13- Ejemplo de upload* Para subir ficheros al servidor, fotos, etc. se puede usar elpaquete com.oreilly.servlet.*: es muy útil la claseMultipartRequest, ya que el formulario de envío debe sermultiparte.Fichero upload.jsp<%@ page import="com.oreilly.servlet.*, java.util.*, java.io.*" %><%try{ MultipartRequest multi = new MultipartRequest(request, ".",10000000);// .10MB out.println(multi.getParameter("line")+"<br>"); out.println("Files:"); Enumeration files = multi.getFileNames(); while (files.hasMoreElements()) { S String name = (String)files.nextElement(); G String filename = multi.getFilesystemName(name); String type = multi.getContentType(name); File f = multi.getFile(name); R if (f==null) continue; // Por si el parámetro no está cargado BufferedReader in = new BufferedReader(new FileReader(f)); String s, s2 = new String(); while((s = in.readLine())!= null) s2 += s + "<br>"; out.println("name: " + name); out.println("filename: " + filename); out.println("type: " + type); out.println("f.length(): " + f.length()+"<br>"); out.println("fileContent: " + s2+"<br>");in.close(); }}catch(IOException e){//No es un error, sino tan sólo la primera vez que se llama a esta página}%><FORM ENCTYPE="multipart/form-data" method="POST" action="upload.jsp"><INPUT TYPE="text" NAME="line"><INPUT TYPE="file" NAME="mptest"><INPUT TYPE="submit" VALUE="upload"></FORM>Capítulo 15: Introducción a JSP.
  • 14. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -1- Capítulo 16: Etiquetas jsp: y JavaBeans* Las etiquetas jsp: difieren de las directivas en que soninterpretadas para cada petición del cliente y, por tanto, sepueden considerar una etiqueta HTML más.* Las etiquetas jsp: existentes son:• jsp:include. Se utiliza para incluir ficheros en situaciones condicionales (a diferencia de la directiva @ include que los incluye siempre). Además, permite no sólo incluir ficheros, sino los resultados de otros servlets, páginas JSP,• S etc. El resultado incluido NO puede contener JSP jsp:forward. Hace que la página actual no sea la que se G envíe al cliente, sino la que se especifique en el forward. A este respecto hay que considerar lo siguiente: En el R momento en que la página actual responda al cliente lo más mínimo ya no es posible hacer un forward, pues se produce un error. Es por ello que JSP utiliza un buffer (por defecto de 8 kB).* El formato de ambas etiquetas es muy parecido:<jsp:include page=”URLRelativa” flush=”true”> <jsp:param name=”nombreParámetro” value=”valor”> ...</jsp:include>* En el forward el atributo flush no existe, mientras que en elinclude es oblitarorio y además siempre true.Capítulo 16: Etiquetas jsp: y JavaBeans.
  • 15. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -2- Ejemplo de jsp:page* Con el cuerpo opcional jsp:param es posible enviar camposal formulario destino.Fichero includes.jsp<HTML><BODY> <H1>Includes selectivos</H1> Lo que se incluye a partir de aquí se va alternando. <%! boolean biestable = true; %> <% biestable = !biestable; if (biestable) { %> <jsp:include page="uno.jsp" flush="true"> <jsp:param name="color" value="red"/> </jsp:include> <% } else { %> <jsp:include page="dos.html" flush="true"/> <% } %></BODY></HTML>Fichero uno.jsp<% String bgColor = request.getParameter("color"); if (bgColor == null) bgColor = "WHITE"; String texto = request.getParameter("texto"); if (texto == null) texto = "Prueba de color";%><H2 ALIGN="CENTER"> <FONT COLOR="<%= bgColor %>" ><%= texto %></FONT></H2>Fichero dos.html<H1>Esto es un ejemplo de algo que se incluye</H1>* Nótese como en uno.jsp se utiliza tanto el atributo recibidopor includes.jsp como el que éste le envía. Invocar includes.jspde la forma: http://betelgeuse:8080/jsp/includes.jsp?texto=pruebaCapítulo 16: Etiquetas jsp: y JavaBeans.
  • 16. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -3- La etiqueta jsp:plugin* Es transformada automáticamente por el servidor JSP en unaetiqueta que incluye un applet que puede utilizar las extensionesdel JDK 1.2 y superiores (no es necesario que se hayadescargado el plug-in de Java para los navegadores).* Su formato es muy parecido al de la etiqueta APPLET. Unejemplo comparativo puede ser: <APPLET CODE=”MiApplet.class” WIDTH=465 HEIGHT=350> </APPLET>equivale a S <jsp:plugin type=”applet” code=”MiApplet.class” </jsp:plugin> G width=”465" height=”350"> R* Si el applet tiene parámetros, éstos se pasan igual que enjsp:include, aunque deben ir, a su vez, entre <jsp:params> y</jsp:params>* Además de losmismo atributos que permite la etiquetaAPPLET, otros atributos que posee son:• jreversion. Versión del JRE que requiere el applet• nspluginurl. La URL completa en la que es posible encontrar el plug-in para Netscape• iepluginurl. La URL completa en la que es posible encontrar el plug-in para Internet Explorer* Además de applets tambien se pueden cargar JavaBeansCapítulo 16: Etiquetas jsp: y JavaBeans.
  • 17. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -4- Uso de JavaBeans* Desde nuestro punto de vista, un JavaBean es una clase conlas siguientes características:• Posee un constructor sin parámetros• No posee campos públicos• Para conocer el valor de un campo llamado xxx debe disponer de una función getXxx (o isXxx si es de tipo boolean)• Para asignarle valor a un campo llamado xxx debe disponer de una función setXxx* La utilización de los JavaBeans permite encapsular diversasfuncionalidades aumentando la orientación a objetos del sistema* Para no «ensuciar» el código HTML de la página JSP, sesuministran varias etiquetas jsp: que permiten gestionar losJavaBeans de forma natural* Las etiquetas jsp: para gestionar JavaBeans son:• jsp:useBean. Crea un objeto (si no existe ya) de una clase que cumple ser un JavaBean y le da un nombre. A partir de este momento ese objeto se utilizará por su nombre• jsp:setProperty. Invoca un método setXxx de un JavaBean previamente creado• jsp:getProperty. Visualiza el resultado devuelto por un método getXxx de un JavaBean previamente creadoCapítulo 16: Etiquetas jsp: y JavaBeans.
  • 18. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -5- Sintaxis* Los atributos que admite jsp:useBean son:id=”nombre”. Nombre que se le da a ese objetoscope=”page|request|session|application”. Indica dónde sepuede usar dicho objeto: O page: sólo en esta página O request: si hay un forward o un include también se podrá usar en las páginas destino O session: se puede usar en la sesión de usuario a través de varias páginas, pero sólo para ese usuario O application: Existirá hasta que se cierre el servidor JSP. Disponible para todo el mundo siempre. Sclass=”Clase.class”. Nombre de la clase de la que se crea elobjeto Gtype=”Clase.class”. Por si se quiere hacer un upcasting R* Los atributos que admite jsp:getProperty son:name=”nombre”. Nombre del objeto del que tomar el campoproperty=”nombreCampo”. Nombre del campo cuyo valor sedesea visualizar* Los atributos que admite jsp:setProperty son:name=”nombre”. Nombre del objeto en que guardar el valorproperty=”NombreCampo”. Nombre del campo cuyo valor sedesea guardarvalue=”valor”. Valor que se desea guardar. Se hace unaconversión automática en función del tipo del campoCapítulo 16: Etiquetas jsp: y JavaBeans.
  • 19. Programación en Java. Forman, 2000. -6- Ejemplo de JSP y JavaBeansFichero StringBean.java/** Un JavaBean sencillito que sólo tiene un campo * llamado mensaje de tipo String */package jsp;public class StringBean { private String mensaje = "Ningún mensaje"; public String getMensaje() { return(mensaje); } public void setMensaje(String mensaje) { this.mensaje = mensaje; }}Fichero StringBean.jsp<HTML><HEAD><TITLE>Uso de JavaBeans con JSP</TITLE></HEAD><BODY> <TABLE BORDER=5 ALIGN="CENTER"> <TR><TH CLASS="TITLE">Uso de JavaBeans con JSP </TABLE> <jsp:useBean id="stringBean" class="jsp.StringBean" /> <OL> <LI>Valor inicial (getProperty): <I><jsp:getProperty name="stringBean" property="mensaje" /></I> <LI>Valor inicial (expresión JSP): <I><%= stringBean.getMensaje() %></I> <LI><jsp:setProperty name="stringBean" property="mensaje" value="El mejor lenguaje: Java" /> Valor después de haber cambiado el campo con setProperty: <I><jsp:getProperty name="stringBean" property="mensaje" /></I> <LI><% stringBean.setMensaje("Libertad, Igualdad y Fraternidad"); %> Valor después de haber cambiado el campo con un <i>scriptlet</i>: <I><%= stringBean.getMensaje() %></I> </OL></BODY></HTML>* El nombre dado al JavaBean puede usarse desde un scriptlet* El StringBean.class debe ir en el directorio WEB-INFclassesde la aplicación donde esté metida la página StringBean.jsp.Capítulo 16: Etiquetas jsp: y JavaBeans.
  • 20. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -7- Asignación de parámetros* Si una página recibe parámetros que hay que asignarlos acampos de un JavaBean, jsp:setProperty suministra una formade hacerlo de forma elegante. De esta guisa, los dos trozos decódigo siguientes son equivalentes:<% int numElementos = 1; try { numElementos = Integer.parseInt(request.getParameter(“num”)); } catch (NumberFormatException nfe) {}%><jsp:setProperty name=”articulo” property=”numero” value=”<%= numElementos %>”/>equivale a<jsp:setProperty S name=”articulo” property=”numero”/> G param=”num” R JSP, lo convierte al tipo del* El atributo param en lugar de value toma el valor de unparámetro de entrada a la páginacampo y guarda su valor en el campo.* Para asociar todos los parámetros de entrada con campos de unJavaBean basta con indicar un asterisco como property. Ej.:<jsp:setProperty name=”articulo” property=”*”/>* En éste último caso, los nombres de los parámetros y de loscampos del JavaBean han de ser idénticosCapítulo 16: Etiquetas jsp: y JavaBeans.
  • 21. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -8- EjemploFichero StringBean2.java/** Un JavaBean sencillito que sólo tiene un campo * mensaje de tipo String y un campo dato de tipo double */package jsp;public class StringBean2 { private String mensaje = "Ningún mensaje"; private double dato = 0.0; public String getMensaje() { return(mensaje); } public void setMensaje(String mensaje) { this.mensaje = mensaje; } public double getDato() { return(dato); } public void setDato(double dato) { this.dato = dato; }}Fichero StringBean2.jsp<HTML><HEAD><TITLE>Uso de JavaBeans con JSP</TITLE></HEAD><BODY> <jsp:useBean id="articulo" class="jsp.StringBean2" scope ="session" /> <% if (request.getParameter("mensaje") != null) { %> <jsp:setProperty name="articulo" property="*" /> <jsp:getProperty name="articulo" property="mensaje" /><br> <jsp:getProperty name="articulo" property="dato" /><br> <% } else {%> <FORM ACTION="StringBean2.jsp"> <INPUT TYPE="TEXT" NAME="mensaje" VALUE="Algo que contar"> <INPUT TYPE="TEXT" NAME="dato" VALUE="67.9"> <INPUT TYPE="SUBMIT"> </FORM> <% } %></BODY></HTML>* Como se dijo antes, con jsp:useBean se crea un objeto si ésteno existía ya. Si ya existía se usa el preexistente y ya está* Entre <jsp:useBean ...> y </jsp:useBean> se puede introducirun bloque JSP que sólo se ejecutará si el JavaBean se crea deverdadCapítulo 16: Etiquetas jsp: y JavaBeans.
  • 22. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -1- Capítulo 17:Biblioteca de etiquetas (Tags)* Permiten construir páginas JSP con una estructura másparecida a la del HTML.* Se utilizan etiquetas de la misma forma que en HTML.* Las etiquetas pueden tener parámetros y englobar un cuerpo.* Las etiquetas funcionalmente relacionadas se agrupan enficheros llamados bibliotecas de etiquetas. S de código Java ubicado en* Cada etiqueta se asocia a un bloquela clase cuyo nombre se indica.G R* Estas clases deben heredar y utilizar clases estándaresalmacenadas en el paquete java.servlet.jsp.tagext.** Cuando el motor JSP se encuentra una de estas etiquetas, lasustituye por su código asociado y lo ejecuta.* Por tanto, necesitamos tres ficheros:• La página JSP que utiliza las etiquetas: *.jsp• La clase que contiene el código a ejecutar: *.class• Un fichero que indica qué clase se corresponde con cada etiqueta: *.tld (Tag Library Descriptor)* En el código asociado podemos acceder al objetopageContext y, a través de él, a los objetos out, request,parameter, etc.Capítulo 17: JSP y bibliotecas de etiquetas.
  • 23. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -2- Primer ejemploFichero ExampleTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.io.*;/** Utilización de etiquetas con JSP. Ejemplo que saca un sencillo mensaje. * El nombre real de la etiqueta no se da aquí, sino en el fichero tld referenciado * en la página JSP a través de la directiva taglib */public class ExampleTag extends TagSupport { public int doStartTag() { try { JspWriter out = pageContext.getOut(); out.print("Custom tag example (ExampleTag)"); } catch(IOException ioe) { System.out.println("Error in ExampleTag: " + ioe); } return(SKIP_BODY); }}Fichero csajsp-taglib.tld<?xml version="1.0" encoding="ISO-8859-1" ?><!DOCTYPE taglib PUBLIC "-//Sun MicroSystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd"><taglib> <tlibversion>1.0</tlibversion> <jspversion>1.1</jspversion> <shortname>csajsp</shortname> <info>http://www.coreservlets.com/.</info> <tag> <name>example</name> <tagclass>ExampleTag</tagclass> <info>Simplest example: inserts one line of output</info> </tag></taglib>Fichero Ejemplo.jsp<HTML><HEAD><%@ taglib uri="/csajsp-taglib.tld" prefix="csajsp" %><TITLE><csajsp:example /></TITLE></HEAD><BODY><H1><csajsp:example /></H1><csajsp:example /></BODY></HTML>Capítulo 17: JSP y bibliotecas de etiquetas.
  • 24. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -3- La clase Tag* Las etiquetas se forman por un inicio, un cuerpo y un final.Cuando el sistema se encuentra el inicio ejecuta doStartTag(),y cuando encuentra el final ejecuta doEndTag().* Estas funciones deben reescribirse en una clase que hereda dela interfaz Tag. Sun suministra dos clases de partida que heredande Tag: O TagSupport, si la etiqueta no gestiona el cuerpo O BodyTagSupport, si se quiere tener un control completo del cuerpo* doStartTag() retorna un entero que puede ser: S SKIP_BODY. Ignora lo que haya entre el inicio de etiqueta y el final de etiqueta. Continúa con el resto de la página G EVAL_BODY_INCLUDE. Evalúa el cuerpo que haya entre el inicio de etiqueta y el final de etiqueta. Sólo TagSupport R EVAL_BODY_TAG. Igual que el anterior, pero con más control. Sólo BodyTagSupport* doEndTag() retorna un entero que puede ser: SKIP_PAGE. Ignora el resto de la página HTML EVAL_PAGE. Continúa normalmente la evaluación del resto de la página* Como en cualquier otra etiqueta HTML, las etiquetas puedentener atributos asociados. Si una etiqueta tiene asociado elatributo miAtributo, el sistema (antes de llamar a doStartTag())busca y llama automáticamente a una función llamadasetMiAtributo(String) y que deberemos definir en la claseasociada a la etiqueta.Capítulo 17: JSP y bibliotecas de etiquetas.
  • 25. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -4- Tag Library Descriptor* El fichero *.tld tiene estructura del fichero XML conforme alestándar http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd* La primera parte del fichero es común para todos ellos.* La etiqueta <taglib> engloba todas las etiquetas que vamos adefinir en este fichero. Contiene:<tlibversion> La versión de este tld<jspversion> La versión más pequeña con que funciona este tld<shortname> Prefijo que se debe usar cuando se referencien las etiquetas de este tld. (No obligatorio)<uri> URI donde se encuentra este tld<info> Descripción de este tld.<tag> Diferentes etiquetas definidas en este biblioteca. Contiene: <name> Nombre de la etiqueta <tagclass> Fichero .class asociado a la etiqueta <teiclass> Fichero .class opcional, subclase de TagExtraInfo <bodycontent> Puede contener tres valores: EMPTY Debe estar vacío JSP Posee cualquier cosa válida en una página .jsp TAGDEPENDENT El contenido será interpretado por el código del .class <info> Descripción opcional de esta etiqueta <attribute> Diferentes atributos que puede contener esta etiqueta. Contiene:Capítulo 17: JSP y bibliotecas de etiquetas.
  • 26. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -5- Tag Library Descriptor <attribute> Diferentes atributos que puede contener esta etiqueta. Contiene: <name> Nombre del atributo <required> Si el atributo es obligatorio o no <rtexprvalue> Indica si el valor del atributo debe ser constante, o si puede ser una expresión JSP que varíe de una ejecución a otra de la página* Los atributos son siempre de tipo String y es necesarioconvertirlos a su tipo correcto controlando posibles errores. Semplea la directiva taglib que* Para utilizar una biblioteca seposee como parámetros:uri G .tld que contiene la La dirección del fichero R traducción de las etiquetas. Dirección a partir del directorio ROOTprefix Prefijo que deben tener todas las etiquetas que procedan del uri anterior. Se utiliza para evitar conflictos de etiquetas procedentes de varios tld* La ubicación de un fichero .tld se puede indicar a través delfichero de configuración web.xml, de la forma: <taglib> <taglib-uri>/myPRlibrary</taglib-uri> <taglib-location>/WEB-INF/tlds/PRlibrary_1_4.tld</taglib-uri> </taglib>de forma que en el fichero JSP se puede invocar simplementecomo: <%@ taglib uri=”/myPRlibrary” prefix=”x” %>Capítulo 17: JSP y bibliotecas de etiquetas.
  • 27. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -6- Segundo ejemploFichero SimpleTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.io.*;import java.util.*;/** Utilización de etiquetas con JSP. Ejemplo que saca un número aleatorio * entre 0 y el parámetro que se le pasa. */public class SimpleTag extends TagSupport { protected long maximo = 100; public int doStartTag() { try { JspWriter out = pageContext.getOut(); out.print(new Random().nextLong() % maximo); } catch(IOException ioe) { System.out.println("Error in SimpleTag: " + ioe); } return(SKIP_BODY); } public void setMaximo(String maximo){ try{ this.maximo = new Long(maximo).longValue(); } catch(NumberFormatException nfe){ this.maximo=100; } }}Tag del fichero csajsp-taglib.tld <tag> <name>example3</name> <tagclass>jsp.SimpleTag</tagclass> <info>Saca un numero aleatorio por la salida</info> <attribute> <name>maximo</name> <required>false</required> </attribute> </tag>Ejemplo de uso <csajsp:example3 maximo="10000"/>Capítulo 17: JSP y bibliotecas de etiquetas.
  • 28. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -7- Etiquetas con cuerpo* El cuerpo se encuentra entre el inicio de etiqueta y el final deetiqueta: <prefijo:etiqueta>cuerpo</prefijo:etiqueta>* El cuerpo puede contener cualquier componente de los quehay en el resto de la páginaSi no se desea un control especial sobre el cuerpo de unaetiqueta, no es necesario heredar de BodyTagSupport, sino queen doStartTag() retornamos SKIP_BODY oEVAL_BODY_INCLUDE S como es posible retornar* En el siguiente ejemplo se observa Gcualquiera de sendas etiquetas en base a un condición dedepuración R* Podemos invocar a la página como: http://localhost:8080/jsp/EjemploDebug.jspo bien como: http://localhost:8080/jsp/EjemploDebug.jsp?debug=sisegún queramos que aparezca el cuerpo o no* Nótese como el cuerpo también puede contener elementos JSPCapítulo 17: JSP y bibliotecas de etiquetas.
  • 29. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -8- Tercer ejemplo. DepuraciónFichero DebugTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.io.*;import javax.servlet.*;/* Utilización de etiquetas con JSP. Ejemplo que evalúa el cuerpo o no * en función de un parámetro de formulario llamado debug. */public class DebugTag extends TagSupport { public int doStartTag() { ServletRequest request = pageContext.getRequest(); String debugFlag = request.getParameter("debug"); if ((debugFlag == null) || (debugFlag.equalsIgnoreCase("no"))) return SKIP_BODY; else return EVAL_BODY_INCLUDE; }}Fichero EjemploDebug.jsp<HTML><HEAD><TITLE>Using the Debug Tag</TITLE></HEAD><BODY><H1>Uso de la etiqueta depurar</H1><%@ taglib uri="/WEB-INF/tlds/csajsp-taglib.tld" prefix="csajsp" %>Comienzo de página. Bla, bla, bla. chiu, chiu, chiu.<P><csajsp:depurar><B>Debug:</B><UL> <LI>Fecha actual: <%= new java.util.Date().toLocaleString() %> <LI>Host remoto: <%= request.getRemoteHost() %> <LI>Id de Sesión: <%= session.getId() %></UL></csajsp:debug><P>Final de página. Bla, bla, bla. chiu, chiu, chiu.<P></BODY></HTML>Capítulo 17: JSP y bibliotecas de etiquetas.
  • 30. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -9- Manipulación del cuerpo* Si se hereda de BodyTagSupport se incorporan varios métodosnuevos:T doInitBody(). Se invoca automáticamente antes de la primeraevaluación dle cuerpoT doAfterBody(). Se invoca automáticamente después de cadaevaluación del cuerpo. Puede retornar: SKIP_BODY. Finaliza la ejecución del cuerpo EVAL_BODY_TAG. Reevalúa el cuerpo De esta forma el cuerpo se evalúa una y otra vez mientras SdoAfterBody() retorne EVAL_BODY_TAG GT getBodyContent(). Devuelve un objeto de tipo BodyContent R* Un objeto de tipo BodyContent representa el resultado dehaber evaluado el cuerpo de una etiqueta. Los cuerpos seevalúan y el resultado se mete en un BodyContent. Acontinuación, el BodyContent se suele volcar en out.BodyContent posee los siguientes métodos:• getString(). Devuelve una cadena que representa la evaluación del cuerpo• getReader(). Permite leer a través de un Reader el BodyContent• clearBody(). Resetea el contenido del BodyContent• getEnclosingWriter()• writeOut(Writer). Vuelca el contenido del BodyContent en el Writer especificadoCapítulo 17: JSP y bibliotecas de etiquetas.
  • 31. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -10- Ejemplo de bucleFichero RepeatTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.io.*;/* Etiqueta que repite el cuerpo un número de veces. */public class RepeatTag extends BodyTagSupport { private int reps; public void setReps(String repeats) { try { reps = Integer.parseInt(repeats); } catch(NumberFormatException nfe) { reps = 1; } } public int doAfterBody() { if (reps-- >= 1) { BodyContent body = getBodyContent(); try { JspWriter out = body.getEnclosingWriter(); out.println(body.getString()); body.clearBody(); // Borra para el ciclo siguiente } catch(IOException ioe) { System.out.println("Error en RepeatTag: " + ioe); } return(EVAL_BODY_TAG); } else { return(SKIP_BODY); } }}Tag del fichero csajsp-taglib.tld <tag> <name>repetir</name> <tagclass>jsp.RepeatTag</tagclass> <info>Ejecuta el cuerpo varias veces</info> <attribute> <name>reps</name> <required>false</required> <rtexprvalue>true</rtexprvalue> </attribute> </tag>Capítulo 17: JSP y bibliotecas de etiquetas.
  • 32. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -11- Ámbito de objetosFichero RepetirEjemplo.jsp<HTML><HEAD><TITLE>Algunos números aleatorios</TITLE></HEAD><BODY><H1>Algunos números aleatorios</H1>Cada número de la lista siguiente es un número aleatorio<%@ taglib uri="/WEB-INF/tlds/csajsp-taglib.tld" prefix="csajsp" %><OL><!-- Se repite N veces. Si reps es null se repite una sola vez. --><csajsp:repetir reps=<%= request.getParameter("repeats") %>> <LI><csajsp:example3 maximo="1000000" /></csajsp:repetir></OL></BODY></HTML> S* Como se observa en este yG anteriores ejemplos, el número Raleatorio que se obtiene es siempre el mismo, ya que por cadainvocación de una etiqueta se vuelve a crear un objeto de suclase asociada. Si un objeto se quiere reutilizar de unainvocación a otra en la misma página, se puede almacenar en elobjeto request con: request.setAttribute(“clave”, objeto)y se recupera con request.getAttribute(“clave”)* Ejemplo que soluciona el problema (SimpleTag.java) JspWriter out = pageContext.getOut(); ServletRequest request = pageContext.getRequest(); Random rnd = (Random) request.getAttribute("rnd"); if (rnd == null){ rnd = new Random(); request.setAttribute("rnd", rnd); out.println("Creando el Random()"); } out.print(rnd.nextLong() % maximo);Capítulo 17: JSP y bibliotecas de etiquetas.
  • 33. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -12- Etiquetas anidadas* Hay situaciones en las que se sabe que una etiqueta debeaparecer siempre dentro del cuerpo de alguna otra. La etiquetaexterior puede contener alguna información útil para las internas* Desde una etiqueta interna podemos acceder al objeto de laexterna mediante la función: Object findAncestorWithClass(Object, Class)* Los parámetros definen de quién se busca la etiqueta ancestro(normalmente this) y, por si el anidamiento es de varios niveles,que tipo de etiqueta ancestro es la que se busca (p.ej.EtiquetaExterna.class)Capítulo 17: JSP y bibliotecas de etiquetas.
  • 34. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -13- Bases de Datos* En este ejemplo completo se ilustra la utilización de una basede datos mediante el uso de etiquetas anidadas*El código JSP producido es muy similar al HTML con laventaja con respecto a la legibilidad que ello conlleva* Las etiquetas que se usan son: T queryBlock que toma como parámetros el nombre de la fuente de datos (en ODBC). Opcionalmente podría incluir el nombre de usuario y la clave T queryStatement que tiene como cuerpo el texto de una consulta SQL S T queryCreateRows que prepara la lectura del número de G tuplas que se indique desde un inicio a un final (ambos opcionales) R T queryDisplay que visualiza el contenido del campo que se indique* Ejemplo de uso:<html> <%@ taglib uri=”http://acme.com/taglibs/simpleDB.tld” prefix=”x” %> <x:queryBlock connData=”conData1”> <x:queryStatement> SELECT nombre, apellidos FROM Clientes </x:queryStatement> Los primeros diez clientes son: <table> <tr><th>ACCOUNT</th><th>BALANCE</th></tr> <x:queryCreateRows from=”1” to=”10”> <tr> <td><x:queryDisplay field=”nombre”/></td> <td><x:queryDisplay field=”apellidos”/></td> </tr> </x:queryCreateRows> </table> </x:queryBlock></html>Capítulo 17: JSP y bibliotecas de etiquetas.
  • 35. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -14- Etiquetas JavaFichero QueryBlockTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.sql.*;import java.io.*;class Util { public static void prueba(JspWriter out, String cadena){ try { out.print(cadena); }catch(IOException ioe){ ioe.printStackTrace(); } }}public class QueryBlockTag extends TagSupport{ protected Connection conexión; protected ResultSet resultado; private String connData = "prueba1"; JspWriter out ; public void setConnData(String connData){ this.connData = connData; } public int doStartTag(){ try{ out = pageContext.getOut(); Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); conexión = DriverManager.getConnection("jdbc:odbc:"+connData, "", ""); }catch(Exception e){ e.printStackTrace(); Util.prueba(out, "Error en la apertura de la base de datos"); return SKIP_BODY; } return EVAL_BODY_INCLUDE; } public int doEndTag(){ try{ conexión.close(); }catch(SQLException se){se.printStackTrace();} return EVAL_PAGE; }}Capítulo 17: JSP y bibliotecas de etiquetas.
  • 36. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -15- Etiquetas JavaFichero QueryStatementTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.sql.*;import java.io.*;public class QueryStatementTag extends BodyTagSupport{ public int doAfterBody(){ BodyContent body = getBodyContent(); try{ QueryBlockTag padre = (QueryBlockTag)findAncestorWithClass(this,QueryBlockTag.class); if (padre ==null) throw new SQLException("Padre es null"); Statement sentencia = padre.conexión.createStatement(); padre.resultado = sentencia.executeQuery(body.getString()); }catch(SQLException se){ } S Util.prueba(body.getEnclosingWriter(), "No se puede crear la sentencia."); return SKIP_BODY;} } G RFichero QueryDisplayTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.sql.*;import java.io.*;public class QueryDisplayTag extends TagSupport{ private String field; public int doStartTag(){ ResultSet resultado = ((QueryBlockTag)findAncestorWithClass(this,QueryBlockTag.class)).resultado; JspWriter out = pageContext.getOut(); try{ out.print(resultado.getString(field)); }catch(Exception ioe){ Util.prueba(out, "Imposible cargar el campo: "+ field); } return SKIP_BODY; } public void setField(String field){ this.field = field; }}Capítulo 17: JSP y bibliotecas de etiquetas.
  • 37. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -16- Etiquetas JavaFichero QueryCreateRowsTag.javapackage jsp;import javax.servlet.jsp.*;import javax.servlet.jsp.tagext.*;import java.sql.*;import java.io.*;public class QueryCreateRowsTag extends BodyTagSupport{ int from = 1, to = 1; ResultSet resultado; public void setFrom(String from){ this.from = Integer.parseInt(from);} public void setTo(String to){ this.to = Integer.parseInt(to); } public int doStartTag(){ re s u lt a d o = ((Q u e ryB lo c kT ag)f indAncest o rW it h Cla s s (t h is,QueryBlockTag.class)).resultado; int contador = 1; // Este bucle se posiciona en el registro anterior al que hay que mostrar try{ while ((contador < from) && resultado.next()) contador ++; }catch(SQLException se){ se.printStackTrace(); } try{ if(!resultado.next()) return SKIP_BODY; }catch(SQLException se){ Util.prueba(pageContext.getOut(), "No se puede mostrar el registro"); return SKIP_BODY; } return EVAL_BODY_TAG; } public int doAfterBody(){ BodyContent body = getBodyContent(); JspWriter out = body.getEnclosingWriter(); try{ out.print(body.getString()); body.clearBody(); }catch(IOException ioe){Util.prueba(out, "Imposible emitir registro"); } if (++from > to) return SKIP_BODY; else{ try{ if (!resultado.next()) return SKIP_BODY; }catch(SQLException sqle){ Util.prueba(out, "Error en los registros."); return SKIP_BODY; } return EVAL_BODY_TAG; } }}Capítulo 17: JSP y bibliotecas de etiquetas.
  • 38. Programación en Java. Cursos de verano, Acción Estudiantil, 2003. -17- Descriptor de etiquetasFichero bbdd-taglib.tld<?xml version="1.0" encoding="ISO-8859-1" ?><!DOCTYPE taglib PUBLIC "-//Sun MicroSystems, Inc.//DTD JSP Tag Library 1.1//EN" "http://java.sun.com/j2ee/dtds/web-jsptaglibrary_1_1.dtd"><taglib> <tlibversion>1.0</tlibversion> <jspversion>1.1</jspversion> <shortname>bbdd</shortname> <info>http://www.coreservlets.com/.</info> <tag> <name>queryBlock</name> <tagclass>jsp.QueryBlockTag</tagclass> <info>Comienzo de una consulta. Conexión</info> <attribute> <name>connData</name> <required>false</required> </attribute> S </tag> <tag> <name>queryStatement</name> <tagclass>jsp.QueryStatementTag</tagclass> </tag> <tag> G <info>Ejecuta una consulta que es su propio cuerpo</info> <name>queryCreateRows</name> R <tagclass>jsp.QueryCreateRowsTag</tagclass> <info>Se posiciona al comienzo de la tupla deseada</info> <attribute> <name>from</name> <required>false</required> </attribute> <attribute> <name>to</name> <required>false</required> </attribute> </tag> <tag> <name>queryDisplay</name> <tagclass>jsp.QueryDisplayTag</tagclass> <info>Visualiza el campo que se indica</info> <attribute> <name>field</name> <required>false</required> </attribute> </tag></taglib>Capítulo 17: JSP y bibliotecas de etiquetas.
  • 39. Programación en Java. Universidad de Málaga, 2006. -1- Capítulo 18: JSTL (Java Standard Tag Library)* El objetivo de JSTL (biblioteca de etiquetas estándar de Java)es facilitar el trabajo a los desarrolladores de JSP.* Desde un punto de vista general, JSTL proporciona lassiguientes capacidades: S O Acciones de propósito general mediante un lenguaje de expresiones, atributos con ámbito y captura de excepciones O Acciones de control de flujo dentro de una página JSP O Validaciones de bibliotecas de etiquetas que obligan a G que un proyecto cumpla con ciertas reglas de estilo* Desde el punto de vista de las bibliotecas concretas quesuministra, JSTL nos da las siguientes: R O Etiquetas de propósito general (gestión de variables) O Etiquetas de control de flujo y de iteración O Etiquetas asociadas a URLs O Etiquetas de internacionalización y formateo O Etiquetas para trabajar con bases de datos O Etiquetas para trabajar con XML O Etiquetas de manipulación de cadenas* Como se verá a lo largo de nuestro estudio, JSTL utilizaciertas convenciones que hacen más fácil al desarrollador elrecordar la estructura interna de las etiquetas.Capítulo 18: JSTL (Java Standard Tag Library).
  • 40. Programación en Java. Universidad de Málaga, 2006. -2- Lenguaje de expresiones* El lenguaje de expresiones (EL) sirve para facilitar la escriturade expresiones restringidas Java dentro de una página JSP.* Una expresión EL se escribe de la forma ${expresion}y entre las llaves puede usarse cualquier operador binario ounario que se quiera, ya sea matemático, de cadena, relacionalo lógico. Es muy útil el operador unario empty para saber sialgo es null o no.* Como operandos pueden usarse:• Variables con ámbito.• Literales numéricos, de cadena o lógicos.• Componentes Java Beans.• Colecciones.• Funciones definidas en un fichero .tld* La gran ventaja de las expresiones EL es que son evaluadaspor el propio motor JSP que las sustituye bajo demanda por elresultado de la evaluación. Por tanto, las expresiones puedenusarse en cualquier lugar de una página JSP:T Como sustituta de un literal HTMLT Como valor de un atributo de una etiqueta* Ejemplos:${10 mod 3} devuelve 1${1 > 3} devuelve false<c:set var=”numeroSS” value=”124578" />${numeroSS == 124578} devuelve trueCapítulo 18: JSTL (Java Standard Tag Library).
  • 41. Programación en Java. Universidad de Málaga, 2006. -3- Contenido de expresiones* Una expresión EL unifica el uso del punto y de los corchetes.De esta guisa, expr-a.ident-b es equivalente a expr-a[“ident-b”].* Para evaluar expr-a[expr-b] se evalúa expr-a a valor-a yexpr-b a valor-b, y en base a valor-a se hacen diferentesacciones:• Si es null el resultado es null.• Si es de tipo Map, se retorna valor-a.get(valor-b).•• S Si es de tipo List el resultado es valor-a.get((int)valor-b). Si es un array el resultado es Array(.get(valor-a, valor- b).• Si es un Java Bean se retorna la propiedad valor-b. G* Las siguientes variables pueden usarse directamente (todas sonlistas): R• param: lista con los nombres de los parámetros.• paramValues: lista con los valores de los parámetros.• header: lista con los campos de la cabecera.• headerValues: lista con los valores de los campos de la cabecera.• cookie: lista con los nombres de las cookies.• pageScope, requestScope, sessionScope y applicationScope: lista con las variables definidas en cada ámbito.* Ejemplo:<c:forEach item=”unaCookie” values=${cookie}”> ${unaCookie}<br></c:forEach>Capítulo 18: JSTL (Java Standard Tag Library).
  • 42. Programación en Java. Universidad de Málaga, 2006. -4- Core Tag Library* Esta biblioteca posee etiquetas de propósito general, entre lasque se incluyen las de manipulación de variables y gestión deerrores. El prefijo estándar para esta biblioteca es c. Para usarlahay que incluir en la página JSP:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>* Las etiquetas más importantes que posee son: O <c:out> utilizada con el mismo objetivo que el scriptlet <%= expresion %> tiene algunas funcionalidades adicionales O <c:set> permite asignar valores a variables (p.ej., de sesión) o a propiedades de Java Beans O <c:remove> es el complemento natural al anterior, y sirve para destruir variables con ámbito O <c:catch> permite recuperar un error, y supone el complemento perfecto para la página de error JSP O <c:if> emite por la salida el cuerpo que contiene sólo si la condición a que se refiere es cierta O <c:choose>, <c:when> y <c:otherwise> permiten formar una estructura de ifs en cascada con parte else O <c:forEach> permite recorrer una colección o un array, así como ejecutarse como un bucle FOR de BASIC O <c:forTokens> divide una cadena en trozos y se ejecuta para cada trozo* Las etiquetas de URL también forman parte de las core perolas veremos aparte por su complejidad.Capítulo 18: JSTL (Java Standard Tag Library).
  • 43. Programación en Java. Universidad de Málaga, 2006. -5- <c:out>* La sintaxis de esta etiqueta es:<c:out value=”valor” [escapeXml=”true|false”] [default=”valorSiEsNull”]/>* Emite por la salida el valor del atributo value. Si este es nulo,se saca por pantalla el valor del atributo default. S* Por defecto escapeXml está puesto a true, lo que quiere decirque se traducen algunos caracteres para evitar errores: Carácter Código de carácter < > & G &lt; &gt; &amp; ‘ “ R &#039; &#034;* El valor dado al atributo value se convierte en String y seemite, a no se que sea un objeto de tipo java.io.Reader, en cuyocaso lo que se emite es el resultado de leer por completo dichocanal de entrada.* Puede probarse como ejemplo con la página completa:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><c:out value="Trabajo en Gar & cía" />Capítulo 18: JSTL (Java Standard Tag Library).
  • 44. Programación en Java. Universidad de Málaga, 2006. -6- <c:out> y Reader* Sea el siguiente Bean:package org.apache.jsp;import java.io.*;public class StringBean { private String nombreFichero = "Ningun nombreFichero"; public String getNombreFichero() { return(nombreFichero); } public void setNombreFichero(String nombreFichero) { this.nombreFichero = nombreFichero; } public Reader getLector() throws IOException { return new FileReader(getNombreFichero()); } public void setLector(String lector) { this.nombreFichero = lector; }}* Y el JSP:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %> <jsp:useBean id="stringBean" class="org.apache.jsp.StringBean" /> <jsp:setProperty name="stringBean" property="lector" value="e:/prueba.txt"/> <c:out value="${stringBean.lector}"/><br> <c:out value="Otra cosa" /><br>* La salida de la línea marcada es el contenido del ficheroe:prueba.txt. De una sola tacada se ha emitido el contenido deun fichero entero.Capítulo 18: JSTL (Java Standard Tag Library).
  • 45. Programación en Java. Universidad de Málaga, 2006. -7- <c:set> y <c:remove>* La sintaxis de <c:set> es: O Para asignar valor a una variable con ámbito<c:set value=”valor” var=”nombreVar” [scope=”page|request|session|application”]/> O Para asignar una propiedad a un Java Bean, o un elementode un mapa<c:set value=”valor” target=”nombreVar”/> property=”nombrePropiedad” S O Para establecer un valor en diferido. Un valor diferidoquiere decir que se asigna una expresión que se evalúa de forma Gperezosa, o sea, no en este momento, sino cuando se utilice lavariable. Realmente esto sólo tiene utilidad cuando se trabajacon JSF (Java Server Faces) y no volveremos a tratar el tema.sintaxis de <c:remove> es:<c:remove var=”nombreVar” R* <c:remove> sólo tiene sentido para variables con ámbito. La [scope=”page|request|session|application”]/>* <c:set> hace asignaciones a variable con ámbito o apropiedades de Java Beans o a datos de Mapas. <c:remove>elimina variables con ámbito.* El subrayado quiere decir que sólo pueden especificarseliterales.Capítulo 18: JSTL (Java Standard Tag Library).
  • 46. Programación en Java. Universidad de Málaga, 2006. -8- <c:catch>* La sintaxis de <c:catch> es:<c:catch [var=”nombreVar”]> // Acciones que pueden producir excepciones</c:catch>* <c:catch> permite capturar excepciones dentro de bloquesJSP.* La idea es que los errores graves no sean capturados, sino quese propaguen hasta la página de error especificada. Los erroressecundarios son los que se deben capturar con <c:catch> paraque no interfieran con el desarrollo normal de la página.* Si se indica un nombre de variable, entonces la excepsión seguarda en ella. Si no se produce excepción, entonces esavariable se destruye con <c:remove> si es que existía. Portanto, lo que suele venir a continuación del <c:catch> es unaacción condicional que testa dicha variable para hacer la accióncorrectora que sea.* Sino se quiere incluir acción correctora, entonces inclusopuede omitirse el atributo var de <c:catch>.Capítulo 18: JSTL (Java Standard Tag Library).
  • 47. Programación en Java. Universidad de Málaga, 2006. -9- Ejemplo con core* En este ejemplo se ve el uso de <c:set> (no olvidar la directivataglib:<c:set var="aux" value="1" />${aux}<br><c:set var="aux" value="${aux + 1}" />${aux}<br><c:set var="cadena" value="mi nombre" />${cadena}<br><c:set var="cadena" value="${cadena} es Sergio" />${cadena}<br> S* Como puede verse, la concatenación de cadenas se hacemediante una mera yuxtaposición.<c:catch var="fallo"> Esto sale bien<br> <% G* En este ejemplo se ve el uso de <c:catch>: %> if (1==1) R throw new Exception("Fallo que se me ocurre"); Esto ya no sale<br></c:catch>${fallo}<br>Continua la cosa bien<br>* Si se quita la cláusula <c:catch> se produce un fallo en lapágina y no se carga nada.Capítulo 18: JSTL (Java Standard Tag Library).
  • 48. Programación en Java. Universidad de Málaga, 2006. -10- Etiquetas de control de flujo* A menudo una página debe devolver al cliente diferentestextos en función de los datos de entrada o almacenados en unabase de datos.* Estas etiquetas evitan el tener que recurrir a Java directamente,lo que suele ser propenso a errores debido al uso intensivo dellaves.* No tienen la misma potencia que las sentencias de control deflujo en Java, sino que simulan básicamente un if sin else y lasentencia if en cascada.* No existe nada parecido a un for, while o do while. Lasúnicas sentencias de bucle que hay son las que permiten recorrerestructuras y, por ello, están más asociadas al concepto deiterador que al de control de flujo. Por esto no las veremos eneste apartado, sino más adelante.Capítulo 18: JSTL (Java Standard Tag Library).
  • 49. Programación en Java. Universidad de Málaga, 2006. -11- <c:if>* La sintaxis de <c:if> es:<c:if test=”condicion” [var=”nombreVar” [scope=”page|request|session|application”]]> // Acciones que se ejecutan si la condicion se cumple</c:if>* Si la etiqueta <c:if> se autocierra y se indica un nombre de Svariable, entonces es como si se utilizara para cargar un valorbooleano en dicha variable.* Como puede verse, esta etiqueta carece de cláusula else. El Gmotivo es que la cláusula else, utilizada a discreción, seconvierte en unos ifs en cascada mutuamente excluyentes; ypara eso, la biblioteca core suministra otras etiquetas* Ej. de control:<c:if test="${ empty param.nombre}" > R Se le ha olvidado escribir un valor para el nombre.<br></c:if> Puede probarse a cargar una página que contenga estopsando o no pasando en la dirección URL el parámetro nombre.* Ejemplo de carga de valor booleano:<c:if var="existeNombre" test="${ empty param.nombre}" />${existeNombre}<br>Capítulo 18: JSTL (Java Standard Tag Library).
  • 50. Programación en Java. Universidad de Málaga, 2006. -12- <c:choose>, <c:when> y <c:otherwise>* Estas tres etiquetas se emplean conjuntamente según lasiguiente sintaxis<c:choose> <c:when test=”condicion1”> // Cuerpo que se emite si condicion1 es cierta </c:when> <c:when test=”condicion2”> // Cuerpo que se emite si condicion2 es cierta // y condicion1 es falsa </c:when> .... <c:otherwise> // Cuerpo que se emite si ninguna de las // condiciones anteriores es cierta </c:otherwise></c:choose>* La estructura de estas etiquetas es la intuitiva: una vez entradoen un <c:choose> se evalúan los <c:when> en secuencia; en elprimero en que la condición sea cierta, se emite su cuerpo y sesale del <c:choose>. Si todas las condiciones son falsas se emiteel cuerpo de <c:otherwise>.Capítulo 18: JSTL (Java Standard Tag Library).
  • 51. Programación en Java. Universidad de Málaga, 2006. -13- Ejemplo con <c:choose>* El siguiente ejemplo completo comprueba los parámetros deentrada a un formulario y emite diferentes salida en base a estos:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><h3>Saludos</h3><c:choose> <c:when test="${empty param.nombre}" > Necesito un nombre.<br> </c:when> <c:when test="${empty param.tiempo}" > Necesito un tiempo.<br> </c:when> <c:otherwise> ¡Hombre ${param.nombre}!.<br> S G ¡Cuánto tiempo sin verte!<br> Qué día más ${param.tiempo} hace.<br> </c:otherwise></c:choose> RCapítulo 18: JSTL (Java Standard Tag Library).
  • 52. Programación en Java. Universidad de Málaga, 2006. -14- Etiquetas para recorridos* Este tipo de etiquetas permite repetir la emisión de un trozoJSP en base al número de elementos de una colección, array,etc.* También se permite la iteración sobre mapas y sobreiteradores y enumeradores. Con estos últimos hay que tenercuidado ya que no se pueden resetear y no pueden recorrerse, asu vez, varias veces.* El recorrido puede ser sobre objetos o sobre tipos primitivos.en este último caso se hace una traducción automática al tipowrapper correspondiente.* La iteración también puede proporcionar un estado que puedeindicar, el número de componente por el que va el recorrido, etc.Para ello se utiliza la clase LoopTagStatus.* También es posible realizar recorridos un número determinadode veces, con variables límite de inicio, final y paso.* El desarrollador puede hacer uso de la clase LoopTag paraconstruir sus propias etiquetas que interaccionen con<c:forEach>Capítulo 18: JSTL (Java Standard Tag Library).
  • 53. Programación en Java. Universidad de Málaga, 2006. -15- <c:forEach>* La sintaxis es diferente según se recorra una estructura o seitere un determinado número de veces.* La sintaxis que recorre una estructura es:<c:forEach [var=”nombreVar”] items=”coleccion” [varStatus=”nombreVarEstado”] [begin=”comienzo”] [end=”final”]> [step=”paso”] // Cuerpo a repetir S</c:forEach> G* Para ejecutarse un determinado número de veces, la sintaxises:<c:forEach [var=”nombreVar”] begin=”comienzo” end=”final” R [varStatus=”nombreVarEstado”] [step=”paso”]> // Cuerpo a repetir</c:forEach>* Ejemplo que saca los números del 1 al 20:<c:forEach var="cont" begin="1" end="20"> ${cont}<br></c:forEach>Capítulo 18: JSTL (Java Standard Tag Library).
  • 54. Programación en Java. Universidad de Málaga, 2006. -16- <c:forEach>* La sintaxis de la ejecución un determinado número de vecesparece clara: la variable nombreVar parte del valor comienzohasta el valor final incrementándose en cada iteración por pasounidades.* Si el recorrido de una colección hace uso de begin y demás,quiere decir que se comienza en el ítem de la colección situadoen posición comienzo. Si hay menos ítems que comienzo,entonces el bucle ni se ejecuta. El primer elemento de lacolección está en la posición 0.* El <c:forEach> se usa para recorrer una colección de formaque cada elemento visitado es apuntado por nombreVar* Si la colección es un mapa, lo que se recorren son las entradas,que son del tipo Map.Entry.* Como colección también puede indicarse un array tradicionale incluso un String. En este último caso, se supone que elString posee palabras separadas por comas, y el <c:forEach>se ejecuta para cada una de tales palabras. La coma hace lasveces de carácter delimitador.* Ejemplo de recorrido de los elementos de la cabecera(header):<c:forEach var="elemento" items="${header}"> ${elemento}<br> -> ${elemento.value}<br></c:forEach>Capítulo 18: JSTL (Java Standard Tag Library).
  • 55. Programación en Java. Universidad de Málaga, 2006. -17- <c:forTokens>* El comportamiento de <c:forTokens> es muy parecido al de<c:forEach> cuando se recorre un String. En el caso de<c:forTokens> esposible indicar nuestros propiosdelimitadores.* La sintaxis de esta etiqueta es:<c:forTokens items=”cadenaDeTokens” delims=”delimitadores” [var=”nombreVar”] [begin=”comienzo”] [end=”final”] S [varStatus=”nombreVarEstado”] [step=”paso”]> // Cuerpo a repetir</c:forEach> G R* El funcionamiento de esto es como el de un StringTokenizerque tiene como argumentos la cadenaDeTokens y losdelimitadores.* Nótese la diferencia entre:<c:forEach var="elemento" items="uno, dos, tres, cuatro,"> ${elemento}<br></c:forEach>Adios.<br> y<c:forTokens var="elem" items="uno,dos,tres,cuatro," delims=",o" > ${elem}<br></c:forTokens>Adios.<br>Capítulo 18: JSTL (Java Standard Tag Library).
  • 56. Programación en Java. Universidad de Málaga, 2006. -18- Transferencia de variables* En el siguiente ejemplo se puede apreciar cómo intercambiarinformación entre un scriptlet y el entorno JSP.<% int[] miLista = new int[]{1, 3, 5, 7, 11, 13, 17, 19, 23, 29}; pageContext.getSession().putValue("miArray", miLista);%><c:forEach var="elemento" items="${miArray}" > ${elemento}<br></c:forEach>* Las variables Java también se pueden cambiar desde JSP. Enel siguiente ejemplo se le pasa un valor a JSP desde un scriptlet.Luego se cambia la variable en JSP y se recarga desde otroscriptlet:<h3>Saludos</h3><% int miNumero = 234544; pageContext.getSession().putValue("numero", miNumero);%>${numero}<br><c:set var="numero" value="16" scope="session" />${numero}<br><%= miNumero %><br><% miNumero = Integer.parseInt(pageContext.getSession(). getValue("numero").toString());%><%= miNumero %><br>Adios.<br>Capítulo 18: JSTL (Java Standard Tag Library).
  • 57. Programación en Java. Universidad de Málaga, 2006. -19- Etiquetas para URLs* Las diversas etiquetas suministradas permiten, entre otrascosas:• Asignar un nombre a una URL para usarla varias veces en la página JSP.• Asociar parámetros a una URL sin codificarlos en la dirección en sí.• Importar contenidos de cualquier URL de internet (y no sólo de recursos locales, como hace <jsp:include>).• Importar contenidos y meterlos en una variable String o• S Reader, en lugar de emitirlos directamente. Una URL puede ser absoluta, relativa, o relativa a un contexto diferente del de la página en que está.• Redirigir la carga de la página a la URL que se indique.* Las etiquetas disponibles son: G O <c:import> para disponer de contenidos de cualquier lugar de internet, ya sea in line o metiéndolos en una variable R O <c:url> permite hacer referencia a una URL y meterla en una variable. También permite indicar parámetros a la URL de forma fácil O <c:redirect> permite redirigir la carga de la página. O <c:param> permite pasar parámetros a una URL sin indicarlos directamente en la dirección.Capítulo 18: JSTL (Java Standard Tag Library).
  • 58. Programación en Java. Universidad de Málaga, 2006. -20- <c:url>* Permite construir una URL completa rescribiendo las partesque sean necesarias.* La sintaxis de esta etiqueta es:<c:url value=”dirección” [context=”contexto”] [var=”nombreVar”] [scope=”page|request|session|application”]> <c:param ...> <c:param ...></c:url>* La direccion puede ser absoluta o relativa. Si es relativa serescribe para hacerla absoluta. También puede ser relativa a uncontexto que no sea el de la página actual; en este caso elsistema se encarga de rescribirla convenientemente.* Si la direccion contiene caracteres raros, éstos no son rescritospor el sistema.* Por defecto, la URL resultante es emitida (a través delJspWriter actual); pero en lugar de esto puede almacenarse enuna variable especificada en el atributo var.* Pueden indicarse parámetros, que se añadirán a la URLconstruida mediante la correspondiente recodificación.Capítulo 18: JSTL (Java Standard Tag Library).
  • 59. Programación en Java. Universidad de Málaga, 2006. -21- <c:param>* Permite añadir parámetros de forma indirecta a una URL.* La sintaxis es:<c:param name=”nombreParam” value=”valorParam”/> o bien, si el valor del parámetro es muy complicado:<c:param name=”nombreParam” > valorParam</c:param> S* Aunque hacer uso de esta etiqueta puede considerarseredundante, ya que se puede escribir directamente en la URL, Ghay que reconocer que el código queda mucho más claro.Además, este método es consistente con el utilizado por<jsp:include>, que también puede contener <jsp:param>.* He aquí un ejemplo de uso:<h3>Saludos</h3><c:url R value="http://www.google.es/search" var="google"> <c:param name="hl" value="es" /> <c:param name="q" value="${param.consulta}" /></c:url><a href="${google}">${google}</a><br>Pincha <a href="${google}">aquí</a> para ir al mismo sitio.Capítulo 18: JSTL (Java Standard Tag Library).
  • 60. Programación en Java. Universidad de Málaga, 2006. -22- <c:import>* Esta etiqueta se va a la URL especificada y: o la mete en líneadonde se encuentra el <c:import>, o la mete en un objetoReader para que las acciones siguientes hagan lo que quierancon el contenido.* En el primer caso la sintaxis es:<c:import url=”direccion” [context=”contexto”] [var=”nombreVar”] [scope=”page|request|session|application”] [charEncoding=”codificacion”]> <c:param ...> <c:param ...></c:import>* Y en el segundo:<c:import url=”direccion” [context=”contexto”] varReader=”nombreVarReader” [charEncoding=”codificacion”]> // Cuerpo en el que consumir desde nombreVarReader</c:import>* Con la segunda sintaxis no se aceptan parámetros porque seconfundirían con el cuerpo que consume el canal de entrada: nose sabría cuándo acaban los parámetros y cuándo hay que abrirel canal.Capítulo 18: JSTL (Java Standard Tag Library).
  • 61. Programación en Java. Universidad de Málaga, 2006. -23- <c:redirect>* La sintaxis es:<c:redirect url=”direccion” [context=”contexto”]/>* También es posible indicar parámetros a esta URL, con lo quela etiqueta <c:import> quedaría abierta.* Esta etiqueta cancela el procesamiento de la página y redirigela carga hacia la URL indicada que:• S Puede ser absoluta, relativa o relativa a un contexto. El contexto, como en casos anterior, debe empezar por “/”.• Puede poseer parámetros de la forma <c:param>.* Ejemplo de uso:<h3>Saludos</h3> G<c:redirect url="StringBean.jsp" /> R* Como puede observarse, el <c:redirect> puede usarse inclusodespués de haber emitido ya algo.Capítulo 18: JSTL (Java Standard Tag Library).
  • 62. Programación en Java. Universidad de Málaga, 2006. -24- Ejemplo de <c:import>* El ejemplo que vimos de <c:out > y Reader se podría haberhecho como:<h3>Saludos</h3><c:import url="file:///e:/prueba.txt" />Adiós<br>* También el texto que se lee se puede meter en una variable deámbito y leerlo línea a línea:<h3>Saludos</h3><c:import url="file:///e:/prueba.txt" var="lector"/><c:forTokens var="elemento" items="${lector}" delims=<%="n"%>> ${elemento} --</c:forTokens><br>Adiós<br>* También puede hacerse con un Reader:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><%@page import="java.io.*" %><h3>Saludos</h3><c:import url="file:///e:/prueba.txt" varReader="lector" > <% BufferedReader in = new BufferedReader( (Reader)(pageContext.findAttribute("lector"))); String s; while((s = in.readLine()) != null) out.println(s+"<br>"); %></c:import>Adios.<br>Capítulo 18: JSTL (Java Standard Tag Library).
  • 63. Programación en Java. Universidad de Málaga, 2006. -25- SQL Tag Library* El prefijo estándar para esta biblioteca es sql. Para usarla hayque incluir en la página JSP:<%@ taglib uri="http://java.sun.com/jstl/sql" prefix="sql" %>* Esta biblioteca permite:T Ejecutar consultas con SELECT.T Acceder fácilmente a los resultados de una consulta.T Ejecutar actualizaciones con INSERT, UPDATE y DELETE.T Agrupar operaciones SQL en una transacción.T Cambiar rápidamente de base de datos. S* Las operaciones de esta biblioteca trabajan con objetos de tipoDataSource que retorna uno de tipo Connection. ElDataSource sirve para hacer referencia a una base de datos enconcreto. G* El DataSource con que trabajar puede especificarse de variasformas:• Directamente en el atributo dataSource de algunas etiquetas, de dos formas: • R dando directamente la información que necesita el DriverManager: url [, driver] [, usuario, contraseña]. Ej.: jdbc:pointbase:server://localhost:9092/sample, com.pointbase.jdbc.jdbcUniversalDriver,pbPublic,pbPublic • dando un valor de JNDI que será traducido por el motor JNDI a la información necesaria de acceso a la base de datos. Este método tiene la ventaja de que permite acceder a un pool de conexiones.• Como valor del atributo de configuración: javax.servlet.jsp.jstl.sql.dataSourceCapítulo 18: JSTL (Java Standard Tag Library).
  • 64. Programación en Java. Universidad de Málaga, 2006. -26- <sql:setDataSource>* Esta etiqueta permite especificar la fuente de datos de lasetiquetas sql que vendrán a continuación. No obstante, no esobligatorio especificarlo, puesto que la fuente de datos tambiénpuede indicarse como atributo de un inicio de transacción.* La sintaxis es:<sql:setDataSource var=”nombreVar” [scope=”page|request|session|application”] [ dataSource=”fuenteDeDatos” | url=”URL_JDBC” [driver=”claseJavaDelDriver”] [user=”nombreUsuario”] [password=”contraseña”] ]/>* El campo fuenteDeDatos, si se especifica, debe ser del tipojavax.sql.DataSource.Capítulo 18: JSTL (Java Standard Tag Library).
  • 65. Programación en Java. Universidad de Málaga, 2006. -27- <sql:transaction>* La sintaxis de esta etiqueta es:<sql:transaction [dataSource=”fuenteDeDatos”] [isolation=” read_uncommited | read_commited | repeatable_read | serializable “]> // Cuerpo HTML que puede hacer uso de // cuantas sentencias SQL se quiera</sql:transaction> S* La transacción ejecuta automáticamente el COMMIT o elROLLBACK. El ROLLBACK lo ejecuta si captura algunaexcepción en la ejecución del cuerpo, y el COMMIT en casocontrario.el anterior:• G* Cada tipo de aislamiento en la transacción es más potentes que read_uncommited: lo lee todo, hasta lo que todavía no se le ha hecho un COMMIT.• R read_uncommited: no hace lecturas sucias (datos a los que no se ha hecho un COMMIT; pero sí pueden suceder relecturas ambiguas: una transacción lee un registro, otra transacción modifica el registro, y la primera vuelve a leer el registro otra vez, ¡pero con un valor diferente!• repeatable_read: no hace relecturas ambiguas; pero sí pueden suceder lecturas fantasma: una transacción lee registros con WHERE, otra transacción mete un nuevo registro que satisface la condición, y la primera vuelve a leer los registros otra vez, ¡pero con un nuevo registro aparecido!• serializable: evita todos los problemas de inconsistencia.Capítulo 18: JSTL (Java Standard Tag Library).
  • 66. Programación en Java. Universidad de Málaga, 2006. -28- <sql:query>* La sintaxis de esta etiqueta es:<sql:query var=”nombreVar” [scope=”page|request|session|application”] [dataSource=”fuenteDeDatos”] [startRow=”numRegistroInicio”] [maxRows=”numMaxRegistrosDevueltos”]> // Sentencia SQL con el símbolo ? en el lugar // de cada parámetro <sql:param ...> <sql:param ...></sql:query>* Esta etiqueta permite ejecutar una sentencia selectparametrizada. Cada parámetro se identifica por un símbolo deinterrogación ?. Las posteriores etiquetas <sql:param>permiten sustituir cada uno de estos parámetros por un valorreal.* La sentencia SELECT se ejecuta contra el DataSourceespecificado en la etiqueta <sql:transaction> dentro de la quese incluye, o bien contra el especificado en su atributodataSource.* La variable indicada en el atributo var sirve para referenciarel resultado que devuelve la sentencia SELECT ejecutada yposee gran cantidad de campos.Capítulo 18: JSTL (Java Standard Tag Library).
  • 67. Programación en Java. Universidad de Málaga, 2006. -29- Lo que retorna <sql:query>* El objeto retornado en var por <sql:query> pertenece a lainterfaz:public interface Result { public String[] getColumnNames(); public int getRowCount() public Map[] getRows(); public Object[][] getRowsByIndex(); public boolean isLimitedByMaxRows();} S* El siguiente ejemplo muestra cómo procesar un SELECTsimple:<sql:transaction GdataSource="jdbc:pointbase:server://localhost:9092/sample,com.pointbase.jdbc.jdbcUniversalDriver,pbPublic,pbPublic" > <sql:query var="clientes"> SELECT name FROM customer_tbl R </sql:query> <c:forEach var="cliente" items="${clientes.rows}" > ${cliente.name}<br> </c:forEach></sql:transaction>----------<br>* Es posible procesar un SELECT genérico haciendo uso de loscomponentes de los métodos de la interfaz Result.Capítulo 18: JSTL (Java Standard Tag Library).
  • 68. Programación en Java. Universidad de Málaga, 2006. -30- Recursos de Tomcat* Para no tener que estar repitiendo constantemente en cadapágina los datos de una DataSource, es posible especificar enel fichero server.xml de Tomcat un recurso DataSource, darleun nombre, y luego usarlo en las etiquetas JSTL por su nombre.* De esta forma, cualquier modificación a la cadena de conexiónqueda centralizada en la declaración de este recurso enserver.xml.* Ejemplo:<Context docBase="patata5" path="/patata5" reloadable="true" debug="0"> <Resource name="jdbc/orcl" auth="Container" type="javax.sql.DataSource" maxActive="100" maxIdle="3" maxWait="10000" username="galvez" password="alfa00" driverClassName="oracle.jdbc.driver.OracleDriver" url="jdbc:oracle:thin:@localhost:1521:orcl"/></Context>que sólo será accesible a las páginas JSP del contexto%TOMCAT_HOME%webappspatata5* Una transacción hará uso de este recurso de la forma.<sql:transaction dataSource="jdbc/orcl" >Capítulo 18: JSTL (Java Standard Tag Library).
  • 69. Programación en Java. Universidad de Málaga, 2006. -31- Uso de la interfaz Result* El siguiente es un ejemplo completo de acceso genérico abases de datos:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %><h3>Consulta genérica</h3><sql:transactiondataSource="jdbc:pointbase:server://localhost:9092/sample,com.pointbase.jdbc.jdbcUniversalDriver,pbPublic,pbPublic" > <sql:query var="clientes"> select * from customer_tbl </sql:query> <table border="1"> <tr> S <c:forEach var="nombreCampo" G items="${clientes.columnNames}" > <th>${nombreCampo}</th> </c:forEach> </tr> <tr> R <c:forEach var="registro" items="${clientes.rowsByIndex}" > <c:forEach var="datoCampo" items="${registro}" > <td>${datoCampo}</td> </c:forEach> </tr> </c:forEach> </table></sql:transaction>----------<br>Capítulo 18: JSTL (Java Standard Tag Library).
  • 70. Programación en Java. Universidad de Málaga, 2006. -32- <sql:param> y <sql:dateParam>* Esta etiqueta sirve para pasar parámetros a sentencias SQLpreparadas. La sintaxis es:<sql:paramvalue=”valor” /> o bien<sql:param> // valor del parámetro</sql:param>* Esta etiqueta sirve para sustituir los símbolos ? que se hayanincluido en la sentencia SQL dentro de la cual se enmarca elpropio <sql:param>. Sirve para indicar parámetros de cualquiertipo excepto fecha, para lo cual se usa la etiqueta<sql:dateParam> cuya sintaxis es:<sql:dateParam value=”valorDeTipoDateDeJava” type=”timestamp | time | date”/>* Lo más normal es que los parámetros de entrada a una páginaJSP sean los que se utilicen para parametrizar una consulta SQL.Estos parámetros entrada deberían validarse antes de enviarlosa la consulta.Capítulo 18: JSTL (Java Standard Tag Library).
  • 71. Programación en Java. Universidad de Málaga, 2006. -33- Ejemplo de <sql:query>* El siguiente es un ejemplo de página completa:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %><h3>Consulta genérica</h3><c:choose> <c:when test="${empty param.limite || empty param.hora}"> <form action="index.jsp" method="GET"> Límite de crédito: <input size=10 name="limite" value="0" /><br> Hora a partir de la cual: <input size=8 name="hora" value="0:0" /><br> <input type=submit value="Buscar" /> S </form> </c:when> <c:otherwise> <% pageContext.setAttribute("horaDate", new java.util.Date("1/1/1 "+ request.getParameter("hora"))); %> <sql:transaction G dataSource="jdbc:pointbase:server://localhost:9092/sample, com.pointbase.jdbc.jdbcUniversalDriver,pbPublic,pbPublic"> <sql:query var="clientes"> SELECT name, credit_limit, last_sale_time FROM customer_tbl R WHERE credit_limit >= ? AND last_sale_time > ? <sql:param value="${param.limite}" /> <sql:dateParam value="${horaDate}" type="time" /> </sql:query> <table border="1"> <c:forEach var="cliente" items="${clientes.rows}" > <tr> <td>${cliente.name}</td> <td>${cliente.credit_limit}</td> <td>${cliente.last_sale_time}</td> </tr> </c:forEach> </table> </sql:transaction> </c:otherwise></c:choose>Capítulo 18: JSTL (Java Standard Tag Library).
  • 72. Programación en Java. Universidad de Málaga, 2006. -34- <sql:update>* Esta etiqueta permite ejecutar cualquier sentencia SQL que nosea un SELECT. La sintaxis es:<sql:update [var=”nombreVar”] [scope=”page|request|session|application”] [dataSource=”fuenteDeDatos”]> // Sentencia SQL de DDL o DML con el símbolo ? // en el lugar de cada parámetro <sql:param ...> <sql:param ...></sql:update>* La variable var hace referencia al número de elementosafectados por la sentencia. Es de especial utilidad en sentenciasUPDATE y DELETE.* Con esta etiqueta también pueden crearse tablas, borrarlas,cambiarlas, crear restricciones, etc.* Ejecutar <sql:update sql=”rollback” /> o <sql:updatesql=”commit” /> no está permitido y puede producir resultadosimpredecibles.Capítulo 18: JSTL (Java Standard Tag Library).
  • 73. Programación en Java. Universidad de Málaga, 2006. -35- Ejemplo de <sql:update>* El siguiente ejemplo crea una tabla, la rellena, la visualiza yla borra:<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %><%@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %><h3>Procesamiento</h3><sql:transactiondataSource="jdbc:pointbase:server://localhost:9092/sample,com.pointbase.jdbc.jdbcUniversalDriver,pbPublic,pbPublic" > <sql:update> CREATE TABLE a (campo1 NUMBER) </sql:update> S <c:forEach var="contador" begin="1" end="20" step="3" > <sql:update> G INSERT INTO a VALUES (?) <sql:param value="${contador}" /> </sql:update> </c:forEach> <sql:query var="registros" > SELECT campo1 FROM a </sql:query> R <c:forEach var="registro" items="${registros.rows}"> ${registro.campo1}<br> </c:forEach> <sql:update> DROP TABLE a </sql:update></sql:transaction>----------<br>Capítulo 18: JSTL (Java Standard Tag Library).
  • 74. Programación en Java. Universidad de Málaga, 2006. -36- I18n Formatting Tag Library* Esta biblioteca posee etiquetas que permiten formatear unapágina en base a un idioma seleccionado posibilitando que sealeída por personas de todo el mundo. El prefijo estándar paraesta biblioteca es fmt. Para usarla hay que incluir en la páginaJSP:<%@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>* Hace uso de los conceptos de internacionalización que ya sehan estudiado en capítulos anteriores. Algunas etiquetasinteresantes son: O <fmt:setLocale> especifica el Locale actual. O <fmt:bundle> especifica el nombre base de los ficheros de recursos. O <fmt:message> emite el mensaje de código especificado en el idioma del Locale actual. El mensaje lo busca en el fichero de recursos del bundle actual. Se le pueden pasar parámetros. O <fmt:requestEncoding> sirve para trabajar con parámetros que proceden de un código diferente al ISO- 8859-1.* Nosotros nos vamos a centrar principalmente en las etiquetasde formateo. <fmt:timeZone> y <fmt:setTimeZone> no lasveremos.Capítulo 18: JSTL (Java Standard Tag Library).
  • 75. Programación en Java. Universidad de Málaga, 2006. -37- <fmt:formatNumber> y <fmt:parseNumber>* Estas etiquetas permiten emitir un número que siga el formatoque se le indice, así como traducir un texto a un númerosiguiendo un patrón concreto de análisis. Las sintaxis son:<fmt:formatNumber value=”valorNumérico” [var=”nombreVar”] [scope=”page|request|session|application”] [pattern=”patronPersonalizado”] [currencyCode=”codigoDeMoneda”] S [type=”number | currency | percent “] [currencySymbol=”simboloDeMoneda”] [groupingUsed=”true | false “] G [maxIntegerDigits=”maximoNumeroDeDigitos”] [minIntegerDigits=”minimoNumeroDeDigitos”] [maxFractionDigits=”maximoNumeroDeDecimales”]/>y R [minFractionDigits=”minimoNumeroDeDecimales”]<fmt:parseNumber value=”valorNuméricoEnUnaCadena” [var=”nombreVar”] [scope=”page|request|session|application”] [type=”number | currency | percent “] [pattern=”patronPersonalizado”] [parseLocale=”LocaleDelParser“] [integerOnly=”true | false”]/>Capítulo 18: JSTL (Java Standard Tag Library).
  • 76. Programación en Java. Universidad de Málaga, 2006. -38- <fmt:formatNumber> y <fmt:parseNumber>* El patrón de formateo debe seguir las reglas de la clasejava.text.DecimalFormat.* El atributo groupingUsed permite decir si se va ausar algúncarácter de agrupación. Ver java.text.NumberFormat.setGroupingUsed() para más información.* El atributo parseLocale sirve para decir el Locale en base alcual hay que hacer el análisis del número almacenado en lacadena de entrada.* El atributo integerOnly especifica que sólo debe reconocersela parte entera del número guardado en la cadena.* Por ejemplo, el formateo :<fmt:formatNumber value="${100000000 / 3}" type="currency" currencySymbol="€" groupingUsed="true" maxIntegerDigits="4" maxFractionDigits="2" minFractionDigits="2"/>produce: €3.333,33así que cuidado con maxIntegerDigits, ya que el resultadodebiera haber sido: €33.333.333,33Capítulo 18: JSTL (Java Standard Tag Library).
  • 77. Programación en Java. Universidad de Málaga, 2006. -39- <fmt:formatDate> y <fmt:parseDate>* Estas etiquetas permiten trabajar con fechas. Las sintaxis son:<fmt:formatDate value=”valorDeFecha” [var=”nombreVar”] [scope=”page|request|session|application”] [type=”date | time | both“] [pattern=”patronPersonalizado”] S [dateStyle=”default | long | medium | short | full”] [timeStyle=”default | long | medium | short | full”] [timeZone=”zonaTemporal”]/>y<fmt:parseDate value=”valorFechaEnUnaCadena” G [var=”nombreVar”] [type=”date | time | both“] [pattern=”patronPersonalizado”] R [scope=”page|request|session|application”] [dateStyle=”default | long | medium | short | full”] [timeStyle=”default | long | medium | short | full”] [timeZone=”zonaTemporal”] [parseLocale=”LocaleDelParser“]/>* dateStyle y timeStyle siguien el formateo dejava.text.DateFormat.Capítulo 18: JSTL (Java Standard Tag Library).
  • 78. Programación en Java. Universidad de Málaga, 2006. -40- <fmt:formatDate> y <fmt:parseDate>* Algunos ejemplos de funcionamiento son:<jsp:useBean id="ahora" class="java.util.Date" /><fmt:formatDate value="${ahora}" /><br><fmt:formatDate value="${ahora}" type="both" /><br><fmt:formatDate value="${ahora}" type="time" /><br><fmt:formatDate value="${ahora}" type="time" timeStyle="short" /><br><fmt:formatDate value="${ahora}" pattern="dd/MM/yyyy" /><br>cuya salida es: 30-ene-2006 30-ene-2006 20:46:56 20:46:56 20:46 30/01/2006Capítulo 18: JSTL (Java Standard Tag Library).
  • 79. Programación en Java. Universidad de Málaga, 2006. -41- I18n Formatting Tag Library* El lenguaje de expresiones define el concepto de “funciones”para permitir a los desarrolladores crear sus propias extensionesa este lenguaje. El prefijo estándar para esta biblioteca es fn.Para usarla hay que incluir en la página JSP:<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>* Esto no son etiquetas realmente, sino funciones con prefijoque pueden usarse en el interior de una expresión del lenguajede expresiones.* Las funciones son las siguientes: S• De búsqueda en cadenas: G Ofn:contains(string, substring) devuelve boolean Ofn:containsIgnoreCase(string, substring) devuelve boolean Ofn:endsWith(string, sufijo) devuelve boolean R Ofn:startsWith(string, prefijo) devuelve boolean Ofn:indexOf(string, substring) devuelve int. La primera posición de string es la 0. Si no está se devuelve -1.• De obtención de subcadenas: Ofn:substring(string, beginIndex, endIndex) devuelve String. Las posiciones comienzan a partir de la 0. El carácter en beginIndex se incluye y el de enIndex se excluye. Ofn:substringAfter(string, substring) devuelve String Ofn:substringBefore(string, substring) devuelve StringCapítulo 18: JSTL (Java Standard Tag Library).
  • 80. Programación en Java. Universidad de Málaga, 2006. -42- Funciones (cont.)• Traducción de cadenas: Ofn:replace(inputString, beforeSubstring, afterSubstring) devuelve String Ofn:toLowerCase(string) devuelve String Ofn:toUpperCase(string) devuelve String Ofn:trim(string) devuelve String. Elimina los espacios a ambos extremos de la cadena.• Gestión de arrays y cadenas: Ofn:join(array, separador) devuelve String. Convierte un array en una cadena. Cada dos elementos están separados por la cadena separador. Ofn:split(string, delimitadores) devuelve String[]. Trocea una cadena en un array de cadenas. Los trozos estaban originalmente separados por cualquier carácter de los que aparece en delimitadores. Ofn:length(input) devuelve integer. La entrada puede ser una cadena o un array o una colección y devuelve su longitud o el número de elementos respectivamente.• Otras: Ofn:escapeXml(string) devuelve String. Véase el atributo escapeXml de <c:out>.Capítulo 18: JSTL (Java Standard Tag Library).
  • 81. Programación en Java. Universidad de Málaga, 2006. -43- Ejemplos de funciones* Algunos ejemplos son:<%-- Trunca el nombre a 30 caracteres y lo visualiza enmayúsculas --%> ${fn:toUpperCase(fn:substring(nombre, 0, 30))}<%-- Visualiza el texto que precede al primer asterisco --%> ${fn:substringBefore(texto, ’*’)}<%-- La variable custId puede tener espacios en blanco en losextremos. Esto los quita --%> <c:url var="myUrl" value="${base}/cust"> </c:url> S <c:param nombre="custId" value="${fn:trim(custId)}"/><%-- Visualiza el texto entre paréntesis --%> ${fn:substring(text, fn:indexOf(texto, ’(’)+1,fn:indexOf(texto, ’)’))} G<%-- Visualiza el nombre si contiene la cadena a buscar --%> <c:if test="${fn:containsIgnoreCase(nombre, searchString)}"> Encontrado en el nombre: ${nombre} </c:if><%-- Visualiza los últimos 10 caracteres --%> R ${fn:substring(text, fn:length(texto)-10)}<%-- Visualiza un valor con “bolillas” en vez de guiones --%> ${fn:replace(texto, ’-’, ’&#149;’)}Capítulo 18: JSTL (Java Standard Tag Library).
  • 82. Programación en Java. Universidad de Málaga, 2006. -44- XML Tag Library* Esta biblioteca posee etiquetas que permiten analizar, procesary buscar información dentro de un documento XML. El prefijoestándar para esta biblioteca es x. Para usarla hay que incluir enla página JSP:<%@ taglib uri="http://java.sun.com/jsp/jstl/xml" prefix="xml" %>* No entraremos en detalle en sus etiquetas. Baste decir que son: O <x:parse> que analiza un documento XML y puede devolver un org.w3c.dom.Document. O <x:out> que evalúa una expresión Xpath y emite el resultado. O <x:set> igual al anterior pero guarda el resultado en una variable. O <x:if>, <x:choose>, <x:when>, <x:otherwise> y <x:forEach> para recorrer contenidos basados en expresiones Xpath. O <x:transform> y <x:param> para aplicar hojas XSLT a un documento XML.Capítulo 18: JSTL (Java Standard Tag Library).