Your SlideShare is downloading. ×
  • Like
Curso Jsp Mas
Upcoming SlideShare
Loading in...5
×

Thanks for flagging this SlideShare!

Oops! An error has occurred.

×

Now you can save presentations on your phone or tablet

Available for both IPhone and Android

Text the download link to your phone

Standard text messaging rates apply
Published

 

Published in Technology
  • Full Name Full Name Comment goes here.
    Are you sure you want to
    Your message goes here
  • gracias
    Are you sure you want to
    Your message goes here
  • gracias
    Are you sure you want to
    Your message goes here
No Downloads

Views

Total Views
6,556
On SlideShare
0
From Embeds
0
Number of Embeds
0

Actions

Shares
Downloads
379
Comments
2
Likes
3

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. JAVASERVER PAGES Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 2. 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. La tecnología permite generar páginas dinámicas a través de la inclusión de código Java en la propia HTML.
      • 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.
      • Es posible ver el código del servlet generado, este código debe estar en una carpeta del servidor, dependiendo ésta del tipo de servidor utilizado.
      • Se generan las siguientes clases:
            • JSPPages
            • HttpJspPages
      • Se encuentran también tres métodos:
            • _jspInit()
            • _jspDestroy()
            • _jspService()
      • Los dos primeros métodos pueden ser definidos por el programador de la página JSP, pero el tercer método es la versión compilada de la página JSP, y la crea al motor JSP..
  • 3. Funcionamiento Módulo: J2EE Tema: JavaServer Pages ( JSP )
      • ¿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.
  • 4. 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 (y modificar!) 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: nuestros expertos en diseño de páginas Web pueden construir el HTML, dejando espacio para que nuestros programadores de servlets inserten el contenido dinámico.
  • 5. 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.
  • 6. 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” %>
  • 7. 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” : Comunica al servidor el lenguaje que va a ser utilizado en el archivo. Java es el único posible valor en esta especificación.
          • extends = ”package.class”: La variable extends, define la clase padre del servlet generado. Normalmente no es necesario utilizar otras que no sean las de las clases base del proveedor
          • import = ”package.*”,”package.class”: Sirve para especificar los paquetes y las clases que se quieran utilizar.
          • session = “true false”: Por defecto session vale true, manteniendo los datos de las sesiones para la página.
          • isThreadSafe = “true false”: Por defecto vale true, le hace señales al motor de JSP para que multiples pedidos del cliente puedan ser tomados como uno solo.
          • info = “text”: Información en la página a la que puede accederse a través del método Servlet.getServletInfo().
          • errorPage = “pagina_error”: Página que manejará las excepciones de errores.
          • isErrorPage = “true false”: Marca a la página como la página que manejará los errores.
  • 8. 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=&quot;url relativa&quot; %>
      • La URL especificada normalmente se interpreta como relativa a la página JSP a la que se refiere, pero, al igual que las URLs relativas en general, podemos decirle al sistema que interpreta la URL reltativa al directorio home del servidor Web empezando la URL con una barra invertida. Los contenidos del fichero incluido son analizados como texto normal JSP, y así pueden incluir HTML estático, elementos de script, directivas y acciones.
  • 9. 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.
  • 10. <%! 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.
      • Es perferible que las declaraciones estén en un solo bloque de declaración JSP <%! ... %>, para centralizar las declaraciones dentro de un área del cuerpo JSP. Aquí tenemos un ejemplo:
  • 11. 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 %>: Una expresión JSP se usa para insertar valores directamente en la salida.
          • Las expresiones no terminan en (;), ya que el motor de JSP pondrá la expresión automáticamente dentro de out.println().
          • Scriptles: <% código %>: Los scriptlets JSP permiten insertar código Java dentro del método _jspService() del servlet que será construido al general la página.
  • 12. Variables predefinidas Módulo: J2EE Tema: JavaServer Pages ( JSP )
      • JSP incorpora ocho variables ya definidas, llamadas también objetos implicitos.
          • request : Hace referencia a HttpServletRequest. Es la petición del cliente.
          • response : Hace referencia a HttpServletResponse. Es la página JSP de respuesta.
          • session : Hace referencia a HttpSession. Variables de sesión.
          • out : Hace referencia a PrintWriter usada para enviar la salida al cliente.
          • application : Esta variable es el ServletContext obtenido medante getServletConfig().getContext(). Permite almacenar datos persistentes en el objeto ServletContext en lugar de variables de instancia.
          • config : Hace referencia al objeto ServletConfing e la página.
          • pageContext : Jsp incorpora una nueva clase llamada PageContext para encapsular características de uso específicas el servidor. Esta clase PageContext es inicializada con los objetos response y request y algunos atributos de la directiva de la página ( erropage, session, buffer y autoflush ).
          • page : Esta variable es un sinónimo de this, y no es muy util en Java.
      • La mayoría de estas variables de referencia se han visto y utilizado con servlets y sus funciones y operativa son idénticas.
  • 13. 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 --%>
  • 14. Ejemplo de JSP ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
    • <! DOCTYPE HTML PUBLIC &quot;-//W3C//DTD HTML 4.01 Transitional//EN&quot; >
    • <%@ page language = &quot;java&quot;
    • contentType = &quot;text/html; charset=ISO-8859-1&quot;
    • pageEncoding = &quot;ISO-8859-1&quot; %>
    • <%@ page import = &quot;java.util.*&quot; %>
    • <%!
    • 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 = &quot;Content-Type&quot; content = &quot;text/html; charset=ISO-8859-1&quot; >
    • < title > Ejemplo 1 </ title >
    • </ head >
  • 15. Ejemplo de JSP ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) < body > <% ip = request.getRemoteAddr(); host = request.getRemoteHost(); %> < div >< b > Informaci &oacute; 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( &quot;<div>&quot; + name + &quot; = &quot; + value + &quot;</div>&quot; ); } %> </ body > </ html >
  • 16. 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.
  • 17. 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, o generar HTML para el plug-in Java. Las acciones disponibles incluyen:
      • 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
  • 18. 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=&quot;relative URL&quot; flush=&quot;true&quot; />
      • 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. Esto se paga un poco en la eficiencia, e imposiblita a la página incluida de contener código JSP general (no puede seleccionar cabeceras HTTP, por ejemplo), pero se obtiene una significante flexibilidad.
      • Con el cuerpo opcional jsp:param es posible enviar campos al formulario destino.
    • <jsp:include page=&quot;pagina.jsp&quot; flush=&quot;true&quot;>
    • <jsp:param name=&quot;id&quot; value=&quot;valor&quot;/>
    • </jsp:include>
  • 19. 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
  • 20. Beans ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
      • Los JavaBeans se idearon como un mecanismo para diseñar componentes, generalmente de tipo gráfico, que pudiesen ser reutilizados por los entornos de desarrollo integrado(IDE).
      • Para ello el interfaz de un JavaBean debía ser capaz de mostrar su contenido en tiempo de ejecución. Esta característica ha hecho que los JavaBeans se utilicen en otos entornos, como puede ser el desarrollo de aplicaciones web.
      • Un JavaBean no es más que una clase java que sigue ciertas convenciones con los nombres de sus métodos
  • 21. Beans ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
      • Pautas en la construcción de un bean:
          • 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.
      • 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.
  • 22. Beans ( 3 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
      • 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
      • 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
  • 23. 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=&quot;package.class&quot; />
      • 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=&quot;DiscoTienda&quot; />
      • Debe entenderse como:
      • <% DiscoTienda discos = new DiscosTienda(); %>
  • 24. 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=”page|request|session|application” . 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.:
  • 25. 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ódifgo 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” / >
      • En este caso, el jsp:setProperty se ejecuta independientemente de si se ha instanciado un nuevo bean o se ha encontrado uno ya existente. 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>
      • Aquí el jsp:setProperty sólo se ejecuta si se ha instanciado un nuevo objeto, no si se encontró uno ya existente.
  • 26. 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. Para que se realice la asignación automática, los nombres de los parámetros de entrada deben coincidir exáctamente, mayúsculas y minúsculas.
  • 27. 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>
  • 28. 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 = &quot;Ningún mensaje&quot;;
    • public String getMensaje() {
    • return(mensaje);
    • }
    • public void setMensaje(String mensaje) {
    • this.mensaje = mensaje;
    • }
    • }
  • 29. 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=&quot;stringBean&quot; class=&quot;business.vo.StringBean&quot; />
    • <ul>
    • <li>Valor inicial (getProperty):
    • <jsp:getProperty name=&quot;stringBean&quot; property=&quot;mensaje&quot; />
    • </li>
    • <li>
    • <jsp:setProperty name=&quot;stringBean&quot; property=&quot;mensaje&quot; value=&quot;Texto&quot; />
    • Valor después de haber cambiado el campo con setProperty:
    • <jsp:getProperty name=&quot;stringBean&quot; property=&quot;mensaje&quot; />
    • </Ii>
    • </ul>
    • </body>
    • </html>
  • 30. 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 = &quot;usuarioVO&quot; property = &quot;propiedad&quot; />
          • Una vez realizado ésto, probaremos a ver que pasa poniendo un *.
          • < jsp:setProperty name = &quot;usuarioVO&quot; property = &quot;*&quot; />
  • 31. 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.
  • 32. 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.
  • 33.
      • 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=&quot;c&quot; uri=&quot;http://java.sun.com/jstl/core&quot; %>
        • fmt: <%@ taglib prefix=&quot;fmt&quot; uri=&quot;http://java.sun.com/jstl/fmt&quot; %>
    JSTL Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 34.
      • La especificación JSP ahora se ha convertido en una tecnología estándar para la creación de sitios Web dinámicos en Java, y el problema es que han aparecido algunas debilidades:
          • El código Java embebido en scriptlets es desordenado.
          • Un programador que no conoce Java no puede modificar el código Java embebido, anulando uno de los mayores beneficios de los JSP: permitir a los diseñadores y personas que escriben la lógica de presentación que actualicen el contenido de la página.
          • El código de Java dentro de scriptlets JSP no pueden ser reutilizados por otros JSP, por lo tanto la lógica común termina siendo re-implementado en múltiples páginas.
          • La recuperación de objetos fuera del HTTP Request y Session es complicada. Es necesario hacer el Casting de objetos y esto ocasiona que tengamos que importar más Clases en los JSP.
    Problema con los scriptlets JSP Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 35.
      • Debido a que las etiquetas JSTL son XML, estas etiquetas se integran limpia y uniformemente a las etiquetas HTML.
      • Las 4 librerías de etiquetas JSTL incluyen la mayoría de funcionalidad que será necesaria en una página JSP. Las etiquetas JSTL son muy sencillas de usarlas para personas que no conocen de programación, a lo mucho necesitarán conocimientos de etiquetas del estilo HTML.
      • Las etiquetas JSTL encapsulan la lógica como el formato de fechas y números. Usando los scriptlets JSP, esta misma lógica necesitaría ser repetida en todos los sitios donde es usada, o necesitaría ser movida a Clases de ayuda.
      • Las etiquetas JSTL pueden referenciar objetos que se encuentren en los ambientes Request y Session sin conocer el tipo del objeto y sin necesidad de hacer el Casting.
      • Los JSP EL (Expression Language) facilitan las llamadas a los métodos Get y Set en los objetos Java. Esto no es posible en la versión JSP 1.2, pero ahora está disponible en JSP 2.0. EL es usado extensamente en la librería JSTL.
      • Debido a que las etiquetas JSTL son XML, estas etiquetas se integran limpia y uniformemente a las etiquetas HTML.
      • Las 4 librerías de etiquetas JSTL incluyen la mayoría de funcionalidad que será necesaria en una página JSP. Las etiquetas JSTL son muy sencillas de usarlas para personas que no conocen de programación, a lo mucho necesitarán conocimientos de etiquetas del estilo HTML.
      • Las etiquetas JSTL encapsulan la lógica como el formato de fechas y números. Usando los scriptlets JSP, esta misma lógica necesitaría ser repetida en todos los sitios donde es usada, o necesitaría ser movida a Clases de ayuda.
      • Las etiquetas JSTL pueden referenciar objetos que se encuentren en los ambientes Request y Session sin conocer el tipo del objeto y sin necesidad de hacer el Casting.
      • Los JSP EL (Expression Language) facilitan las llamadas a los métodos Get y Set en los objetos Java. Esto no es posible en la versión JSP 1.2, pero ahora está disponible en JSP 2.0. EL es usado extensamente en la librería JSTL.
    Mejora de la librería JSTL Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 36.
      • Los JSTL pueden agregar mayor sobrecarga en el servidor. Los scriptlets y las librerías de etiquetas son compilados a servlets, los cuales luego son ejecutados por el contenedor. El código Java embebido en los scriptlets es básicamente copiado en el servlet resultante. En cambio, las etiquetas JSTL, causan un poco más de código en el servlet. En la mayoría de casos esta cantidad no es mensurable pero debe ser considerado.
      • Los scriptlets son más potentes que las etiquetas JSTL. Si desea hacer todo en un script JSP pues es muy probable que insertará todo el código en Java en él. A pesar que las etiquetas JSTL proporciona un potente conjunto de librerías reutilizables, no puede hacer todo lo que el código Java puede hacer. La librería JSTL está diseñada para facilitar la codificación en el lado de presentación que es típicamente encontrado en la capa de Vista si hablamos de la arquitectura Modelo-Vista-Controlador.
    Desventajas de los JSTL Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 37.
      • 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(&quot;login&quot;) %>
          • 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 )
  • 38.
      • Las expresiones se componen de:
        • Identificadores. Hay once identificadores reservados que corresponden a once objetos implícitos (los veremos luego). El resto de identificadores sirven para crear variables.
        • Literales. Son números, cadenas delimitadas por comillas simples o dobles, y los valores true , false , y null .
        • Operadores. Permiten comparar y operar con identificadores y literales.
        • Operadores de acceso. Se usan para referenciar propiedades de los objetos.
      • 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=&quot;Hola ${nombre} ${apellidos}&quot; .
    Lenguaje de Expresión JSTL (2) Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 39.
      • 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=&quot;${nombre}&quot;/>
    • <c:if test=&quot;${tabla.indice % 2 == 0}&quot;>es par</c:if>
      • O independientemente junto a texto estático como el HTML:
    • <input type=&quot;text&quot; name=&quot;usuario&quot; value=&quot;${requestScope.usuario.nombre}&quot;/>
    Lenguaje de Expresión JSTL (3) Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 40.
      • 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.
      • Ejemplo:
    • <c:forEach var=”unaCookie” items=”${cookie}”>
    • ${unaCookie}<br>
    • </c:forEach>
    Lenguaje de Expresión JSTL (4) Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 41.
      • 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:catch> permite recuperar un error, y supone el complemento perfecto para la página de error JSP
        • <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
        • <c:forTokens> divide una cadena en trozos y se ejecuta para cada trozo
    Core Tag Library Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 42.
      • 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 '&lt;'
          • Puede probarse como ejemplo con la página completa:
          • <%@ taglib uri=&quot;http://java.sun.com/jsp/jstl/core&quot; prefix=&quot;c&quot; %>
      • <c:out value=&quot;Mensaje escrito con c:out&quot; />
      • 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 )
  • 43.
      • Tenemos el siguiente Bean:
      • package business.vo;
      • import java.io.*;
      • public class StringBean {
      • private String nombreFichero = &quot;Ningun nombreFichero&quot;;
      • 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 )
  • 44.
      • Y el JSP sería:
      • <%@ taglib uri=&quot;http://java.sun.com/jsp/jstl/core&quot; prefix=&quot;c&quot; %>
      • <jsp:useBean id=&quot;stringBean&quot; class=&quot;business.vo.StringBean&quot; />
      • <jsp:setProperty name=&quot;stringBean&quot; property=&quot;lector&quot; value=&quot; e:/prueba.txt &quot; />
      • <c:out value=&quot;${stringBean.lector}&quot;/><br>
      • <c:out value=&quot;Otra cosa&quot; /><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 )
  • 45.
      • 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”] />
      • Para asignar una propiedad a un Java Bean, o un elemento de un mapa
        • <c:set value=”valor” target=”nombreVar” property=”nombrePropiedad” />
      • <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 )
  • 46.
      • En este ejemplo se ve el uso de <c:set> (no olvidar la directiva taglib):
        • <c:set var=&quot;aux&quot; value=&quot;1&quot; />
        • ${aux}<br>
        • <c:set var=&quot;aux&quot; value=&quot;${aux + 1}&quot; />
        • ${aux}<br>
        • <c:set var=&quot;cadena&quot; value=&quot;mi nombre&quot; />
        • ${cadena}<br>
        • <c:set var=&quot;cadena&quot; value=&quot;${cadena} es Jorge&quot; />
        • ${cadena}<br>
    Ejemplo: <c:set> Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 47.
      • Para demostrar el concepto de ordenamiento y mejor mantenimiento de los JSP, veamos 2 versiones de una página simple.
      • La primera versión usa etiquetas scriptlets, y la segunda usa etiquetas JSTL.
      • Ambas páginas implementan la misma lógica. Graban una lista de objetos AddressVO del Request y luego iteran a través de la lista, imprimiendo el atributo apellido de cada objeto (si el apellido no es null y de longitud diferente a 0).
      • En cualquier otro caso, imprimirá &quot;N/A&quot;.
      • Finalmente, la página imprime la fecha actual.
    Ejemplo ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 48.
      • 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; y para eso, la biblioteca core suministra otras etiquetas
    <c:if> Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 49.
      • Ej. de control:
      • <c:if test=&quot;${ empty param.nombre}&quot; >
      • 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=&quot;existeNombre&quot; test=&quot;${ empty param.nombre}&quot; />
      • ${existeNombre}<br>
    Ejemplo: <c:if> Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 50.
      • 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 )
  • 51.
      • El siguiente ejemplo completo comprueba los parámetros de entrada a un formulario y emite diferentes salida en base a estos:
      • <%@ taglib uri=&quot;http://java.sun.com/jsp/jstl/core&quot; prefix=&quot;c&quot; %>
      • <h3>Saludos</h3>
      • <c:choose>
      • <c:when test=&quot;${empty param.nombre}&quot; >
      • Necesito un nombre.<br>
      • </c:when>
      • <c:when test=&quot;${empty param.tiempo}&quot; >
      • 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 )
  • 52.
      • La sintaxis que recorre una estructura es:
      • <c:forEach [var=”nombreVar”]
      • items=”coleccion”
      • [varStatus=”nombreVarEstado”]
      • [begin=”comienzo”]
      • [end=”final”]
      • [step=”paso”] >
      • // Cuerpo a repetir
      • </c:forEach>
      • Para ejecutarse un determinado número de veces, la sintaxis es:
      • <c:forEach [var=”nombreVar”]
      • [varStatus=”nombreVarEstado”]
      • begin=”comienzo”
      • end=”final”
      • [step=”paso”] >
      • // Cuerpo a repetir
      • </c:forEach>
    <c:forEach> ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 53.
      • La sintaxis de la ejecución un determinado número de veces parece clara: la variable nombreVar parte del valor comienzo hasta el valor final incrementándose en cada iteración por paso unidades.
      • 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. Si hay menos ítems que comienzo, entonces el bucle ni se ejecuta. El primer elemento de la colección está en la posición 0.
      • El <c:forEach> se usa para recorrer una colección de forma que 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 tradicional e incluso un String. En este último caso, se supone que el String posee palabras separadas por comas, y el <c:forEach> se ejecuta para cada una de tales palabras. La coma hace las veces de carácter delimitador.
      • Ejemplo de recorrido de los elementos de la cabecera (header):
      • <c:forEach var=&quot;elemento&quot; items=&quot;${header}&quot;>
      • ${elemento}<br>
      • -> ${elemento.value}<br>
      • </c:forEach>
    <c:forEach> ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 54.
      • 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 )
  • 55.
      • 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=&quot;c&quot; uri=&quot;/WEB-INF/c&quot; %>
      • <c:set var=&quot;hello&quot; value=&quot;Hola mundo&quot;/>
      • <div>
      • <c:out value=&quot;${hello}&quot;/>
      • </div>
    Instalación y configuración ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
  • 56. Ejemplo ( 1 ) Módulo: J2EE Tema: JavaServer Pages ( JSP ) <%@ taglib prefix=&quot;c&quot; uri=&quot;/WEB-INF/c&quot; %> <html> <head> <meta http-equiv=&quot;Content-Type&quot; content=&quot;text/html; charset=ISO-8859-1&quot;> <title>JSTL - Ejemplo 1</title> </head> <body> <c:set var=&quot;nombre&quot; value=&quot;Mi nombre es Jorge&quot; /> <div><c:out value=&quot;${nombre}&quot; default=&quot;Valor por defecto;&quot; /></div> <div><c:out value=&quot;${variableInexistente}&quot; default=”Valor por defecto&quot;/></div> <hr/>
  • 57. Ejemplo ( 2 ) Módulo: J2EE Tema: JavaServer Pages ( JSP )
    • <div>Cabecera: </div>
    • <ul>
    • <c:forEach var=&quot;elemento&quot; items=&quot;${header}&quot;>
    • <li><strong>${elemento.key}:</strong> ${elemento.value}</li>
    • </c:forEach>
    • </ul>
    • <hr/>
    • <ul>
    • <c:forEach var=&quot;unaCookie&quot; items=&quot;${cookie}&quot;>
    • <li><strong>${unaCookie.key}:</strong> ${unaCookie.value}</li>
    • </c:forEach>
    • <ul/>
    • </body></html>
  • 58. Ejercicio Módulo: J2EE Tema: JavaServer Pages ( JSP )
    • Ejercicio 1: