Curso Jsp

JAVASERVER PAGES Módulo: J2EE Tema: JavaServer Pages ( JSP )

Introducción Módulo: J2EE Tema: JavaServer Pages ( JSP ) JavaServer Pages, JSP combina HTML con fragmentos de Java para producir páginas web dinámicas. El fichero que contiene la página HTML tiene la extensión .jsp, y se almacena en el mismo sitio que una página web normal. Cuando un cliente pide una página JSP del sitio web y no se ha ejecutado antes, la página es pasada al motos de JSP, el cual complila la página convirtiendola en un servlet, la ejecuta y devuelve el contenido de los resultados al cliente. ¿Cuál es el funcionamiento básico? Muy sencillo: 1) El cliente solicita una página .jsp 2) La solicitud llega al servidor 3) El servidor «ejecuta» la página .jsp y obtiene un texto en formato html 4) El servidor envía el texto html al cliente 5) El navegador del cliente visualiza el texto html como si realmente hubiera estado almacenado en el servidor.

Funcionamiento Módulo: J2EE Tema: JavaServer Pages ( JSP )

Ventajas de JSP Módulo: J2EE Tema: JavaServer Pages ( JSP ) JSP no nos da nada que no pudierámos en principio hacer con un servlet. Pero es mucho más conveniente escribir HTML normal que tener que hacer un billón de sentencias println que generen HTML. Además, separando el formato del contenido podemos poner diferentes personas en diferentes tareas.

Comentarios iniciales Módulo: J2EE Tema: JavaServer Pages ( JSP ) Un fichero JSP empieza con un comentario del lado del serviros: <%-- - Author (s) : - Date : - Copyright Notice : - @(#) - Description : --%> Este comentario sólo es visible en el lado del servidor porque se elimina durante la traducción JSP. Dentro de este comentario están los autores, la fecha, la nota de copyright de la revisión, un identificador y una descripción sobre el JSP para los desarrolladores web.

Directiva(s) JSP Page ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Una directiva page, defina atributos asociados con la página JSP en tiempo de traducción. La especificación JSP no impone ninguna obligaciñon sobre cuántas directivas page se pueden definir en la misma página. Por eso los fragmentos de código que veremos a continuación son equivalentes: <%@ page session = ”true” %> <%@ page import = ”java.util.*” %> <%@ page errorPage = ”/pages/errorPage.jsp” %> Si la longitod de cualquier directivam excede de la anchura normal de una página JSP ( 80 caracteres), se debe dividor en varias lineas: <%@ page session = ”true” import = ”java.util.*” errorPage = ”/pages/errorPage.jsp” %>

Directiva(s) JSP Page ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Tal y como podemos ver, la directiva page posee variso atributos: languaje = ”java” extends = ”package.class” import = ”package.*”,”package.class” session = “true \ false” isThreadSafe = “true \ false” info = “text” errorPage = “pagina_error” isErrorPage = “true \ false”

Directiva(s) JSP Include Módulo: J2EE Tema: JavaServer Pages ( JSP ) Esta directiva nos permite incluir ficheros en el momento en que la página JSP es traducida a un servlet. La directiva se parece a esto: <%@ include file="url relativa" %>

Directiva(s) Tag Library Módulo: J2EE Tema: JavaServer Pages ( JSP ) Una directiva taglib declara las librerías de etiquetas usadas por el JSP. Una directiva corta se declara en una sola línea. Si tenemos varias directivas taglib se deben almacenar juntas en la misma localización dentro del cuerpo JSP: <%@ taglib uri=”URI1” prefix=”tagprefix1” %> <%@ taglib uri=”URI2” prefix=”tagprefix2” %> Al igual que la directiva page, si la longitud de una directiva taglib excede la anchura de 80 caracteres, debemos dividirla en varias líneas: <%@ taglib uri=”URI1” prefix=”tagprefix1” %> Solo deberíamos importar librerías de etiquetas que realmente se van a utilizar en la página JSP.

<%! private int cont; %> <%! private Date today; %> <%! public int getCont() { return cont; } %> ... <%! private int cont; private Date today; public int getCont() { return cont; } %> Declaraciones JSP Módulo: J2EE Tema: JavaServer Pages ( JSP ) Las declaraciones JSP declaran métodos y variable pertenecientes a la JSP. Estos métodos y variables no se diferencian de los declarados en el lenguaje Java, y por lo tanto se deberían seguir las convenciones de codificación más importantes.

Script de JSP Módulo: J2EE Tema: JavaServer Pages ( JSP ) Los script son bloques de código Java residentes entre los tags <% %>. Los elementos de script permiten insertar código Java dentro del método _jspService() del servlet que se generará desde la página JSP. Hay dos tipos: Expresiones: <%= expresion %> Scriptles: <% código %>

Variables predefinidas Módulo: J2EE Tema: JavaServer Pages ( JSP ) JSP incorpora ocho variables ya definidas, llamadas también objetos implicitos. request . response session out application config pageContext . page La mayoría de estas variables de referencia se han visto y utilizado con servlets y sus funciones y operativa son idénticas.

Comentarios Módulo: J2EE Tema: JavaServer Pages ( JSP ) Los comentarios se utilizan para descubrir información adicional o los propósitos del código cercano. Los comentarios JSP( tambien conocidos del lado del servidor) sólo son visibles en el lado del servidor (es decir, no se propagan al lado del cliente ). Se prefieres los comentarios puros JSP sobre los comentarios JSP con comentarios de scripts, ya que los primeros son menos dependientes del lenguaje de script subyacente. <%-- Comentario de JSP --%>

Ejemplo de JSP ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) <! DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" > <%@ page language = "java" contentType = "text/html; charset=ISO-8859-1" pageEncoding = "ISO-8859-1" %> <%@ page import = "java.util.*" %> <%! String ip = null ; // IP del cliente String host = null ; // Host del cliente Enumeration e = null ; String value = null ; String name = null ; %> < html > < head > < meta http-equiv = "Content-Type" content = "text/html; charset=ISO-8859-1" > < title > Ejemplo 1 </ title > </ head >

Ejemplo de JSP ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) < body > <% ip = request.getRemoteAddr(); host = request.getRemoteHost(); %> < div >< b > Informaci ó n del cliente </ b ></ div > < div > ip del cliente : <%= ip %> < div > < div > host del cliente : <%= host %> < div > < hr /> < div >< b > Cabeceras </ b >< div > <% e = request.getHeaderNames(); while (e.hasMoreElements()) { name = (String)e.nextElement(); value = request.getHeader(name); out.println( "<div>" + name + " = " + value + "</div>" ); } %> </ body > </ html >

Ejercicios Módulo: J2EE Tema: JavaServer Pages ( JSP ) Ejercicio 1: Realizar una gestión de usuarios, de tal forma que podamos listar, añadir usuarios, modificar usuarios y eliminar usuarios. Dichos usuarios se almacenarán en una tabla de una base de datos que tendrá los siguientes campos: pk_id - int nombre - varchar( 80 ) departamento – varchar( 80 ) email – varchar ( 80 ) Para acceder a la zona de administración debemos de validarnos en un formulario. Los datos de acceso los recibirá un servlet como parámetros iniciales por medio del fichero web.xml. Tendremos que crear un usuarioVO, un usuarioDAO y los servlets que consideremos oportunos.

Acciones Módulo: J2EE Tema: JavaServer Pages ( JSP ) Las acciones JSP usan construcciones de síntaxis XML para controlar el comportamiento del motor de Servlets. Podemos insertar un fichero dinámicamente, reutilizar componentes JavaBeans, reenviar al usuario a otra página, etc.: Recuerda que, como en XML, los nombre de elementos y atributos son sensibles a las mayúsculas. A continuación veremos las siguientes acciones: jsp:include jsp:forward jsp:useBean jsp:getProperty jsp:setProperty

Acción jsp:include Módulo: J2EE Tema: JavaServer Pages ( JSP ) Esta acción nos permite insertar ficheros en una página que está siendo generada. La síntaxis se parece a esto: <jsp:include page="relative URL" flush="true" /> Al contrario que la directiva include, que inserta el fichero en el momento de la conversión de la página JSP a un Servlet, esta acción inserta el fichero en el momento en que la página es solicitada. Con el cuerpo opcional jsp:param es posible enviar campos al formulario destino. <jsp:include page="pagina.jsp" flush="true"> <jsp:param name="id" value="valor"/> </jsp:include>

Acción jsp:forward Módulo: J2EE Tema: JavaServer Pages ( JSP ) Esta acción nos permite reenviar la petición a otra página. Tiene un sólo atributo, page, que debería consistir en una URL relativa. Este podría ser un valor estático, o podría ser calculado en el momento de la petición: <jsp:forward page=”pagina.jsp” /> <jsp:forward page=”<%= una expresión de java %>” /> También permite incorporar parámetros en la petición de la nueva página: <jsp:forward page=”pagina.jsp” > <jsp:param name=”login” value=”alumno” /> </jsp:forward> El significado de ejemplo anterior sería equivalente a : pagina.jsp?login=alumno

Beans ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Un JavaBean no es más que una clase java que se adapta a los siguientes criterios: Clase pública Una clase bean debe contar, al menos, con un constructor sin argumentos. No debe tener variables de instancia públicas. No debe permitir el acceso directo a las variables de instancia. Se accede a los valores de las variable a través de métodos denominados getXXX y setXXX. Un método que devuelve un tipo booleano debe denominarse is en lugar de get.

Beans ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Cuando se dice que un bean tiene una propiedad “nombre”, realmente se quiere decir que la clase tiene un método getNombre que devuelve un tipo X, y otro método llamado setNombre que toma X como argumentod e entrada. Los beans se utilizan principalmente para intercambiar información entre las distintas páginas que componen la aplicación, pudiendo sustituir perfectamente a las variables de sesión. Para no «ensuciar» el código HTML de la página JSP, se suministran varias etiquetas jsp: que permiten gestionar los JavaBeans de forma natural

Beans ( 3 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) 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 creado

jsp:useBeans ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Esta acción permite cargar y utilizar un JavaBean en la página JSP. La sintaxis más simple para especifica que se usa un Bean es: <jsp:useBean id=”name” class="package.class" /> Se puede interpretar como: generar una instancia de la clase especificada y asociarla a la variable definida en id. Es decir: <jsp:useBean id=”discos” class="DiscoTienda" /> Debe entenderse como: <% DiscoTienda discos = new DiscosTienda(); %>

jsp:useBeans ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Los atributos que admite jsp:useBean son: id=”nombre” . Nombre que se le da a ese objeto Scope= Indica dónde se puede usar dicho objeto: page : Valor por defecto. Sólo está disponible para la página actual. request : Indica que el bean sólo está disponible para la petición actual. s ession : Indica que está disponible para todas las páginas durante el tiempo de vida de la sesión actual. application : Existirá hasta que se cierre el servidor JSP. Disponible para todo el mundo siempre. class=”Clase.class” . Nombre completo del bean. La importancia del ámbito radica en que sólo se generará una instancia si no existe un bean con el mismo id y scope.:

jsp:setProperty( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Se usa jsp:setProperty para establecer los valores de la propiedad de los beans. Se puede utilizar en dos contextos diferentes. jsp:useBeans debe escribirse en el código antes de utilizar jsp:setProperty. Primero, se puede usar fuera de un elemento jsp:useBean: <jsp:useBeans id=”discos” class=”DiscosTienda” /> <jsp:setProperty name=”discos” Property=”titulo” value =”Disco 1” / > Sería equivalente a: <% discos.setTitulo( “Disco 1” ) %> La segunda forma de usar jsp:setProperty es dentro del cuerpo de un elemento jsp:useBean: <jsp:useBeans id=”discos” class=”DiscosTienda” > <jsp:setProperty name=”discos” Property=”titulo” value =”Disco 1” / > </jsp:useBeans>

jsp:setProperty( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) jsp:setProperty tiene cuatro posibles atributos: name : Atributo necesario. Designa el bean cuya propiedad va a ser seleccionada. property : Atributo necesario. Indica la propiedad a la que se accede. value : Atributo opcional. Especifica el valor para la propiedad. param : Atributo opcional. Indica el parámetro de la petición del que se debería derivar la propiedad, es decir, el nombre del campo del formulatio que llega al servidor. En el caso de utilizar param se debe tener en cuenta que si con la petición no llega dicho parámetro, no se hará nada. No se puede usar value y param juntos. Si en la propiedad property se pone un “ * ” se quiere decir que automáticamente asigne el valor a las propiedades del bean a través de los datos aportados por los parámetros de la petición de página cuando el nombre corresponda con la propiedad. En este caso se omite tanto value como param.

jsp:getProperty Módulo: J2EE Tema: JavaServer Pages ( JSP ) Recupera el valor de una propiedad del bean, lo convierte a un string, y escribe el valor en la salida out. Los atributos necesarios son: name: Nombre del id del bean referenciado previamente con jsp:useBean. property: Nombre de la propiedad cuyo valor se desea recuperar. Ejemplo: <html><head><title>Ejemplo de Bean</title></head> <body> <jsp:useBean id=”discos” class=”DiscosTienda” > <jspSetroperty name=”disco” property=”id” /> <ul> <li> Titulo del disco: <jsp:getProperty name=”disco” property=”titulo” /> </li> </ul> </body></html>

Ejemplo ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Fichero StringBean.java /*Un JavaBean sencillito que sólo tiene un campo llamado mensaje de tipo String */ package business.vo; public class StringBean { private String mensaje = "Ningún mensaje"; public String getMensaje() { return(mensaje); } public void setMensaje(String mensaje) { this.mensaje = mensaje; } }

Ejemplo ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) Fichero StringBean.jsp <htmlL> <head><title>Uso de JavaBeans con JSP</title></head> <body> <div>Uso de JavaBeans con JSP</div> <jsp:useBean id="stringBean" class="business.vo.StringBean" /> <ul> <li>Valor inicial (getProperty): <jsp:getProperty name="stringBean" property="mensaje" /> </li> <li> <jsp:setProperty name="stringBean" property="mensaje" value="Texto" /> Valor después de haber cambiado el campo con setProperty: <jsp:getProperty name="stringBean" property="mensaje" /> </Ii> </ul> </body> </html>

Ejercicios Módulo: J2EE Tema: JavaServer Pages ( JSP ) Ejercicio 1: Tendremos que realizar una página JSP que nos muestre un formulario con los datos personales de un usuario. Una vez que rellenemos dicho formulario, mostraremos utilizando beans los datos de ese usuario por pantalla. Primero cargaremos los datos del usuario los cargaremos poniendo en el property los nombres de las propiedades. < jsp:setProperty name = "usuarioVO" property = "propiedad" /> Una vez realizado ésto, probaremos a ver que pasa poniendo un *. < jsp:setProperty name = "usuarioVO" property = "*" />

Ejercicios Módulo: J2EE Tema: JavaServer Pages ( JSP ) Ejercicio 2: Modificar la aplicación anterior, de tal forma que vamos a tener una página de inicio que lo único que hará será redirigirnos a otra págia principal utilizando la acción apropiada. Esa página principal estaá formada por cuatro páginas incluidas mediante otra acción. cabecera.jsp: Tendrá la cabecera de nuesta página cuerpo.jsp: Tendrá que realizar las tareas del ejercicio 1. contador.jsp: Contador de visitas de nuestra página. Las visitas serán el número de accesos a la página de los usuarios que no la hyan visitado ya en su sesión actual. pie.jsp: Mostraremos el pie de nuestra página.

Ejercicios Módulo: J2EE Tema: JavaServer Pages ( JSP ) Ejercicio propuesto para casa: Vamos a realizar un de periódico virtual donde almacenaremos distintas noticias. Una noticias tendrán un solo autor y podrá pertenecer a varias secciones. Por lo que tendremos que crear cuatro tablas para almacenar la información. noticia: pk_id, titulo, reseña, contenido, fecha de publicación, fk_autor autor: pk_id, nombre, apellidos Seccion: pk_id, nombre, descripción noticia_seccion: fk_noticia, fk_seccion En nuestra aplicación tendremos dos partes, una parte privada y una parte publica. Parte privada: Administración de las noticias. Debemos estar validado para acceder a esta parte. Guardaremos los usuarios en otra tabla de la base de datos( pk_id, login, password ). Parte pública: Los usuarios podrán consultar las noticias por autor o por secciones. Tambíén dispondrán de un buscador avanzado de noticias donde tendrán diversas opciones de busqueda, como por nombre, fecha de publicación, sección, autor, etc. En la portada se mostrarán las cuatro últimas noticias insertadas.

La librería JSTL ( biblioteca de etiquetas estándar de Java ) es un componente dentro de la especificación del Java 2 Enterprise Edition (J2EE) y es controlada por Sun MicroSystems. El objetivo de JSTL es facilitar el trabajo a los desarrolladores de JSP. Como se verá a lo largo de nuestro estudio, JSTL utiliza ciertas convenciones que hacen más fácil al desarrollador el recordar la estructura interna de las etiquetas. JSTL proporciona unas bibliotecas de etiquetas JSP, como por ejemplo:: core: <%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %> fmt: <%@ taglib prefix="fmt" uri="http://java.sun.com/jstl/fmt" %> JSTL Módulo: J2EE Tema: JavaServer Pages ( JSP )

El lenguaje de expresiones (EL) sirve para facilitar la escritura de expresiones restringidas Java dentro de una página JSP Antes de JSTL, JSP usaba Java para referenciar atributos dinámicos. Con JSTL ya no es necesario. Compara por ejemplo, la lectura de un parametro: con JSP <%= request.getParameter("login") %> con JSTL ${param.login} . Una expresión EL se escribe de la forma ${expresion} y entre las llaves puede usarse cualquier operador binario o unario que se quiera, ya sea matemático, de cadena, relacional o lógico. Es muy útil el operador unario empty para saber si algo es null o no. Ejemplo: ${empty param.login} Lenguaje de Expresión JSTL (1) Módulo: J2EE Tema: JavaServer Pages ( JSP )

Las expresiones se componen de: Identificadores. Hay once identificadores reservados que corresponden a once objetos implícitos. 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. 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}" . Lenguaje de Expresión JSTL (2) Módulo: J2EE Tema: JavaServer Pages ( JSP )

Para acceder al campo de un bean java, o a un elemento de una colección (array, o Map ), se usa el operador punto, o el operador corchete: ${bean.propiedad} ${map.elemento} ${header['User-Agent']} Si un campo de un bean es otro bean, podemos encadenar puntos para acceder a una propiedad del segundo bean: ${bean1.bean2.propiedad} Las expresiones pueden aparecer como parte del valor de un atributo de una etiqueta: <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}"/> Lenguaje de Expresión JSTL (3) Módulo: J2EE Tema: JavaServer Pages ( JSP )

Las siguientes variables pueden usarse directamente (todas son listas): param : Parámetros del request como cadenas. paramValues : Parámetros del request como array de cadenas. 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. initParam: Parametros de inicialización de la aplicación Web. pageContext: El objeto PageContext de la página actual. pageScope , requestScope , sessionScope y applicationScope : lista con las variables definidas en cada ámbito. Lenguaje de Expresión JSTL (4) Módulo: J2EE Tema: JavaServer Pages ( JSP )

Etiquetas para iteración sobre datos, operaciones condicionales, e importación de datos de otras páginas <c:out> utilizada con el mismo objetivo que el scriptlet <%= expresion %> tiene algunas funcionalidades adicionales <c:set> permite asignar valores a variables (p.ej., de sesión) o a propiedades de Java Beans <c:remove> es el complemento natural al anterior, y sirve para destruir variables con ámbito <c:if> emite por la salida el cuerpo que contiene sólo si la condición a que se refiere es cierta <c:choose>, <c:when> y <c:otherwise> permiten formar una estructura de ifs en cascada con parte else <c:forEach> permite recorrer una colección o un array , así como ejecutarse como un bucle FOR Core Tag Library Módulo: J2EE Tema: JavaServer Pages ( JSP )

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. Por defecto escapeXml está puesto a true, lo que quiere decir que se traducen algunos caracteres para evitar errores: El Caracter '<' se traduce autómaticamente a '<' Puede probarse como ejemplo con la página completa: <c:out value="Mensaje escrito con c:out" /> El valor dado al atributo value se convierte en String y se emite, a no se que sea un objeto de tipo java.io.Reader, en cuyo caso lo que se emite es el resultado de leer por completo dicho canal de entrada. <c:out> Módulo: J2EE Tema: JavaServer Pages ( JSP )

Tenemos el siguiente Bean: package business.vo; 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; } } Ejemplo: <c:out> y reader ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )

Y el JSP sería: <jsp:useBean id="stringBean" class="business.vo.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 fichero e:\prueba.txt. De una sola tacada se ha emitido el contenido de un fichero entero. Ejemplo: <c:out> y reader ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )

La sintaxis de <c:set> es: Para asignar valor a una variable con ámbito <c:set value=”valor” var=”nombreVar” [scope=”page|request|session|application”] /> <c:remove> sólo tiene sentido para variables con ámbito. La sintaxis de <c:remove> es: <c:remove var=”nombreVar” [scope=”page|request|session|application”] /> <c:set> hace asignaciones a variable con ámbito o a propiedades de Java Beans o a datos de Mapas. <c:remove> elimina variables con ámbito. <c:set> y <c:remove> Módulo: J2EE Tema: JavaServer Pages ( JSP )

En este ejemplo se ve el uso de <c:set> (no olvidar la directiva taglib): <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 Jorge" /> ${cadena}<br> Ejemplo: <c:set> Módulo: J2EE Tema: JavaServer Pages ( JSP )

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 variable, entonces es como si se utilizara para cargar un valor booleano en dicha variable. Como puede verse, esta etiqueta carece de cláusula else. El motivo es que la cláusula else, utilizada a discreción, se convierte en unos ifs en cascada mutuamente excluyentes; <c:if> Módulo: J2EE Tema: JavaServer Pages ( JSP )

Ej. de control: <c:if test="${ empty param.nombre}" > Se le ha olvidado escribir un valor para el nombre.<br> </c:if> Puede probarse a cargar una página que contenga esto pasando 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> Ejemplo: <c:if> Módulo: J2EE Tema: JavaServer Pages ( JSP )

Estas tres etiquetas se emplean conjuntamente según la siguiente 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 entrado en un <c:choose> se evalúan los <c:when> en secuencia; en el primero en que la condición sea cierta, se emite su cuerpo y se sale del <c:choose>. Si todas las condiciones son falsas se emite el cuerpo de <c:otherwise>. <c:choose>, <c:when> y <c:otherwise> Módulo: J2EE Tema: JavaServer Pages ( JSP )

El siguiente ejemplo completo comprueba los parámetros de entrada a un formulario y emite diferentes salida en base a estos: <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> ¡Cuánto tiempo sin verte!<br> Qué día más ${param.tiempo} hace.<br> </c:otherwise> </c:choose> Ejemplo: <c:choose> Módulo: J2EE Tema: JavaServer Pages ( JSP )

La sintaxis que recorre una estructura es: <c:forEach [var=”nombreVar”] items =”coleccion” [begin=”comienzo”] [end=”final”] [step=”paso”] > // Cuerpo a repetir </c:forEach> 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 situado en posición comienzo, <c:forEach> ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )

Para ejecutarse un determinado número de veces, la sintaxis es: <c:forEach [var=”nombreVar”] begin =”comienzo” end =”final” [step=”paso”] > // Cuerpo a repetir </c:forEach> La variable nombreVar parte del valor comienzo hasta el valor final incrementándose en cada iteración por paso unidades. <c:forEach> ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )

El <c:forEach> se usa para recorrer una colección de forma que cada elemento visitado es apuntado por nombreVar Como colección también puede indicarse un array tradicional e incluso un String. Ejemplo de recorrido de los elementos de la cabecera (header): <c:forEach var="elemento" items="${header}"> ${elemento}<br> -> ${elemento.value}<br> </c:forEach> <c:forEach> ( 3 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )

La librería JSTL es distribuida como un conjunto de archivos JAR que simplemente tenemos que agregarlo en el classpath del contenedor de servlets. 1. Debemos usar un contenedor de servlets compatible con la versión JSP 2.0 para usar el JSTL 1.1. El Apache Tomcat 5.0 [http://jakarta.apache.org/tomcat/] por ejemplo. En caso contrario, es posible usar el JSTL 1.0 en un contenedor que soporte por lo menos el JSP 1.2 y servlets 2.3. 2. Descargar la implementación JSTL de la página de proyecto Jakarta TagLibs [http://mirrors.isc.org/pub/apache/jakarta/taglibs/standard/]. La distribución binaria viene empaquetada como .zip o tar.gz. Desempaquete estos archivos en un directorio temporal. 3. Del directorio temporal, copie todos los archivos s tandard.jar y jstl.jar que se encuentran en jakarta-taglibs-standard-1.1.2/lib al directorio /WEB-INF/lib de su aplicación Web.También copiaremos el contenido de la carpeta jakarta-taglibs-standard-1.1.2/conf a un /WEB-INF/conf. Instalación y configuración ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )

4. A continuación debemos mapear en el web.xml las librerías que vayamoa a utilizar de la siguiente forma:. <taglib> <taglib-uri>/WEB-INF/c</taglib-uri> <taglib-location>/WEB-INF/conf/c.tld</taglib-location> </taglib> 5.Ahora, creamos una página JSP y probamos algunas etiquetas simples para asegurarnos que la configuración del JSTL está bien hecha. <%@ taglib prefix="c" uri="/WEB-INF/c" %> <c:set var="hello" value="Hola mundo"/> <div> <c:out value="${hello}"/> </div> Instalación y configuración ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )

Ejemplo ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) <%@ taglib prefix="c" uri="/WEB-INF/c" %> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=ISO-8859-1"> <title>JSTL - Ejemplo 1</title> </head> <body> <c:set var="nombre" value="Mi nombre es Jorge" /> <div><c:out value="${nombre}" default="Valor por defecto;" /></div> <div><c:out value="${variableInexistente}" default=”Valor por defecto"/></div> <hr/>

Ejemplo ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) <div>Cabecera: </div> <ul> <c:forEach var="elemento" items="${header}"> <li><strong>${elemento.key}:</strong> ${elemento.value}</li> </c:forEach> </ul> <hr/> <ul> <c:forEach var="unaCookie" items="${cookie}"> <li><strong>${unaCookie.key}:</strong> ${unaCookie.value}</li> </c:forEach> <ul/> </body></html>

Ejercicio Módulo: J2EE Tema: JavaServer Pages ( JSP ) Ejercicio 1 Tendremos una página de inicio con un formulario. Dicho formulario tendrá los siguientes datos personales de un usuario: nombre, apellidos, nif, direccion, telefono y sexo( será un desplegable con las opciones 'Hombre' y 'Mujer'. Además tendremos una opción por defecto que será 'Seleccione'. Tendremos un servlet que nos recogerá los datos del formulario, los cargará en un UsuarioVO, meterá dicho objeto en sesión y llamará a otra página JSP que nos mostrará los dados introducidos por el usuario. Si la opción sexo no fue seleccionada correctamente, sino que se dejo la opción por defecto:, se mostrará 'No se ha seleccionado el sexo del usuario' NO DEBEMOS INTRODUCIR NADA DE CÓDIGO JAVA DENTRO DE LA PÁGINA JSP.

Ejercicio Módulo: J2EE Tema: JavaServer Pages ( JSP ) Ejercicio 2 Tendremos una página de inicio con un formulario. Dicho formulario tendrá los siguientes datos personales de un usuario: nombre, apellidos, nif, direccion, telefono y sexo( será un desplegable con las opciones 'Hombre' y 'Mujer'. Además tendremos una opción por defecto que será 'Seleccione'. Tendremos un servlet que nos recogerá los datos del formulario, los cargará en un UsuarioVO, añadirá el usuario a una lista de UsuarioVO, y meterá en sesión la lista de usuarios. A continuación llamará a otra página JSP que nos mostrará la lista de usuarios. En dicha página tendremos un enlace para volver a la página del formulario y añadir mas usuarios a la lista. NO DEBEMOS INTRODUCIR NADA DE CÓDIGO JAVA DENTRO DE LA PÁGINA JSP.

Curso Jsp

Más contenido relacionado

La actualidad más candente (19)

Destacado (20)

Similar a Curso Jsp (20)

Último (20)

Curso Jsp