Desarrollo Web Integrado
Fecha:
Objetivos
Al finalizar la sesión el
estudiante:
Es capaz de aplicar los
fundamentos de las Java
Server Pages
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 ([Link])
<HTML>
<HEAD>
<TITLE>JSP Expressions</TITLE>
</HEAD>
<BODY>
<H2>JSP Expressions</H2>
<UL>
<LI>Current time: <%= new [Link]() %>
<LI>Your hostname: <%= [Link]() %>
<LI>Your session ID: <%= [Link]() %>
<LI>The <CODE>testParam</CODE> form parameter:
<%= [Link]("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
[Link](....)
• Las expresiones se evalúan y se insertan en el texto
que se manda, por lo cual la expresión
<LI>Current time: <%= new [Link]() %>
equivaldría en un servlet a hacer
[Link](“<LI>Current time: “+ new [Link]() );
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 = [Link]();
[Link]("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: <%= [Link]() %>
pero hay cosas que no se pueden hacer con expresiones:
<% [Link]("text/plain"); %>
Algo más serio ([Link])
<HTML> <HEAD> <TITLE>Color Testing</TITLE> </HEAD>
<% String bgColor = [Link]("bgColor");
boolean hasExplicitColor;
if (bgColor != null) {
hasExplicitColor = true;
} else {
hasExplicitColor = false;
bgColor = "WHITE";
} %>
<BODY BGCOLOR="<%= bgColor %>">
<H2 ALIGN="CENTER">Color Testing</H2>
<% if (hasExplicitColor)
[Link]("You supplied color " +bgColor );
else
[Link]("Using background color WHITE.."); %>
</BODY> </HTML>
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 [Link](...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 ([Link]() < 0.5) { %>
Have a <B>nice</B> day!
<% } else { %>
Have a <B>lousy</B> day!
<% } %>
se traduce en
if ([Link]() < 0.5) {
[Link](“Have a <B>nice</B> day!”);
} else {
[Link](“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 ([Link]) 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
</jspdeclaration>
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
([Link].*)
• 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
([Link] con [Link] y [Link])
<%@ page import=”[Link].*" %>
<%@ page import="package.class1,...,
[Link]" %>
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á ([Link])
<%@ page contentType="application/[Link]-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
([Link])
<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 [Link] y [Link])
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
[Link] y [Link])
• 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 [Link] e [Link], [Link], [Link])
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="[Link]" 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 [Link] usa las sentencias jsp:getProperty
• [Link] usa los métodos set y get (y otros)
directamente
• [Link] implementa un “carrito de compras”
• [Link] muestra como se puede derivar el request a otra
página
