4. Curso Java JSP (Java Server Pages) - Curso 2005-2006

Samuel Marrero Lorenzo [email protected] 1

J2EE – Java Server Pages

JSP

2

Introducción Servlets - JSP

� En los servltes vistos anteriormente:� el texto generado para el aspecto (vista) de la interfaz

gráfica (HTML,WML, etc.) está mezclado con código Java

� No es posible usar herramientas de generación de HTML, etc. directamente

� La generación del texto necesita ser escrita por una persona con conocimientos de Java => económicamente muy costoso

� Cambios al aspecto de la interfaz gráfica requieren recompilación, creación de un nuevo fichero .war y rearranque del servidor

� En una aplicación web, especialmente en Internet, los cambios a la interfaz gráfica son muy frecuentes

3

Introducción Servlets – JSP (2)

� Situación a la que queremos llegar� Separación de roles

� Personas que realizan el aspecto gráfico => diseñadores gráficos o similares

� Conocimientos de diseño gráfico y herramientas para generación de HTML y WML

� Personas que implementan el controlador y el modelo =>programadores

� Conocimientos de diseño e implementación

� Se deberían poder usar directamente las herramientas de diseño de páginas web

� Las actualizaciones al aspecto gráfico no deben provocar un re-arranque del servidor

4

JSP

� ¿ Qué es JSP ?� A modo de ejemplo, una página JSP que genera HTML� Tiene el aspecto de una página HTML� Puede incluir scriptlets (scripts) para generar HTML dinámicamente� Típicamente los scriptlets se escriben en Java� En realidad, una página JSP es un tipo especial de servlet

(javax.servlet.jsp y javax.servlet.jsp.tagext) orientado a generar el texto de la interfaz gráfica

� Invocables por GET y POST<<interface>>javax.servlet.Servlet<<interface>> javax.servlet.jsp.JspPage<<interface>>javax.servlet.jsp.HttpJspPage+ _jspService(request : HttpServletRequest, response :

HttpServletResponse) : void

5

JSP (2)

� ¿ Qué ocurre cuando se accede a una página JSP ?� Si es la primera vez, el servidor de aplicaciones genera un servlet (que implementajavax.servlet.jsp.HttpJspPage) a partir de la página JSP, lo compila y lo carga en memoria

� Si no es la primera vez, le pasa la petición al servlet (ya compilado y creado en memoria)

� Si la página se ha modificado desde la última compilación, el servidor se da cuenta, genera el nuevo servlet, lo compila y lo carga de nuevo

6

Primer ejemplo de JSP

<%@page language="java"%> � directiva<HTML> � HTML<HEAD><TITLE>Primer ejemplo JSP</TITLE></HEAD><BODY><%if(request.getParameter("nombre")==null){%> � scriptlet

<H1>Hola Mundo</H1><%}else {%>

<H1>Hola <%=request.getParameter("nombre")%></H1><%}%> Expresión</BODY></HTML>� Código: c:\java\JSP1-HolaMundo\HolaMundo\HolaMundo.jsp

7

Servlet generado por el servidor Tomcat a partir del código JSPpackage org.apache.jsp;

import javax.servlet.*;import javax.servlet.http.*;import javax.servlet.jsp.*;

public final class HolaMundo_jsp extends org.apache.jasper.runtime.HttpJspBaseimplements org.apache.jasper.runtime.JspSourceDependent {

private static java.util.Vector _jspx_dependants;

public java.util.List getDependants() {return _jspx_dependants;

}

public void _jspService(HttpServletRequest request, HttpServletResponse response)throws java.io.IOException, ServletException {

JspFactory _jspxFactory = null;PageContext pageContext = null;HttpSession session = null;ServletContext application = null;ServletConfig config = null;JspWriter out = null;Object page = this;JspWriter _jspx_out = null;PageContext _jspx_page_context = null;

try {_jspxFactory = JspFactory.getDefaultFactory();response.setContentType("text/html");pageContext = _jspxFactory.getPageContext(this, request, response,true, 8192, true);

8

Servlet generado por el servidor Tomcat a partir del código JSP_jspx_page_context = pageContext;

application = pageContext.getServletContext();config = pageContext.getServletConfig();session = pageContext.getSession();out = pageContext.getOut();_jspx_out = out;

out.write("\r\n"); out.write("\r\n"); out.write("<HTML>\r\n"); out.write("<HEAD>\r\n"); out.write("<TITLE>Primer ejemplo JSP</TITLE>\r\n"); out.write("</HEAD>\r\n"); out.write("<BODY>\r\n"); out.write("\r\n");

if(request.getParameter("nombre")==null){out.write("\r\n"); out.write("\r\n");out.write("\t<H1>Hola Mundo</H1>\r\n");out.write("\r\n");

}else {out.write("\r\n");out.write("\r\n");out.write("\t<H1>Hola ");out.print(request.getParameter("nombre"));out.write("</H1>\r\n");out.write("\r\n");

}out.write("\r\n"); out.write(" \t\r\n"); out.write("</BODY>\r\n"); out.write("</HTML>");

} catch (Throwable t) {if (!(t instanceof SkipPageException)){out = _jspx_out;if (out != null && out.getBufferSize() != 0)out.clearBuffer();

if (_jspx_page_context != null) _jspx_page_context.handlePageException(t);}

} finally {if (_jspxFactory != null) _jspxFactory.releasePageContext(_jspx_page_context);

}}

}

9

Expresiones

� Expresión JSP: <%= expression %>

� La expresión es evaluada y situada en la salida.

� <%=request.getParameter(“nombre”)%>

� Escribe en la salida el parámetro ‘nombre’ del objeto petición ‘request’

� El equivalente XML es � <jsp:expression> expression </jsp:expression>.

� Las variables predefinidas son request, response, out, session, application, config, y pageContext.

10

Scriptlets

� Scriptlet JSP: <% código Java %>

� El código se inserta en el método service del servlet generado

� El equivalente XML es:

� <jsp:scriptlet>código</jsp:scriptlet>

11

JSP1-HolaMundoScriptlets

<%if(request.getParameter("nombre")==null){

out.println(“<H1>Hola Mundo</H1>”);}else {

out.println(“<H1>Hola”+request.getParameter("nombre")+”</H1>”);

}%>

� Fíjate que aquí se utiliza en objeto out para escribir la salida, equivalente al PrintWriter usado en servlets

� El código está disponible en el directorio JSP1-HolaMundo� c:\java\JSP1-HolaMundo\HolaMundo\HolaMundo.jsp

12

Declaraciones

� Declaración JSP: <%! Código Java %>

� El código se inserta en el cuerpo de la clase del servlet generado, fuera del método service, como un atributo de la clase servlet.

� El equivalente XML es: � <jsp:declaration>código</jsp:declaration>

13

Ejemplo de declaración

� El siguiente ejemplo implementa un contador de visitas a una página

<%! private int accesos = 0; %> Visitas a la página desde el arranque del servidor

<%= ++accesos %>

14

Directiva page

� Directiva page JSP: <%@ page atributo=“valor" %>� Dirige al motor servlet sobre la configuración general.� El equivalente XML es: <jsp:directive.page language=“java"\>. � Los atributos legales son (con los valores por defecto en negrita):

� import="package.class" � contentType="MIME-Type" � isThreadSafe="true|false" � session="true|false" � buffer="sizekb|none" � autoflush="true|false" � extends="package.class" � info="message" � errorPage="url" � isErrorPage="true|false" � language="java"

15

La directiva page (2)

� import="paquete.clase1,...,paquete.claseN". � Por ejemplo: <%@ page import="java.util.*" %> El atributo import es el

único que puede aparecer múltiples veces.

� contentType="MIME-Type; charset=Character-Set" Esto especifica el tipo MIME de la salida. El valor por defecto es text/html. � Por ejemplo, la directiva: <%@ page contentType="text/plain" %> tiene el

mismo valor que el scriptlet <% response.setContentType("text/plain"); %>

� isThreadSafe="true|false". Un valor de true (por defecto) indica un procesamiento del servlet normal, donde múltiples peticiones pueden procesarse simultáneamente con un sólo ejemplar del servlet. � Un valor de false indica que el servlet debería implementar

SingleThreadModel, con peticiones enviadas serialmente.

16


� session="true|false". Un valor de true (por defecto) indica que la variable predefinida session (del tipo HttpSession) es la sesión si existe, si no existe, se crea una nueva sesión.� Un valor de false indica que no se usarán sesiones, y los intentos de

acceder a la variable session resultarán en errores en el momento en que la página JSP sea traducida a un servlet.

� buffer="sizekb|none". Esto especifica el tamaño del buffer para el JspWriter out. El valor por defecto es específico del servidor, debería ser de al menos 8kb.

� autoflush="true|false". Un valor de true (por defecto) indica que el buffer debería descargase cuando esté lleno. Un valor de false, raramente utilizado, indica que se debe lanzar una excepción cuando el buffer se sobrecargue. Un valor de false es ilegal cuando usamos buffer="none".

17


� extends="paquete.superclase". Esto indica la superclase del servletque se va a generar. Debemos usarla con extrema precaución, ya que el servidor podría utilizar una superclase personalizada.

� info="message". Define un string que puede usarse para ser recuperado mediante el método getServletInfo.

� errorPage="url". Especifica una página JSP que se debería procesar si se lanzará cualquier Throwable pero no fuera capturado en la página actual.

� isErrorPage="true|false". Indica si la página actual actúa o no como página de error de otra página JSP. El valor por defecto es false.

� language="java". En algunos momentos, esto está pensado para especificar el lenguaje a utilizar. Por ahora, no debemos precuparnospor él ya que java es tanto el valor por defecto como la única opción legal.

18

Ejemplo JSP2 - TablaHTML

� En el siguiente ejemplo se muestra la construcción en JSP de una tabla de los valores trigonométricos

� Código TablaHTML.jsp: c:\java\JSP2-TablaHTML\TablaHTML\TablaHTML.jsp

� Claves:� <%@ page import="java.io.*,java.text.*,java.util.*" %>

� <%! private static final DecimalFormat FMT1 = new DecimalFormat("#0");%>

� <% for (double gdo = 0; gdo <= 45; gdo += 1.0) { %> …

19

Directiva include

� Directiva include JSP: � <%@ include file="url" %>

� Un fichero del sistema local se incluirá cuando se traduce de JSP a servlet.

� El equivalente XML es: <jsp:directive.include file="url"\>.

� La URL debe ser relativa. � Usamos la acción jsp:include para incluir un fichero en el momento de la petición en vez del momento de la tradución.

20

Comentarios

� Comentario JSP: <%-- comment --%>

� Comentario ignorado cuando se traduce la página JSP en un servlet.

� Si queremos un comentario en el HTML resultante, usamos la síntaxis de comentario normal del HTML <--comment -->.

21

Objetos implícitos en páginas JSP

� Objeto application � Se corresponde con el ServletContextobtenido mediante getServletConfig().getContext().

� Objeto request � HttpServletRequest, objeto proveniente de la petición del cliente o de una redirección

� Objeto response � HttpServletResponse, objeto que representa la respuesta

� Objeto session � HttpSession asociado con el request (si existe una sesión)

� Objeto out � el PrintWriter (una versión con buffer del tipo JspWriter) usada para envíar la salida al cliente (navegador).

22

Convenciones en JSP

� Surge la siguiente cuestión:

� "¿Cómo estructuramos el código JSP para que sea fácil de leer, de escribir y de mantener? “

23

Ficheros y su localización

Tipo de Fichero Extensión Localización Recomendada

JSP .jsp <contexto>/<subsystem path>/

Fragmento JSP .jsp <contexto>/<subsystem path>/

Fragmento JSP .jspf <contexto>/WEB-INF/jspf/<subsystem path>/

CCS .css <contexto>/css/

javascript .js <contexto>/js/

página HTML .html <contexto>/<ruta>/

fuente web .gif, .jpg, etc. <contexto>/images/

TLD .tld <contexto>/WEB-INF/tld/

24

Acceso a base de datos desde JSP

� JSP utiliza JDBC para acceder a base de datos.

� No necesita etiquetas especiales para acceder a base de datos.

25

JSP con el código de acceso a BD incrustado

� Uso de scritplets que utilizan JDBC para acceder a la BD.

� No es necesaria la captura de excepciones, JSP hace el trabajo automáticamente.

� Cuando recuperamos resultados de una consulta aparecerá código HTML dentro del bucle para ir mostrando cada fila.

26

Ejemplo JSP4-JDBC

� Esta aplicación crea una conexión con la base de datos ‘agenda’ y lista todos los contactos de la tabla ‘Contactos’

� MostrarTodos.jsp: � Código: c:\java\JSP4-JDBC\MostrarTodos.jsp

� El driver JDBC de la base de datos tiene que estar incluído en el directorio <contexto>/WEB-INF/lib

� Los scriptlets de Java en este ejemplo están mezclados con el código HTML haciendo difícil el manejo y mantenimiento de esta aplicación

27

Optimización del diseño de las aplicaciones

� Objetivo: separar en capas la lógica de las aplicaciones� Vista: en páginas JSP� Modelo: para el modelo y la lógica de negocio se van a utilizar JavaBeans y clases Java

� A este modelo se le conoce como Modelo 1, y es el primer paso para llegar al modelo MVC

� Más adelante veremos el Modelo 2 que además proporciona el control de la aplicación de forma separada. En ocasiones también denominado MVC

28

Modelo 1: Acceso a través de Beans

� Una forma habitual de utilizar BD con JSP es utilizar componentes JavaBean de apoyo.

� De esta forma mantenemos independiente la presentación y el acceso a datos, esto es fundamental para facilitar el mantenimiento de la aplicación.

29

Introducción a JavaBeans

� ¿Qué es un JavaBean?

� Un JavaBean es una clase Java

� Representa un objeto del modelo, por ejemplo un cliente

� Proporciona métodos para leer y modificar sus variables o atributos

� <tipo> getAtributo () {…}

� void setAtributo (<tipo> valor) {...}

30

Proceso para recuperar datos a través de un JavaBean

� El Bean se encarga de conectar con la BD y ejecutar la sentencia deseada.

� El bean proporciona métodos para posicionarse en cada fila de la consulta.

� A través de las propiedades del JavaBeanpodemos acceder a los valores de cada uno de los campos.

� Las propiedades de un JavaBean se representan muy fácilmente en una página JSP.

31

Acción jsp:useBean

� Acción jsp:useBean� <jsp:useBean at1=val1 at2=val2 …/> � <jsp:useBean atri=val*> ... </jsp:useBean>

� Encuentra o construye un Java Bean. Los posibles atributos son: � id="name" � scope="page|request|session|application" � class="package.class" � type="package.class" � beanName="package.class"

32

Acción jsp:setProperty

� Acción jsp:setProperty: � <jsp:setProperty atrib=val …/>

� Modifica las propiedades del bean, bien directamente o designando el valor que viene desde un parámetro de la petición.

� Los atributos legales son: � name=“nombre del bean" � property=“propiedad del bean|*" � param=“nombre del parámetro" � value=“valor"

33

Acción jsp:getProperty

� Acción jsp:getProperty:

� <jsp:getPropertyname=“nombrePropiedad" value="valor"/>

� Recupera y saca las propiedades del Bean.

34

Ejemplo de utilización de <jsp:useBean>

� Ejemplo de uso:� <jsp:useBean id="pool" scope="application"

class="Clientes.Pool"/>

� En este ejemplo se obtiene o crea el objeto ‘pool’, con ámbito de aplicación y a partir del JavaBean Pool del paquete Clientes

35

Estructura del JavaBean para acceso a BD

� Constructor del JavaBean:� conexión con la base de datos.

� realización de la consulta.

� Guardar resultados en una estructura local al Bean.

� establecer los valores de las propiedades.

� cerrar la conexión.

� Método para recorrer los resultados.� Recargando las propiedades cada vez que cambie.

� Propiedades se corresponden con los campos de la tabla.

36

Ejemplo Modelo 1.JSP5-JDBC-CliPool

� Este ejemplo de aplicación web utiliza un JavaBean y clases Java que permiten recuperar resultados de una BD, usando un pool de conexiones.� Vista: varias páginas JSP

� Modelo: clases Java� BDClientes: realiza las consultas y acciones en la BD

� Cliente: JavaBean que representa el objeto Cliente del modelo

� Pool: Es el objeto que conecta con la base de datos y permite obtener la conexión cuando sea solicitada

37

Ejemplo Modelo 1.JSP5-JDBC-CliPool (2)

� Clase BDClientes, métodos estáticos:� obtenerClientes(): hace la consulta sobre la BD y guarda resultados en un vector interno, para visualizar en JSP.

� obtenerCliente(): crea un objeto cliente a partir de su identificador para pasarlo a la página JSP.

� insertarCliente(): inserta un nuevo cliente dado por el usuario en una página JSP.

� eliminarCliente(): elimina un cliente dado por el usuario en una página JSP.

38

Ejemplo Modelo 1.JSP5-JDBC-CliPool (3)

� Clase Cliente, JavaBean: � Contiene las propiedades de un cliente y los métodos getProp y setProp

� Clase Pool, JavaBean:� Constructor: crea un objeto DataSource para la conexión con la BD ‘agenda’

� getConnection: obtiene una conexión a partir de la asociación de conexiones

� freeConnection: cierra la conexión, devolviéndola a la asociación de conexiones

39

Ejemplo JSP5-JDBC-CliPoolModelo

� Modelo: código de las clases Java:� Clase BDClientes: c:\java\JSP5-JDBC-CliPool\CliPool\WEB-INF\src\Clientes\BDClientes.java

� Clase Cliente: c:\java\JSP5-JDBC-CliPool\CliPool\WEB-INF\src\Clientes\Cliente.java

� Clase Pool: c:\java\JSP5-JDBC-CliPool\CliPool\WEB-INF\src\Clientes\Pool.java

40

Ejemplo JSP5-JDBC-CliPoolVistas (2)

� Vista: código de las páginas JSP� index.jsp: c:\java\JSP5-JDBC-CliPool\CliPool\index.jsp,

presenta el formulario para agregar un contacto de cliente

� InsertarCliente.jsp: c:\java\JSP5-JDBC-CliPool\CliPool\InsertarCliente.jsp, inserta un cliente

� EliminarCliente.jsp: c:\java\JSP5-JDBC-CliPool\CliPool\EliminarCliente.jsp, elimina un cliente

� MostrarClientes.jsp: c:\java\JSP5-JDBC-CliPool\CliPool\MostrarClientes.jsp, muestra los clientes

� VerCliente.jsp: c:\java\JSP5-JDBC-CliPool\CliPool\VerCliente.jsp, visualiza un cliente

41

Ejemplo JSP5-JDBC-CliPoolFicheros de configuración

� web.xml: c:\java\JSP5-JDBC-CliPool\CliPool\WEB-INF\web.xml� Fragmento de código a insertar en server.xml, entre las etiquetas

<Host>

<Context path="/JSP5-JDBC-CliPool" docBase="/JSP5-JDBC-CliPool/CliPool" debug="0" reloadable="true" crossContext="true">

<Resource name="jdbc/dsAgenda"auth="Container"type="javax.sql.DataSource"/>

<ResourceParams name="jdbc/dsAgenda">

…Parametros…

</Context>

42

Ejemplo JSP5-JDBC-CliPoolFicheros de configuración (2)� Parámetros de conexión en server.xml

<parameter><name>username</name><value>curso_java</value>

</parameter><parameter>

<name>password</name><value>curso_java</value>


<name>driverClassName</name><value>oracle.jdbc.driver.OracleDriver</value>


<name>url</name><value>jdbc:oracle:thin:@10.1.1.36:1521:DESA</value>

</parameter></ResourceParams>

43

Limitaciones del Modelo 1

� Tiene cierta separación entre contenido y presentación, por lo que es buena para pequeñasaplicaciones Web.

� El hecho que la lógica de presentación normalmente conduzca a una considerable cantidad de código Java embebido en el JSP en el formato de scriptlets, hace que sea una pesadilla para los desarrolladores Java experimentados el mantenimiento de estos sistemas.

� Fíjate que en el Modelo 1, JSP es responsable de:� Procesar la petición y la respuesta al cliente (lógica de

presentación)� Problema sobretodo para los diseñadores de páginas JSP

que no programan código en Java

44

Arquitectura del Modelo 2

45

Componentes en el Modelo 2

� Se implementa al igual que en el Modelo 1, � la vista con páginas JSP

� el modelo con clases Java o JavaBeans

� En el Modelo 2 además se implementa un sistema de controladores (MVC)� En éste modelo, un controlador maneja las solicitudes del usuario, en lugar de lidiar con otro JSP.

� El controlador o “controller” es implementado como un servlet.

46

Misión del servlet Controlador

� Aquí el servlet actúa como el Controlador y está al cargo

� del procesamiento de las peticiones

� de la creación de cualquier JavaBean u objeto usado por el JSP

� así como, dependiendo de las acciones del usuario, a qué página JSP redirigir la petición

47

Pasos en el Modelo 2

� Los siguientes pasos son ejecutados cuando el usuario envía una solicitud:

1. El servlet Controlador atiende la solicitud.

2. El servlet Controlador instancia el JavaBeans apropiado, basado en los parámetros de la solicitud.

3. El JavaBeans se comunica con la base de datos para retirar los datos requeridos.

4. El Controlador ajusta el JavaBeans resultante, en uno de los siguientes contextos: request, session o aplicación.

5. El Controlador entonces despacha la solicitud a la siguiente vista basado en la URL solicitante.

6. La vista usa el JavaBeans del paso 3, para desplegar los datos.

48

Ejemplo de Modelo 2

� Esta pequeña aplicación ejemplifica el uso del Modelo 2

� Descripción:

� Tienda en Internet de venta de cd’s

� El usuario dispone de un carrito de compra donde se almacenan, usando una sesión, los cd’s que este compra

49

Ejemplo de Modelo 2Componentes

� Los componentes son:

� Modelo: un JavaBean que representa el objeto del negocio CD.java

� Controlador: un servlet ServletCompra.javaque realiza las redirecciones a las vistas y la creación de los Beans necesarios

� Vista: varios ficheros .jsp que permiten al usuario interactuar con la aplicación

50

Ejemplo JSP8-Modelo2

� Modelo: CD.java

� Es una clase java que representa un CD de música con las propiedades siguientes:

� Album, artista, país, precio, cantidad

� Métodos: como en todo JavaBean se proporcionan los métodos getXXX y setXXX

� Código: c:\java\JSP8-Modelo2\WEB-INF\src\shopping\cd.java

51


� Controlador: ServletCompra.java

� Comprueba la acción a realizar

� Realiza la acción insertando los valores necesarios en la sesión, si existe

� Redirige la salida a la vista adecuada

52


� Funcionamiento del controlador ServletCompra.java:� Acción ‘Agregar’: Añade el cd seleccionado a la sesión y redirige la salida a Tienda.jsp

� Acción ‘Borrar’: Borra el cd seleccionado de la sesión y redirige a Tienda.jsp

� Acción ‘Comprar’: Calcula el total y redirige a Comprar.jsp

� Código: c:\java\JSP8-Modelo2\WEB-INF\src\ServletCompra.java

53


� Vistas: son las páginas JSP� Tienda.jsp: página de entrada, muestra el catálogo de CD’s disponibles

� c:\java\JSP8-Modelo2\Tienda.jsp

� Carrito.jsp: esta página se incluye en la anterior y muestra los cd’s que el usuario ha ido metiendo en el carrito

� c:\java\JSP8-Modelo2\Carrito.jsp

� Comprar.jsp: muestra el contenido del carrito y el total a pagar cerrando la sesión

54

Ventajas del Modelo 2

� Como no hay lógica de presentación en el JSP, no hay necesidad de demasiados scriptlets.

� Se pueden tener múltiples controladores en la aplicación Web, � aunque normalmente, se suele usar 1 solo.

� Las aplicaciones Web son más sencillas de mantener y extender, ya que las vistas no refieren unas a otras, y no hay lógica de presentación en ellas.

55

Acción jsp:include

� Acción jsp:include: � <jsp:include page="relative URL" flush="true"/>

� Incluye un fichero en el momento en que la página es solicitada.

� Aviso: en algunos servidores, el fichero incluido debe ser un fichero HTML o JSP, según determine el servidor (normalmente basado en la extensión del fichero).

56

Acción jsp:forward

� Acción jsp:forward

� <jsp:forward page="URL relativa"/>

� Reenvía la petición a otra página.

57

Acción jsp:plugin

� Acción jsp:plugin:

� <jsp:plugin attribute="value"*> ... </jsp:plugin>

� Genera etiquetas OBJECT o EMBED, apropiadas al tipo de navegador, pidiendo que se ejecute un appletusando el Java Plugin.

58

Tags personalizadas

� En las páginas JSP se usa código HTML, XML, Java e incluso se usan etiquetas que encapsulan parte de la lógica.

� El uso de la etiqueta <jsp:useBean> en conjunción con los JavaBeans hace que podamos separar la lógica de presentación de la de proceso y � consigue unos archivos JSP mas claros,

� y lo que es mas importante, el que escribe la JSP, no tiene por que tener unos conocimientos avanzados de programación para crear páginas JSP de funcionalidades avanzadas.

59

Tipos de etiquetas

� Hay dos tipos principales de etiquetas,

� etiquetas que no tienen cuerpo. Ejemplo: <img src=“canteras.gif”>

� etiquetas que si lo tienen. Ejemplo: <title>Las Canteras</title> que tiene cuerpo y etiqueta de final.

� Estos son dos tipos de etiquetas que podemos crear en Java

60

Etiquetas personalizadas JSP

� JSP sigue una sintáxis XML por lo tanto� Etiquetas sin cuerpo: <jsp:etiqueta/>

� Etiquetas con cuerpo: <jsp:etiqueta> … </jsp:etiqueta>

� Para crear etiquetas a medida debemos implementar o heredar de otras clases� Interface Tag interface general

� Clase TagSupport creación de etiquetas sin cuerpo

� Clase BodyTagSupport creación de etiquetas con cuerpo

� En los ejemplos siguientes trabajaremos extendiendo la clase TagSupport y BodyTagSupport que son simplificaciones del interface Tag

61

Clase TagSupport

� Las clase TagSupport suministra una serie de métodos que sobreescribiremos para crear una etiqueta. Estos son algunos:� doStartTag(): se invoca cuando se encuentra la etiqueta de apertura

� doEndTag(): se invoca cuando se encuentra la etiqueta de cierre

� doAfterBody(): se invoca una vez se ha obtenido el contenido del cuerpo, cuando éste existe

62

Primer ejemplo JSP6-HolaMundoTag

� Diseñaremos una etiqueta sin cuerpo que escribirá el mensaje “Hola Mundo” en el cliente: � <JSP6:holamundo/>

� Siguiendo la sintáxis XML, de documentos bien formateados

� Código y configuración:� Clase de la etiqueta: c:\java\JSP6-HolaMundoTag\WEB-INF\src\ejemplos\HolaMundoTag.java

63

JSP6-HolaMundoTag

� Ficheros de configuración:

� Definir el descriptor de librería de etiquetas (Tag Library Descriptor) o TLD, en este caso JSP6.tld: c:\java\JSP6-HolaMundoTag\WEB-INF\JSP6.tld

� web.xml: c:\java\JSP6-HolaMundoTag\WEB-INF\web.xml

64

Tag Library Descriptor (TLD)JSP6.tld

� Este fichero de configuración, situado en <contexto>/WEB-INF, describe el formato del conjunto de las etiquetas una librería.

� En este caso la librería recibe el nombre de ‘JSP6’ y describe una etiqueta de nombre ‘holamundo’

<tag>

<name>holamundo</name> <tagclass>HolaMundoTag</tagclass> <bodycontent>empty</bodycontent> <info>Saludo</info>

</tag>

65

JSP6-HolaMundoweb.xml

� El descriptor de despliegue de la aplicación JSP6-HolaMundo: web.xml

� Asigna un uri a la localización de la librería, para poder referirnos a ella en las páginas JSP, en este caso mediante el uri = ‘/JSP6’

<taglib><taglib-uri>/JSP6</taglib-uri><taglib-location>/WEB-INF/JSP6.tld</taglib-location>

</taglib>

66

JSP6-HolaMundoHolaMundo.jsp

� HolaMundo.jsp: c:\java\JSP6-HolaMundoTag\HolaMundo.jsp

<%@ taglib uri="/JSP6" prefix="JSP6" %><HTML><HEAD>

<TITLE>Tag Hola Mundo</TITLE></HEAD><JSP6:holamundo/></BODY></HTML>

67

Página HolaMundo.jspDirectiva taglib

� Una directiva taglib declara las librerías de etiquetas usadas por el JSP. Un 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=“/JSP6" prefix=“JSP6" %>, en este ejemplo� Sólo deberíamos importar librerías de etiquetas que

realmente se van a utilizar en la página JSP.

� Desde JSP 1.2, esta altamente recomendado utilizar la JSP Standard Tag Library en nuestra aplicación web para reducir la necesidad de scriptlets JSP en nuestras páginas. Las páginas que usan JSTL son, en general, más fáciles de leer y de mantener.

68

Constantes de las etiquetas personalizadas

� SKIP_BODY : indica en el método que la etiqueta no tiene cuerpo o que no quiere seguir evaluándolo

� EVAL_PAGE : indica en el método doEndTag() que se procede a evaluar el resto de la página JSP

� SKIP_PAGE : indica que no se siga evaluando la página JSP

� EVAL_BODY_AGAIN: indica que se vuelva a evaluar el cuerpo, en caso de bucles

69

Etiquetas personalizadas con parámetros

� Vamos a ver una etiqueta con parámetros del tipo� <JSP6:suma num1=2 num2=3/>, que suma los números 2+3

� Por cada parámetro que queremos que soporte la etiqueta, se proporciona un método set como en un javabean

� El código de la clase SumaTag lo veremos a continuación

70

SumaTag.java

� Esta etiqueta no tiene cuerpo por lo que seráigual que la anterior excepto que se añaden los métodos set

� Código: c:\java\JSP6-HolaMundoTag\WEB-INF\src\ejemplos\SumaTag.java

� Mediante los métodos set los valores de los parámetros son cargados automáticamente en la clase

71

Modificación del Tag LibraryDescriptor (TLD)

� JSP6.tld: c:\java\JSP6-HolaMundoTag\WEB-INF\JSP6.tld

� Uso de etiquetas para describir parámetros:<attribute>

<name>num1</name> <required>true</required> <rtexprvalue>false</rtexprvalue> </attribute>

</attribute>

� <rtextprvalue> indica si tiene o no que ser evaluada en tiempo de ejecución

72

Etiquetas personalizadas con cuerpo

� Vamos a crear una etiqueta con cuerpo y parámetro que realice un bucle.

<JSP7:bucle veces=“7”>

<JSP7:holamundo/> � cuerpo

</JSP7:bucle>

� La clase BucleTag extenderá la clase BodyTagSupport

73

Ejemplo JSP7-BucleTag

� BucleTag.java :c:\java\JSP7-BucleTag\WEB-INF\src\ejemplos\BucleTag.java

� JSP7.tld: c:\java\JSP7-BucleTag\WEB-INF\JSP7.tld� <bodycontent>JSP</bodycontent>� Indica que el contenido del cuerpo puede ser HTML, texto o etiquetas JSP

� Bucle.jsp: c:\java\JSP7-BucleTag\Bucle.jsp� web.xml: c:\java\JSP7-BucleTag\WEB-INF\web.xml

4. Curso Java JSP (Java Server Pages) - Curso 2005-2006

Education

Transcript of 4. Curso Java JSP (Java Server Pages) - Curso 2005-2006