1
Download Java Server Pages JSP
Document related concepts
no text concepts found
Transcript
Java Server Pages JSP
Otra forma de hacer servlets
Las JSP
• Son páginas HTML a las que se le inserta
código que produce servlets
• Se usan cuando la parte estática de la página
que se debe generar es relativamente
importante (la parte que no cambia)
• Al cargarse una página JSP esta se compila,
se genera el servlet y se ejecuta
• Por esto, la primera invocación a una JSP
demora más que las siguientes
Contenido de una JSP
• Una JSP, aparte de código HTML puede
contener 3 tipos de constructos :
– Elementos de scripting: son los elementos que
definen el comportamiento dinámico del
servlet, es decir su código
– directivas: afectan la estructira general del
servlet que resulta de la JSP
– acciones: permiten redirigir el request a otra
instancia JSP, servlet o página HTML
Elementos de scripting
• 1. Expresiones de la forma <%= expresión %>,
son evaluadas e insertadas en el output del
servlet
• 2. Scriptlets de la forma <% code %>, que son
insertadas en el método _jspService el cual es
el método llamado cuando se contacta a la
página jsp
• 3. Declaraciones de la forma <%! code %>,
que son insertadas en el cuerpo de la clase del
servlet, fuera de todo método, definiendo así
variables de instancia
Variables predefinidas
• Para simplificar las expresiones, existen
variables predefinidas que se pueden usar. Las
más importantes son:
–
–
–
–
request, el HttpServletRequest
response, el HttpServletResponse
session, el HttpSession asociada al request
out, el PrintWriter usado para mandar output al
cliente
Un Ejemplo (Ejemplo1.jsp)
<HTML>
<HEAD>
<TITLE>JSP Expressions</TITLE>
</HEAD>
<BODY>
<H2>JSP Expressions</H2>
<UL>
<LI>Current time: <%= new java.util.Date() %>
<LI>Your hostname: <%= request.getRemoteHost() %>
<LI>Your session ID: <%= session.getId() %>
<LI>The <CODE>testParam</CODE> form parameter:
<%= request.getParameter("testParam") %>
</UL>
</BODY>
</HTML>
Explicaciones
• El servidor crea un servlet, lo compila y llama al
método _jspService que contiene todas las sentencias
escritas entre <% y %>
• El texto HTML es mandado al cliente por vía
out.print(....)
• Las expresiones se evalúan y se insertan en el texto
que se manda, por lo cual la expresión
<LI>Current time: <%= new java.util.Date() %>
equivaldría en un servlet a hacer
out.println(“<LI>Current time: “+ new java.util.Date() );
Scriptlets
• Si se quiere hacer algo más complicado que insertar una
simple expresión en el output del servlet se pueden incluir
sentencias JAVA en scriptlets que tienen la siguiente
estructura:
<%String queryData = request.getQueryString();
out.println("Attached GET data: " + queryData); %>
• Los Scriptlets tienene acceso a a las mismas
variables definidas automáticamente a las que tienen
acceso las expresiones
• En particular, esto también se pudo haber logrado
con
Attached GET data: <%= request.getQueryString() %>
pero hay cosas que no se pueden hacer con expresiones:
<% response.setContentType("text/plain"); %>
Algo más serio (Ejemplo2.jsp)
<HTML> <HEAD> <TITLE>Color Testing</TITLE> </HEAD>
<% String bgColor = request.getParameter("bgColor");
boolean hasExplicitColor;
if (bgColor != null) {
hasExplicitColor = true;
} else {
hasExplicitColor = false;
bgColor = "WHITE";
} %>
<BODY BGCOLOR="<%= bgColor %>">
<H2 ALIGN="CENTER">Color Testing</H2>
<% if (hasExplicitColor)
out.println("You supplied color " +bgColor );
else
out.println("Using background color WHITE..");
%>
Usando Scriptlets para hacer
partes del archivo JSP
condicional
Para entender esto hay que tener claro que el contenido de un
scriptlet se incluye exactamente como está escrito al método
_jspService y las sentencias HTML se traducen como un
out.println(...contenido de sentencia HTML...) en el mismo
orden en que aparecen en la página jsp
Scriptlets para hacer partes del
archivo JSP condicional
Por lo tanto, lo siguiente
<% if (Math.random() < 0.5) { %>
Have a <B>nice</B> day!
<% } else { %>
Have a <B>lousy</B> day!
<% } %>
se traduce en
if (Math.random() < 0.5) {
out.println(“Have a <B>nice</B> day!”);
} else {
out.println(“Have a <B>lousy</B> day! “);
}
El equivalente en XML
El código equivalente para declarar scriptles pero siguiendo
las reglas XML de <% Code %> es
<jsp:scriptlet>
Code
</jsp:scriptlet>
Esta forma de incluir sentencias jsp en la página HTML es
muy recurrente, más adelante veremos otros
jsp:setProperty: para definir propiedades a un
bean
jsp:include: para incluir otros archivos
jsp:forward: para redirigir el request
jsp:param: para definir parámetros a applets
Deaclaraciones
• No generan output, se usan para eclarar variables
que más tarde serán usadas en expresiones o
scriptlets
• Una declaración tiene la siguiente forma:
<%! Java Code %>
Un ejemplo (Ejemplo3.jsp) que cuenta cuantas veces
ha sido accesada una página desde que se cargó:
<%! private int accessCount = 0; %>
Accesses to page since server reboot:
<%= ++accessCount %>
El equivalente en XML
El código equivalente para declaraciones pero siguiendo las
reglas XML de <%! Code %> es
<jsp:declaration>
Code
</jsp:declaration>
Directivas
• Afectan la estructura general del servlet
generado
• Existen 3 tipos de directivas: page, include
y taglib
<%@ directiva atributo="valor" %>
<%@ directiva atributo1="valor1"
atributo2="valor2"
...
atributoN="valorN" %>
Directiva page
• Permite controlar la estructura del servlet
importando clases, afinando la superclase,
definiendo el tipo de contenido a enviar, etc.
• Esto se hace definiendo uno o más de los
siguientes atributos:
– import, contentType, isThreadSafe, session,
buffer, autoflush, extends, info, errorPage,
isErrorPage y language.
• Veremos import, contentType, errorPage e
isErrorPage
El atributo import
• Permite importar clases que no se incluyen
automáticamente
• Por ejemplo, se pueden importar las usuales para java
(java.util.*)
• Para las clases definidas por el programador, estas deben
estar en un lugar “visible”. Este lugar depende del servidor
• En tomcat es el mismo directorio en donde están los
servlets (Ejemplo4.jsp con ServletUtilities.java y
LongLivedCookie.java)
<%@ page import=”java.util.*" %>
<%@ page import="package.class1,...,
package.classN" %>
Controlando el tipo de salida
• Se hace a través de la directiva
<%@ page contetType=”text/plain" %>
• Se puede usar para determinar cualquier tipo de salida que
no sea text/html
• Puede ir en cualquier parte del archivo, a pesar de que en
un servlet esto debe ir antes de mandar cualquier cosa. Esto
es porque primero la página se compila, traduce y luego se
ejecuta en el orden adecuado de las directivas
<HTML>
<BODY>
<H2>The contentType Attribute</H2>
<%@ page contentType="text/plain" %>
Esto debe verse como texto plano <B>no</B> como HTML.
</BODY>
</HTML>
Generando salida para excel
• Se hace a través de la misma directiva pero cambiando el tipo
de salida que se generará (ejemplo5.jsp)
<%@ page contentType="application/vnd.ms-excel" %>
<%- entre columnas poner tabs, no espacios.-%>
1997 1998 1999 2000 2001 (Anticipated)
12.3 13.4 14.5 15.6 16.7
• Tambien se puede lograr lo mismo escribiendo código HTML
para generar una tabla pero poner en la directiva que el
contentType es ms-excel (ejemplo6.jsp)
<TABLE BORDER=1>
<TR><TH></TH><TH>Apples<TH>Oranges
<TR><TH>First Quarter<TD>2307<TD>4706
<TR><TH>Second Quarter<TD>2982<TD>5104
<TR><TH>Third Quarter<TD>3011<TD>5220
<TR><TH>Fourth Quarter<TD>3055<TD>5287
</TABLE>
errorPage & isErrorPage
• Es posible invocar una determinada página cuando en otra
sucede un error (se lanza una Exception )
• Para ello hay que poner en la página que puede generar el ellror
la directiva
<%@ page errorPage=”una_URL_relativa" %>
• En la página que debe recibir el control (una_URL_relativa)
debe ponerse lo siguiente
<%@ page isErrorPage="true" %>
(ver generaError.jsp y muestraError.jsp)
Incluyendo otros archivos
• Es posible hacerlo al momento en que se compila la página con
la directiva
<%@ include file=”nombre del archivo" %>
• Esto implica que se incluirá el archivo referenciado como parte
del actual antes de compilarlo
• El problema es que si el archivo referenciado cambia, no
cambiará en la página que se muestra (a menos que se reinicie
el servidor) (ver contacto.jsp y pprincipal.jsp)
• Se puede hacer que cada vz que se referencie la página incluida
se vuelva a recargar el contenido con la siguiente directiva
<jsp:include page=”nombre del archivo" flush="true"
/>
(ver noticias.jsp e item1.html, item2.html, item3.html)
Incluyendo Applets
• Con JSP es posible poner applets en una pagina web pero que
son interpretadas por un plugin y no por el browser
• Esto soluciona muchos problemas de versionamiento, ya que no
todos los prowsers son capaces de interpretar applets
compilados con una version de Java maor que 1.1.x
• El elemento jsp:plugin instruye al server para que construya un
plugin apropiado para interpretar el objeto.
<jsp:plugin type="applet" code="Clock2.class" codebase="/directorio_relativo"
jreversion="1.2" width="160" height="150" >
<jsp:fallback>
Plugin tag OBJECT or EMBED not supported by browser.
</jsp:fallback>
</jsp:plugin>
• Ver ejemplo plugin de tomcat
Java Beans
• Usar Beans es una buena manera de complementar JSP cuando
se requiere de estructuras de datos (clases) que hagan cosas más
complejas, y separar el código de programación de estas clases
de la JSP
• Un Bean es una clase con las siguientes características:
– Tiene un constructor que no tiene parámetros
– No tiene variables públicas
– Para cierto subconjunto de variables privadas llamadas propiedades, si la
variable es de tipo tipo1 y se llama variable1entonces existe un método
programado tipo1 getVariable1() que retorna el valor actual de la propiedad y
otro void setVariable1(tipo1 x) que modifica el valor de la variable con el que
está dado como parámetro
Usando Beans en JSP
• Para poder usar Beans con JSP en Tomcat estos deben ir en el
mismo directorio que los servlets
• Creación
– <jsp:useBean id=’bean1' class=’Nombre_Clase' scope=“validez”/>
• Es lo mismo que haber hecho en un programa Java
– Nombre_Clase bean1 = new Nombre_Clase();
• Obtención de valores
– <jsp:getProperty name=”bean1" property=”variable1" />
– <%= book1.getVariable1() %>
• Modificación valores
– <jsp:setProperty name=”bean1” property=”variable1” value=”valor1" />
– <% book1.setVariable1(”valor1"); %>
Ejemplos JSP
• Ver Date.jsp usa las sentencias jsp:getProperty
• Numberguess.jsp usa los métodos set y get (y otros)
directamente
• Carts.jsp implementa un “carrito de compras”
• forward.jsp muestra como se puede derivar el request a otra
página
