JSP(I) - Aula Virtual
Anuncio
JSP (I)
Aplicaciones Distribuidas
Contenido
•
Limitación Modelo Servlets
•
Etiquetas de Extensión
•
Definición.
•
Estructura
•
Elementos de Script
•
Modelo Básico de Programación.
•
Ejemplo.
•
Librería de etiquetas
•
Uso.
•
Modelo Extendido de Programación.
•
Iteraciones.
•
Anidamiento.
•
Etiquetas: conclusiones
•
•
•
•
Expresiones y declaraciones.
Directivas.
JavaBeans.
Otros aspectos de interés
2
Limitación Modelo
Servlets
•
Motivación:
• Las aplicaciones web se construyen sin conocer al usuario final.
• Cambios frecuentes
•
Problema:
• La generación del interfaz HTML se realiza utilizando código
Java out.println(“...”)
• No podemos usar editores HTML.
• Costoso tener diseñadores gráficos con conocimientos Java.
•
Consecuencia:
• El mantenimiento (evolución) de la aplicación está limitado.
3
Limitación Modelo
Servlets JSP
•
Objetivo:
• Separación roles: Diseñador Gráfico y Desarrollador.
• Nuevo modelo de desarrollo de contenidos dinámicos en el que
la lógica de la aplicación se encapsule en componentes
portables y reutilizables.
•
Solución: JSP
(Java Server Pages)
• “Una página HTML normal que puede incluir scripts para
generar HTML dinámicamente”.
• En general, puede generar cualquier tipo de contenido dinámico:
XML, WML, etc.
• Código script, por defecto Java (scriptlets).
4
Ciclo de vida
• No representan una nueva tecnología:
• Semánticamente equivalen a los servlets.
• Sólo facilitan el desarrollo y mantenimiento.
• Ciclo de vida:
• El contenedor de servlets traduce la página JSP a su
equivalente servlet la primera vez que se accede.
• El servlet es compilado y cargado en memoria siguiendo
su ciclo de vida convencional.
• Si la página es modificada, el contenedor detecta el
cambio y vuelve a repetir el proceso.
• Ventaja: no se hace necesario reiniciar el servidor
Web.
5
Ejemplo
<html>
<body>
<jsp:useBean id="cliente" class="Cliente" scope="session">
<form method="POST" action=“clienteActualizacion.ctrl">
<p><b> Nombre: <input type="text" name="nombre" size="39"
value="<jsp:getProperty name=\"cliente\" property=\"nombre\“/>">
NIF:<input type="text" name="nif" size="12"
value="<jsp:getProperty name=\"cliente\" property=\"nif\“/>">
...
</form>
</body>
</html>
6
Elementos de Script
•
Incluir código Java:
• <% ... %>
•
Objetos implícitos:
• request, response, out, session, application, config, ...
•
Durante la traducción el código se inserta en el mismo orden
• Podemos usar declaraciones anteriores.
•
No es necesario que el código contenga sentencias completas en
Java:
<% if (session.getAttribute(“accesos”) == null) { %>
<B>Bienvenido a nuestra web</B>
<% } %>
7
Expresiones y
Declaraciones
•
Expresiones:
• <%= ... %>
• Evalúa la expresión en tiempo de ejecución, la convierte a String
y la saca por la salida.
• Equivale a: out.println(“...”);
• Ejemplos:
• <%= request.getParameter(“Nombre”) %>
• <%= i++ %>
•
Declaraciones:
• <%! ... %>
• Declarar métodos y atributos:
• <%! private int numeroAccesos; %>
8
Directivas
•
<%@ ... %>
•
Afectan a la estructura de la clase del Servlet.
•
Directiva page: <%@ page ...
• import: paquetes y clases separados por comas
• <%@ page import=“java.util.*” %>
• contentType:
• <%@ page contentType=“text/xml” %>
• errorPage: página que trata las excepciones no capturadas
• <%@ page errorPage=“error.jsp” %>
• isErrorPage: indica si actúa como página de error
• <%@ page isErrorPage=“true” %>
• ...
•
Directiva include: <%@ include file=“URL” %>
• Incluye código JSP en el momento de la traducción.
9
JavaBeans
•
Componentes Java reutilizables.
•
Se utilizan para facilitar el acceso a los objetos Java.
•
Están caracterizados por un conjunto de propiedades y de eventos que
disparan.
• Ejemplo: componentes AWT/Swing en programación gráfica.
•
Se definen siguiendo unas guías de estilo:
• En JSP sólo nos interesan las propiedades.
•
Declaración:
• Clase serializable con un constructor público sin argumentos.
• Un propiedad ab tendrá métodos de acceso y/o modificación
•
public Tipo getAb() y public void setAb(Tipo valor)
•
Multivaluada: public Tipo[] getAb() y public void setAb(Tipo[])
• Tipo: tipos básicos o String.
10
JavaBeans - Declaración
•
Manejamos los javabeans haciendo uso de acciones estándares
JSP.
•
Declaración:
• <jsp:useBean id=“carro” class=“portal.CarroCompra”
scope=“session” />
portal.CarroCompra carro = new portal.CarroCompra();
session.setAttribute(“carro”, carro);
• scope: indica dónde se guarda el objeto
•
•
•
•
page: equivalente a una variable local
request
session
application
11
JavaBeans - Propiedades
•
Establecimiento de propiedades:
• <jsp:setProperty name=“carro” property=“...” value= “...” />
• name ha de coincidir con el id de la declaración.
• Sin value: toma el valor de un parámetro de la petición cuyo
nombre sea igual a la propiedad.
• property=“*”: establece las propiedades del bean cuyo nombre
coincida con algún parámetro de la petición.
• Para asignar un parámetro concreto: param=“...”
•
Recuperación de propiedades.
• <jsp:getProperty name=“carro” property=“...” />
• Recupera la propiedad y la inserta en la salida.
12
Otros aspectos de interés
•
Acción forward:
• <jsp:forward page=“URL” />
• Equivalente al forward de RequestDispatcher.
•
Acción include:
<jsp:include page=“URL” flush=“true”>
<jsp:param name=“login” value=“Marcos” />
</jsp:include>
• Equivalente al include de RequestDispatcher.
•
En cualquier caso, la URL puede ser un valor calculado mediante una
expresión.
•
Comentarios:
• <%-- comentario --%>
13
Etiquetas de Extensión
•
Alternativa a los JavaBeans para encapsular la lógica de negocio.
•
Limitaciones JavaBeans:
• Ejecución de métodos: uso de scriptlets.
• Dificultad para acceder al contexto de la página (petición,
sesión, etc.)
•
Objetivos:
• Disponer del concepto de “componente” para la edición de
páginas Web Disponible en una paleta
• Ejecutar la lógica de negocio de un modo declarativo.
•
Ejemplo:
• <jsp:forward page=“error.jsp” />
14
Estructura
•
Otro ejemplo:
<ad:enlace URL=“index.jsp” texto=“Inicio” />
•
Una etiqueta se identifica por un prefijo (“ad”) y por un sufijo (“enlace”).
•
Puede tener parámetros al estilo XML (“URL”).
•
Las etiquetas pueden tener cuerpo (body).
•
También puede tener etiquetas anidadas.
•
•
Ejemplo: “jsp:param” en la etiqueta “jsp:include”.
Las etiquetas se organizan en librerías (TagLib)
•
Contiene información sobre las etiquetas.
•
Necesaria para el contenedor y las herramientas de edición.
15
Modelo de Programación: Interface Tag
j:Pagina JSP
•
int doStartTag()
t : Tag
setPageContext(PageContext)
• EVAL_BODY_INCLUDE
• SKIP_BODY
setParent(Tag)
•
int doEndTag()
setAtributo1( )
• EVAL_PAGE
• SKIP_PAGE
setAtributo2( )
•
•
void setParent(Tag)
• Tag getParent()
doStartTag()
PageContext:
doEndTag( )
• Acceso a los objetos implícitos
• getOut(), getRequest(), …
•
release( )
Clase de apoyo: TagSupport
16
Ejemplo de Etiqueta
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
public class EnlaceTag extends TagSupport
{
...
public void setURL(String url) {
this.url = url;
}
...
public int doEndTag() throws JspTagException {
try {
HttpServletResponse respuesta =
(HttpServletResponse) pageContext.getResponse();
pageContext.getOut().write("<a href=\""
+ respuesta.encodeURL(url) + "\">" + texto + "</a>");
} catch (java.io.IOException e) {
throw new JspTagException(e.getMessage());
}
return EVAL_PAGE;
}
}
17
Librería de Etiquetas
<taglib>
<tlibversion>1.0</tlibversion>
<jspversion>1.1</jspversion>
<shortname>ad</shortname>
<info> Libreria de etiquetas de AD</info>
<tag>
<name>enlace</name>
<tagclass>EnlaceTag</tagclass>
<bodycontent>JSP</bodycontent>
<info>Crea un enlace con reescritura de URL</info>
<attribute>
<name>URL</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
<attribute>
<name>texto</name>
<required>true</required>
<rtexprvalue>true</rtexprvalue>
</attribute>
</tag>
...
18
Uso de una etiqueta
• Para utilizar una librería hay que declararla en el descriptor
de la aplicación (web.xml):
<taglib>
<taglib-uri>/ad</taglib-uri>
<taglib-location>/WEB-INF/tlds/ad.tld</taglib-location>
</taglib>
• Para hacer uso de ella en la página JSP usamos una
directiva:
<%@ taglib uri=”/ad" prefix=“ad" %>
19
Cuerpo de la Etiqueta
•
Motivación: Iteraciones
• Ejemplo: Listar Usuarios registrados
<ad:listaUsuarios usuarios="<%= usuarios %>“ >
<b><%= identificador %> <%= nombre %></b>
</aadd:listaUsuarios>
•
El manejador debe controlar:
• El número de veces que se evaluará el cuerpo.
• Las nuevas variables que ofrece a la página.
•
Extensión del modelo de programación:
• Interface BodyTag
• Clase de apoyo: BodyTagSupport
20
Modelo de Programación – Interface
BodyTag
j:Página JSP
•
t :BodyTag
pc : PageContext
BodyContent:
• Acceso al cuerpo de la etiqueta.
doStartTag()
• getString()
pushBody()
• getEnclosingWriter()
setBodyContent(BodyContent)
• clearBody()
doInitBody( )
doAfterBody( )
Iteración
•
void doInitBody()
doAfterBody( )
popBody( )
•
doEndTag( )
int doAfterBody()
• EVAL_BODY_TAG
• SKIP_BODY
21
Ejemplo de Iteración
public int doAfterBody() throws JspTagException {
BodyContent bodyContent = getBodyContent();
if (bodyContent != null) {
try {
bodyContent.getEnclosingWriter().print(bodyContent.getString());
bodyContent.clearBody();
} catch (Exception e) {
throw new JspTagException(e.getMessage());
}
}
if (it.hasNext()) {
Cliente c = (Cliente) it.next();
pageContext.setAttribute("identificador", c.getUsuario());
pageContext.setAttribute("nombre", c.getNombre());
return EVAL_BODY_TAG;
} else
return SKIP_BODY;
}
22
Declaración de Variables
• Si una etiqueta ofrece objetos a la página, debe
declararlos con una clase TagExtraInfo:
import javax.servlet.jsp.tagext.*;
public class VarUsuariosTagTEI extends TagExtraInfo
{
public VariableInfo[] getVariableInfo(TagData data) {
return new VariableInfo[] {
new VariableInfo("identificador", "java.lang.String", true, VariableInfo.NESTED),
new VariableInfo("nombre", "java.lang.String", true, VariableInfo.NESTED) };
}
}
• Declaración de la clase dentro de la librería:
<tag>
<name>listaUsuarios</name>
<tagclass>UsuariosTag</tagclass>
<teiclass>VarUsuariosTagTEI</teiclass>
...
23
Anidamiento de Etiquetas
•
Motivación:
• Una etiqueta puede acceder al contexto proporcionado por otra etiqueta:
colaboración.
•
Relaciones entre etiquetas usando interfaces Java (tipos)
public interface EtiquetaCliente
{
Cliente getCliente();
}
•
Localizar etiqueta envolvente:
EtiquetaCliente etiquetaCliente =
(EtiquetaCliente)TagSupport.findAncestorWithClass(
this, EtiquetaCliente.class);
24
Etiquetas - Conclusiones
•
Usos habituales:
• Generación de código HTML: poco recomendable.
• Exponer datos complejos: listas, tablas, árboles.
• Manejar iteraciones.
•
Consejos de uso:
• Definir etiquetas configurables utilizando atributos: reutilización.
• Evitar código HTML en el manejador.
• No romper el flujo del procesamiento: evitar redirecciones.
•
JSP Standard Tag Library (JSTL).
• http://jstl.java.net/
•
Otras librerías de etiquetas:
• Jakarta: http://jakarta.apache.org/taglibs/
25
