Tema 11

Introducción
Aplicación web:
9 Aplicación que se ejecuta en al menos un servidor y a la que
el usuario accede desde un cliente de propósito general
Curso de Java
(navegador en un PC, teléfono WAP, etcétera).
La comunicación en la Web gira entorno al protocolo HTTP.
9 Protocolo de nivel de aplicación.
9 Funciona sobre TCP (puerto 80 por defecto).
9 Modelo petición/respuesta.
Java Server Pages (JSP) 9 No tiene estado.
El lenguaje Java — Tema 11 — JSP

Luis Hernández Yáñez
Curso de Java Tema 11 – JSP - 1
Carlos Cervigón Rückauer
HTTP HTTP
Tipos de peticiones: El navegador responde con:

GET, POST, PUT, DELETE, TRACE, OPTIONS, HEAD. HTTP/1.0 200 OK
<< Otros campos >>
Las dos tipos de peticiones más relevantes en aplicaciones web Content-Type=text/html; ISO-8859-1
son GET y POST. << Otros campos >>
Ejemplo de GET: <html>
<< Resto del contenido de la página de carlos >>
Utilizamos un navegador para acceder a </html>
http://www.sip.ucm.es/~carlos/index.html
Parámetros en peticiones GET: cadenas de consulta.
El navegador abre una conexión TCP al puerto 80 de la
URL?par1=val1&par2=val2 ... &parN=valN
máquina www.sip.ucm.es (resuelve el nombre por DNS)
y envía una petición similar a: Ejemplo en una página HTML:
GET /~carlos/index.html HTTP/1.0 ...
<a href="/forecast?city=Hermosa+Beach&state=CA">
<< Otros campos >>
Temperatura en Hermosa Beach
</a>...
Luis Hernández Yáñez Luis Hernández Yáñez

Curso de Java Tema 11 – JSP - 2 Curso de Java Tema 11 – JSP - 3
Carlos Cervigón Rückauer Carlos Cervigón Rückauer
HTTP HTTP
Peticiones POST: Cuando el usuario pulsa el botón de envío (submit),

Suelen usarse para enviar los datos de un formulario. se envía una petición POST al servidor del que hemos
obtenido el formulario.
Los datos se envían como parámetros, pero éstos no forman
parte de la URL, sino que se envían como parte del cuerpo
del mensaje.
El cliente (navegador) codifica automáticamente los valores
POST /forecast HTTP/1.0
de los parámetros.
<<Otros campos>>
Ejemplo en un formulario HTML: city=Hermosa+Beach&state=CA
...
<form action="/forecast" method="POST">
City: <input type="text" name="city">
State: <input type="text" name=“state”>
<p>
<input type="submit">
</form>
...
Tecnologías Los servlets
Antes: CGI
9 Crea un proceso por cada petición. Los servlets son las respuesta de la tecnología Java a
la programación CGI. Son programas que se ejecutan en
9 Ineficiente.
un servidor web y construyen páginas web.
9 Se implementaron algunas variantes más eficientes.
La página web está basada en datos enviados por el usuario.
Ahora Por ejemplo, las páginas de resultados de los motores de
búsqueda se generan de esta forma y los programas que procesan
9 J2EE Æ Servlets + JSP (Java Server Pages)
pedidos desde sitios de comercio electrónico también.
9 .NET Æ ASP.NET
Los datos cambian frecuentemente.
9 PHP Por ejemplo, un informe sobre el tiempo o páginas de cabeceras
de noticias podrían construir la página dinámicamente.
Otros ejemplos: páginas de una tienda on-line que liste
los precios actuales y el número de artículos en stock.

Java Server Pages (JSP) Arquitectura JSP
JSP es una forma de ver un servlet. Concretamente, una forma

de trabajar con el servlet como si fuera una página HTML.
JSP combina HTML con fragmentos de Java para producir páginas
web dinámicamente.
La página JSP se preprocesa a un archivo .java, que se compila
para generar un .class.
Una página ASP se compila en memoria y JSP genera un archivo
separado.
Cuando el servidor web recibe la petición de una página JSP,
el motor JSP convierte la página en un servlet, que se compila
mediante javac estándar y se ejecuta mediante la API estándar
de Java.

Solicitud de JSP Esquema de un servlet
Tras la recepción de una petición de página JSP: Un servlet es una subclase de un servlet genérico.
El servlet es un archivo .class del lado del servidor que
1. El motor JSP analiza la página solicitada y crea un archivo normalmente procesa peticiones GET y POST, y genera HTML
de código fuente correspondiente al servlet. dinámicamente, que se devuelve al cliente que realizó la petición.
2. El servlet se compila y se genera el .class, que se ejecuta
como cualquier servlet.
<FORM METHOD="POST" ACTION="EjeServlet">
3. Se crea la instancia del servlet y se ejecutan sus métodos
init() y service().
4. El motor de servlets carga la clase del servlet generado para
ejecutarlo.
Indicamos el
5. El servlet se ejecuta y devuelve su respuesta al cliente que servlet que va a
hizo la solicitud (un archivo HTML).
procesar los
datos del
formulario

EjeServlet.java EjeJSP.jsp
import java.io.*; El servlet en forma de página JSP:

import javax.servlet.*;
import javax.servlet.http.*;
<HTML>
<BODY>
public class EjeServlet extends HttpServlet {
<%
public void doPost(HttpServletRequest request,
response.setContentType("text/html");
HttpServletResponse response)
out.println("<TITLE>Ejemplo</TITLE>" + "<BODY BGCOLOR=FFFFFF>");
throws ServletException, IOException {
out.println("<H2>Botón pulsado</H2>");
String Datos = request.getParameter("Datos");
PrintWriter out = response.getWriter();
if(Datos != null){ out.println(Datos); }
out.println("<TITLE>Example</TITLE>");
else { out.println("No has escrito nada."); }
out.println("<BODY BGCOLOR=FFFFFF>");
%>
out.println("<H2>Botón pulsado</H2>");
</BODY>
String DATA = request.getParameter("Datos");
</HTML>
if(DATA != null) { out.println(Datos); }
else { out.println("No has escrito nada."); }
out.println("<BR>" + "Hola, Hola"); Será una página de respuesta a un formulario, por ejemplo:
out.close();
} <FORM METHOD="POST" ACTION="EjeJSP.jsp">
}

Ventajas de JSP Ventajas de JSP
Frente a ASP: El inconveniente de los servlets es que el contenido de la página

Al utilizar Java, es más portable a otros sistemas operativos y se genera a través del código incrustado en el servlet.
servidores web.
Cualquier modificación de la página implica la recompilación del
Frente a los servlets: servlet.
JSP no ofrece nada que no pudiéramos en principio hacer con
un servlet. Pero es mucho más conveniente escribir HTML normal No debería haber dependencia entre la parte de diseño
que tener que usar muchas instrucciones print() para generar y la parte lógica de la aplicación.
el código HTML (necesario en los servlets). El diseñador gráfico de una web de comercio electrónico no tiene
por qué saber manejar java para manipular el código del servlet.
Separando el formato del contenido podemos poner diferentes JSP debe verse como la norma habitual.
personas en diferentes tareas: nuestros expertos en diseño de Los servlets serán casos excepcionales.
páginas web pueden construir el código HTML, dejando espacio
para que los programadores de servlets inserten el contenido
generado dinámicamente.

Generación dinámica de contenido Lógica de negocio y lógica de presentación
Lógica de negocio:
La incorporación dinámica de contenido en una página web Creación de contenidos y control de la relación entre
siempre implica programación. la entrada, los algoritmos y la salida.
Se trata de minimizar la parte de programación y separar Lógica de presentación:
la programación de la presentación del contenido.
Diseño gráfico que determina la forma como se presenta
JSP mezcla HTML y Java.
la información al usuario.
La generación dinámica de contenido se debe separar en dos
partes, para facilitar la programación y reducir costes:
La lógica de negocio se puede controlar desde JavaBeans.
9 Lógica de negocio.
La lógica de presentación se puede controlar desde JSP.
9 Lógica de presentación.
El control de HTTP se puede realizar mediante servlets.

Distribución de tareas Instalación de un servidor web para JSP
Vamos a trabajar con el servidor Blazix.

Situación a la que queremos llegar: www.Blazix.com
Separación de roles. Ocupa muy poco espacio.
Personas que realizan el aspecto gráfico (la vista) Una vez instalado, debemos conocer los siguientes datos:
Æ diseñadores gráficos o similares.
Dónde se ubican los archivos.
Conocimientos de diseño gráfico
y herramientas para generación de HTML. Cómo acceder a ellos desde un navegador:
Personas que implementan el controlador y el modelo http://localhost/pagina.jsp

Æ informáticos. En Blazix, crearemos nuestra primera página de servidor
Conocimientos de diseño e implementación. en el directorio C:\Blazix\webfiles
Se deberían poder usar directamente las herramientas

de diseño de páginas web.

Ejemplo Puerto 82: http://localhost:82/Hola.jsp La primera página JSP
Desde el navegador: <HTML>

<BODY>
http://localhost/Hola.jsp JSP simplemente intercala código Java entre el código HTML.
<H1> CURSO IZAR </H1>
JSP combina HTML con fragmentos de Java para generar
<H1> JAVA SERVER PAGES </H1>
dinámicamente páginas web.
<H1> Primera página en el
servidor </H1> Cualquier página HTML se puede cambiar a la extensión ".jsp".
</BODY> Al cargar la página mediante
Archivo Hola.jsp
</HTML> http://localhost/Hola.jsp
en el servidor
observamos que tarda su tiempo. Pero sólo es la primera vez que
se carga.
El archivo JSP se traduce a un archivo Java, se compila (archivo
.class) y se carga (la compilación sólo se produce una vez).

Elementos JSP Elementos de guión
El signo % identifica a las etiquetas de lenguaje de guiones.

Elementos de guión:
Engloban instrucciones. Son similares a las etiquetas HTML.
Comentarios HTML: 
Comentarios JSP ocultos: <%-- texto -->
Acciones (instrucciones):
Declaraciones: <%! declaración; [declaración;] %>
Cosas que debe hacer el motor JSP al procesar la página.
Expresiones: <%= expresión %>
Pueden ser acciones estándar, propias o personalizadas.
Scriptlets: <% código java %>
Directivas:
Proporcionan información global sobre la página.

Comentarios Expresiones
Archivo solicitado Página resultante Permiten incluir contenido generado dinámicamente.

La secuencia de caracteres <%= y %> incluyen código Java,
que se interpreta en tiempo de ejecución.
<%= expresión %>
Servidor
Expresión
web válida de Java
Cualquier expresión entre <%= y %> será evaluada, convertida

automáticamente a String y posteriormente incluida como parte
del código HTML (reemplazando al guión).
<%= new java.util.Date() %>
El contenido de la página resultante puede varias cada vez que
se solicita la página JSP.
<%= ... %> es una abreviatura de out.println().

Ejemplo Hora0.jsp Declaraciones
El código JSP de la página se convierte en una definición de clase.

Los scriptlets (guiones) se convierten en métodos de esa clase.
Las declaraciones permiten declarar variables o métodos que se
utilizarán posteriormente en la página JSP.
Sólo se evalúan cuando se carga por primera vez la página.
No generan ninguna salida.
Servidor
web Se pueden utilizar en expresiones y scriptlets.
<%! declaración; [declaración;] %>
Ejemplos:
<%! int i = 0, j = 10; %>
<%! java.util.Date fecha = new java.util.Date(); %>
<%! public void jspInit() { . . . } %>

Ejemplo Horad.jsp Scriptlets
Hemos visto cómo incluir expresiones Java en las páginas JSP,

entre los caracteres <%= y %>.
JSP también permite escribir bloques de código Java:
colocando el código entre los elementos <% y %>
(igual que las expresiones pero sin el carácter =).
Este bloque de código se llama scriptlet. Un scriptlet contiene
código Java que se ejecuta cada vez que se llama a la JSP.
El scriptlet no genera HTML de forma directa, se guarda en
el objeto intrínseco out, a partir del cual se puede presentar
cualquier información que contenga la página HTML.
Se pueden declarar variables y métodos, incluir expresiones, así
como usar objetos intrínsecos y cualquier instrucción válida de Java.
Al ser declaración, sólo se evalúa
cuando se carga la página.
Siempre sale el mismo valor de fecha

Ejemplo de scriptlet Hora1.jsp Proceso:
<HTML>
<BODY>
<%
// Esto es un scriptlet. Obsérvese que la variable
// date declarada aquí está disponible para un
// guión posterior.
System.out.println( "Evaluamos la fecha" );
java.util.Date date = new java.util.Date();
%>
La fecha actual es <%= date %>
</BODY> Aparece en la
</HTML> ventana del
servidor (para
El código se ejecuta cada vez que ¡El scriplet no depurar)
se llama a la página JSP genera HTML
directamente!

Objetos intrínsecos en el scriptlet HTML + Java
<HTML> Se puede alternar entre HTML y guiones tanto como se (re)quiera.

<BODY> Se pueden declarar variables y métodos, incluir expresiones,
<% utilizar objetos intrínsecos y cualquier instrucción válida de Java.
// Objetos intrínsecos: Mezcla de HTML y Java:
// request
// response
...
// session
<% for(int i = 3; i < 8; i++) { %>
// out (permite generar HTML)
<BR>
// . . .
<FONT SIZE="<%= i %>">
%>
Hola, joven
</BODY>
</FONT>
</HTML>
<% } %>
...

HTML + Java Tabla.jsp HTML + Java
<HTML> <HTML>
<BODY> <BODY>
<TABLE BORDER=2> <%
<% boolean hola = false;
for(int i = 0; i < 9; i++) { if(hola) {
%> %>
<TR> <H1>Hola</H1>
<TD>Numero </TD> <%
<TD> </TD> }
<TD><%= i + 1 %></TD> else {
</TR> %>
<% <H1>Adiós</H1>
} <%
%> }
%>
</TABLE> Se puede salir del scriptlet,
</BODY>
</BODY> escribir HTML y volver a entrar
</HTML>
</HTML> en el scriptlet sin problemas.

Scriptlet que genera HTML Hora02.jsp Ejemplo info.jsp
El scriptlet puede generar HTML mediante el objeto out.

<HTML>
Todo lo que se envíe a out debe ser de tipo String. <BODY>
<%
<HTML> System.out.println("Evaluando la fecha ");
<BODY> java.util.Date fecha=new java.util.Date();
<% %>
System.out.println("Evaluamos la fecha"); La fecha actual es
java.util.Date fecha = new java.util.Date();
%> <%
out.println("<BR>" + fecha+"<br>");
Hola! La fecha actual es
out.println(System.getProperty("os.name")+ "<br>");
<% out.println(System.getProperty("java.version")+ "<br>");
out.println("<BR>"); out.println(System.getProperty("user.name")+ "<br>");
out.println(fecha); out.println(System.getProperty("user.home")+ "<br>");
%> out.println(System.getProperty("user.dir")+ "<br>");
</BODY> out.println(System.getProperty("java.vendor"));
</HTML> %>
</BODY>
</HTML>

Objeto intrínseco request Request.jsp Funcionamiento
La hora actual es
Contiene la información proporcionada por el navegador <%
al servidor.
out.println( fecha );
<HTML> out.println("<BR>La dirección de su máquina es " );
<BODY>
out.println( request.getRemoteHost());
<%
%>
System.out.println("Evaluamos la fecha:");
java.util.Date fecha = new java.util.Date(); HTML que se genera
%>
La hora actual es La hora actual es
<% Sat Jan 26 17:40:53 CET 2002
out.println(fecha); <BR>La dirección de su máquina es
out.println("<BR>La dirección de su máquina es " ); localhost
out.println(request.getRemoteHost()); Lo que se ve en el explorador
%>
</BODY>
</HTML> La hora actual es Sat Jan 26 17:40:53 CET 2002
La dirección de su máquina es localhost

Ejemplo Cuatropruebas.jsp Ejemplo contador1.jsp
<UL> <HTML>
<LI><B>Expresión.</B><BR> <BODY>
Tu máquina host es: <%= request.getRemoteHost() %>.<br> <%!
Tu id. de sesión: <%= session.getId() %> String sitio="izar.com";
<LI><B>Scriptlet.</B><BR> int contador = 0;
<% out.println("datos de la cadena de GET: " +
request.getQueryString(); %> void incrementa(){
<LI><B>Declaración (más expresión).</B><BR> contador++;
<%! private int cuentaAccesos = 0; %> }
Accesos desde que se reinició el servidor: %>
<%= ++cuentaAccesos %> <%
<LI><B>Directiva (más expresión).</B><BR> incrementa();
<%@ page import = "java.util.*" %> Directiva para %>
Momento actual: <%= new Date() %> incluir un paquete <br>
</UL> El sitio web del día es <%= sitio %> <br>
número de accesos <%= contador %>
</BODY>
</HTML>

Directivas JSP Directiva de inclusión: include include01.jsp
Permiten especificar caracterísitcas globales de página, de etiquetas, Permite incluir en tiempo de compilación una página HTML, archivo
de importación de clases, archivos, etc...... java, fichero de texto u otra página JSP (normalmente para
Sintaxis: encabezados, pies, tablas, etc...)
<%@ directiva {atributo = “valor”}%> <%@ include file=“URL relativa” %>
page: Información para la página.

<HTML>
include: Incluye archivos completos palabra por palabra.
<BODY>
taglib: La dirección de la librería de tags que se usará en la página.
Vamos a incluir hola.jsp...<BR>
<%@ include file="hola.jsp" %>
Ejemplos: </BODY>
<%@ include file="hola.jsp" %> </HTML>
<%@ page import=“java.util”%>
. . .

Directiva de página: page Directiva de página: page
<%@ page atributo= "valor" %> <%@ page atributo= "valor" %>
Atributos y posibles valores Atributos y posibles valores

language="java“ Comunica al servidor el lenguaje que va a ser isThreadSafe="true|false“ Por defecto vale true, le hace señales
utilizado en el archivo. Java es el único posible es esta especificación al motor de JSP para que multiples pedidos del cliente puedan ser
extends="package.class“ La variable extends, define la clase tomadas como una.
padre del servlet generado. Normalmente no es necesario utilizar otras info="text” Información en la página a la que puede accederse a
que no sean las clases base del proveedor. través del método Servlet.getServletInfo() (autor, versión, etc)
import="package.*,package.class“ Sirve para especificar los errorPage="pagina_error“ Página que manejará las excepciones
paquetes y clases que se quieran utilizar. de errores.
session="true|false“ Por defecto session vale true, manteniendo isErrorPage="true|false“ Marca a la página como la página que
los datos de las sesión para la página. manejará los errores. La página tiene acceso al objeto intrínseco
exception.

Directiva de página: import Directiva de página : errorPage
<%@ page import="java.util.*" %> <%@ page errorPage= "urlRelativa" %>

<HTML> Mediante esta directiva es posible redireccionar a una página JSP en
<BODY> caso de producirse una excepción en tiempo de ejecución.
<%@ page isErrorPage=“false” errorPage="tratarerror.jsp" %>
<%
System.out.println("Evaluamos la fecha"); Informa al motor JSP que redireccione una excepción a la página
tratarerror.jsp.
Date fecha = new Date();
%> Es necesario que la página tratarerror.jsp esté marcada como
página de error mediante la directiva
Hola! La hora es <%= fecha %>
</BODY>
<%@ page isErrorPage="true" %>
</HTML>
Esto que permite que el objeto que contiene la excepción sea
accesible dentro del scriptlet a través del objeto intrínseco del scriptlet
exception.

Ejemplo: trataerror.jsp Ejemplo: paginaerror.jsp
<%@ page errorPage="paginaerror.jsp" %> <%@ page isErrorPage="true" %>

<html> <html>
<body>
<body>
<form method=post action="trataerror.jsp">
<h1>
¿Cual es el mejor lenguaje de programación?<p>
Java<input type=radio name=lenguaje value="JAVA" checked> Error Page
C++<input type=radio name=lenguaje value="CPP"> </h1>
Visual Basic<input type=radio name=lenguaje value="VB"> <hr>
<p> <input type=submit> <h2>
</form> Recibí la excepción:<br>
<%
<font color=green>
if (request.getMethod().equals("POST")) {
<%= exception.toString() %>
if (request.getParameter("lenguaje").equals("JAVA")) {
out.println("<hr><font color=red>Acertaste tu!</font>"); </font>
} else { </h2>
throw new Exception("Te equivocaste de lenguaje!"); </body>
} </html>
}
%>
Directiva de librería de etiquetas Objetos intrínsecos del scriptlet
Una librería de etiquetas es una colección de etiquetas personalizadas

que se pueden usar en la página. Los Scriptlets son bloques de código Java residentes entre los tags
<% y %>.
<%@ taglib uri = “URI de librería de etiquetas” Este bloques de código estarán dentro del servlet generado, incluídos
en el método _jspService().
prefijo= “prefijo etiqueta”
Los Scripts pueden acceder a cualquier variable o Bean que haya sido
%> declarado.
También hay algunos objetos intrínsecos disponibles para los Scripts
Las etiquetas personalizadas permiten ocultar código complejo a los desde entorno del Servlet.
diseñadores web. Los más utilizados:
request, response, out, session

Objetos intrínsecos del scriptlet Objetos del entorno
Objetos que se pueden llamar directamente desde la página jsp: application :

out : javax.servlet.jsp.JspWriter Objeto que representa el contexto JSP a lo largo de su vida, desde
Objeto que representa la salida de texto que se lanza por primera vez hasta que se destruye
Proporciona métodos como println(), para generar salidas dentro de scriptlets Permite compartir datos entre diferents sesiones y peticiones
request : javax.servlet.http.HttpServletRequest config :
Es la petición del cliente y proporciona métodos para recuperar información de la

cabecera http o de cookies. Permite acceder a los parámetros de configuración del motor JSP.
Con cada nueva petición de la página se crea un nuevo objeto request. Con cada nueva petición de la página se crea un nuevo objeto
request.
response : javax.servlet.http.HttpServletResponse
Proporciona acceso a los parámetros asociados con las respuestas HTML generadas
page :
por la página (página de respuesta) Representa la página JSP completa. Es sinónimo del objeto this
session : javax.servlet.http.HttpSession
exception :
Para mantener información del cliente que establece conexión con el servidor.
Permite capturar y tratar errores. Solo está disponible cuando se

Cada objeto session corresponde a un solo cliente y permanece durante múltiples activa el salto a una página de error.
peticiones

pidenombre0.htm
Objeto request guardarnombre0.jsp Otros métodos de request:
request : javax.servlet.http.HttpServletRequest
Proporciona métodos para recuperar información de la cabecera http o Info de la máquina cliente: quiz.jsp
de cookies. <%= request.getRemoteHost() %> quizhandler.jsp
Con cada nueva petición de la página se crea un nuevo objeto request
Obtener el valor de un parámetro:
<%= request.getParameter("edad") %> <br>
Mostrar la cadena del GET

<% out.println("GET:"+ request.getQueryString()); %>
Obtener los Cookies del cliente (devuelve un array con cookies)

Carlos Cookie[] request.getCookie()
A cabo de obtener...

Objeto session Objeto session: ejemplo
session : javax.servlet.http.HttpSession
Se usa para mantener información sobre el cliente o visitante que ha
1.

establecido conexión con el servidor.

El usuario introduce su nombre en un formulario
(“pidenombre1.htm”), cuya información procesa la página
El visitante puede recorrer varias páginas y me puede interesar “guardarnombre1.jsp”.
almacenar su información durante la visita a dichas páginas.
Cada objeto session corresponde a un solo cliente y permanece durante 2. “guardarnombre1.jsp” establece un atributo para la sesión y
múltiples peticiones. muestra un vínculo continuar para llevarme a otra página, pero
Puedo mantener diferente información de cada sesión ya he almacenado el nombre para toda esta sesión.
Métodos del objeto session
getCreationTime(), getLastAccesedTime()
3. En la página “siguiente.jsp” recupero el atributo guardado para
la sesión.
getId()
setAttribute(String clave, Object valor) pidenombre1.htm
getAttribute(String clave) : devuelve el objeto guardarnombre1.js

p
siguiente.jsp

Ejemplo Ejemplo (cont.)
2.“Guardarnombre1.jsp”
procesa los datos enviados.
En la página
3 “siguiente.jsp” obtengo el
atributo “elnom bre” de la
session
1 Clave -objeto
2
1.click
Session Session
Todas las páginas JSP participan en una sesión http. No es obligatorio que las páginas JSP participen en una sesión. Se
Los objetos de la sesión se identifican mediante un ID y se almacenan puede modificar la directiva:
en el explorador como un cookie.
Se pueden almacenar en la sesión cualquier objeto java identificándolo <%@ page session="false" %>
mediante una clave. Por ejemplo:
El objeto a identificado por
ident pertenece a la sesión No hay límite en el número de objetos que se pueden almacenar en
<% Algo a = new Algo();
una sesión. Sin embargo, objetos grandes pueden degradar el
session.setAttribute(“ident",a); %> rendimiento.
Hace que la instancia a esté disponible en todas las páginas JSP y Por defecto, la mayoría de los servidores establecen un tiempo de vida
servlets pertenecientes a la misma sesión. de objetos de sesión de 30 minutos, aunque se puede modificar dicho
La instancia se puede recuperar en otra página : valor.
Veamos el ejemplo de un contador utilizando el objeto session.
<% Algo otro =(Algo)session.getAttribute(“ident"); %>

Contador3.jsp
Objeto response
<HTML>
<BODY> Proporciona acceso a los parámetros asociados con las respuestas
<% HTML generadas por la página (página de respuesta):
Integer numvisitas = (Integer)session.getValue("elcontador");
if (numvisitas==null) { //lo pongo a 0
numvisitas= new Integer(0);
Métodos:
session.putValue("elcontador",numvisitas); Establecer el tipo del mensaje de respuesta:
out.println("Bienvenido");
} response.setContentType(String)
else { Redirigir a otra página:
numvisitas= new Integer(numvisitas.intValue()+1); response.sendRedirect(String)
session.putValue("elcontador",numvisitas); Colocar una cookie en el cliente:
out.println("Has visitado " + numvisitas + " veces");
}
response.addCookie(Cookie)
%> Creación del cookie: new Cookie(nombre,valor)
</BODY>
showSession.jsp
</HTML>
showApplication.jsp Caducidad del cookie: setMaxAge(valor)

Ejemplo: ponCookie.jsp
Uso de cookies
Creación del cookie: new Cookie(nombre,valor) <html>
<body>
Caducidad del cookie: setMaxAge(valor)
<h1>Almacenando Cookie!</h1>
Envio del cookie al cliente: response.addCookie(Cookie)
<%
Cookie miCookie = new Cookie("nombre", "Carlos");
<%
miCookie.setMaxAge(24*60*60);
Cookie micookie=new Cookie(“nombre”, “Carlos”);
response.addCookie(miCookie);
miCookie.setMaxAge(24*60*60);
%>
response.addCookie(micookie);
<a href="CogeCookie.jsp"/>Leer Cookie</a>
%>
</body>
Obtención de cookies del cliente(devuelve un array de Cookies):
</html>
request.getCookie()
<% Cookie[] listacookies = request.getCookies();

. .

Ejemplo: cogeCookie.jsp Captura de Excepciones errorconcatch.jsp
<html>
<html>
<head><title>JSP Page</title></head>
<body> <body>
<h1>el nombre de usuario lo saco del cookie almacenado en el cliente.</h1> <% int i=10; int j=0; i = i/j ; %>
<p> El valor de i <%= i %> </p>
<%
</body>
Cookie[] listacookies = request.getCookies(); </html> Sin capturarexcepción !
for(int I = 0; I< listacookies.length;I++) { ____________________________________________
<%
Cookie miCookie = listacookies[I]; int i = 10;
if (miCookie.getName().equals("nombre")) { int j = 0;
Capturam os la excepción !
try {
out.println("el nombre es: " + miCookie.getValue());
i = i / j ;
} } catch (Exception e) {
out.print(“Se produjo el siguiente error:<br>");
}
out.print(e.toString());
%> }
</body> %>
<p> El valor de i es <%= i%> </p>
</html>
</body>
</html>

Acceso a exception en JSP Ejemplo de acceso a base de datos
<%@ page errorPage=“trataError.jsp" %>

<html> <%@page import="java.sql.*" %>
<body> <%
ejemploError.jsp try {
<% int i = 10; i = i / 0; %>
</body> String urlBD = "jdbc:odbc:JDBC_ALUMNOS";
</html> Class.forName ("sun.jdbc.odbc.JdbcOdbcDriver");
Connection conexion = DriverManager.getConnection (urlBD);
Statement select = conexion.createStatement();
ResultSet res = select.executeQuery(
<%@ page isErrorPage="true" %>
trataError.jsp "SELECT * FROM Tabla1 ORDER BY NOMBRE" );
<html>
out.println("NOMBRE");%> <BR> <%
<body> out.println("------");%> <BR>
Ocurrió el error :<br> <%= exception.toString()%> <br>
</body>
</html>

Ejemplo de acceso a base de datos Resultado obtenido

<%
Al solicitar la página http://oemcomputer:82/Listado.jsp
int col = res.findColumn( "nombre" );
boolean seguir = res.next(); se genera la siguiente página
while( seguir ) {
out.println(res.getString( col )); %> <BR>
<%
seguir = res.next();
};
res.close();
select.close();
conexion.close();
}
catch( SQLException ex ) {
System.out.println(ex.toString());
}
%>
Etiquetas JSP Etiquetas JSP predefinidas
Sintaxis:
<algo:etiqueta> <jsp:accion atributo=“valor” />
Cuerpo <algo:etiqueta/>
</algo:etiqueta> Toda acción tiene dos atributos permanentes: id y scope

id identifica el objeto o acción declarada en otro momento del JSP
Los tags pueden ser : scope indica el ámbito y vida de la acción:
predefinidos (comienzan por jsp):
<jsp: accion atributo=“valor” /> 9 page: sólo durante la vida del JSP en esa petición
<jsp:include . . ./>
9 request: mientras dure la petición
<jsp:usebean . . ./>
9 session: mientras dure la sesión
<jsp:include es similar a la directiva include, pero en vez de cargar el texto

9 application: mientras el JSP no se elimine del servidor
del archivo incluido en el archivo original, el tag <jsp:include> llama al (jspDestroy)
objetivo en tiempo de ejecución.
Cargados de una biblioteca externa Lo estudiaremos al ver beans.

Directiva de librería de etiquetas Ejemplo : jsp:include include02.jsp
Una librería de etiquetas es una colección de etiquetas personalizadas <HTML>

que se pueden usar en la página (ampliamos las etiquetas JSP). <BODY>
Definición
Voy a incluir el archivo hola.jsp...<br>
<%@ taglib uri = “URI de librería de etiquetas” <jsp:include page="hola.jsp"/>
prefijo= “prefijo etiqueta”
</BODY>
%>
</HTML>
Uso posterior:
<prefijo:accion atributo=“valor”> Se incluye el resultado
del jsp
------
</prefijo:accion>
(las predefinidas: <jsp:include . . ./> )

Ejemplo : jsp:forward forward.jsp Ejercicio login.html
<HTML> 1) Creamos el siguiente formulario

<BODY>
Voy a incluir el archivo hola.jsp...<br>

<jsp:forward page="hola.jsp"/>
</BODY> 2) En la página “Validarlogin.jsp”

</HTML> comprobamos que el usuario es Pepe y la
contraseña abcd
Termina el jsp y al Si los datos no son correctos, saltamos a la
cliente salta a la url página “error.jsp”:

Ejercicio Pagina de login predeterminada (Blazix)
login.html (directorio wefiles):

Si los datos son correctos, saltamos a la página menu.jsp:
<p><FORM METHOD=POST ACTION="j_security_check">Username:

<INPUT TYPE=TEXT NAME=j_username SIZE=20>
<br>Password: <INPUT TYPE=PASSWORD NAME=j_password SIZE=20>
<br><INPUT TYPE=SUBMIT VALUE="Login">

Fichero de configuración web.ini (opcion 1) Ejemplo login
# Sample authentication
# Remove these lines to take out the authentication sample
# Change the authType to "Basic" to see basic authentication example
# and uncomment the "authRealm" line.
Página de login
application.default.authType: Form
#application.default.authRealm: Sample
application.default.authLoginForm: /login.html
application.default.authErrorPage: /loginFailed.html Página cuando login
role.name: user incorrecto
role.user.url: /AuthenticationTest.html
Página cuando login correcto
Password y login
a cotejar

Fichero de configuración web.ini (opcion 2) Directiva de página: contentType excel.jsp
# Sample authentication
# Remove these lines to take out the authentication sample
<%@ page atributo= "valor" %>
# Change the authType to "Basic" to see basic authentication example Vamos a generar una hoja de cálculo Excel con los datos de la página
# and uncomment the "authRealm" line. JSP:
application.default.authType: Basic <%@ page contentType="application/vnd.ms-excel" %>

application.default.authRealm: Sample <%-- Observe que hay tabuladores, no espacios entre
columnas. --%>
application.default.authLoginForm: /login.html
1997 1998 1999 2000 2001
application.default.authErrorPage: /loginFailed.html 12.3 13.4 14.5 15.6 16.7
role.name: user
role.user.url: /AuthenticationTest.html

Response: setContentType Response: setRedirect(URL)
<HTML><HEAD><TITLE>Comparing Apples and Oranges</TITLE> <%@page import="java.util.*" %>

</HEAD> <BODY> <html>
<CENTER> <head> <title>HolaUsuario</title> </head>
<H2>Comparing Apples and Oranges</H2>
<body>
<%
<%
response.setContentType("application/vnd.ms-excel");
%>
Date actual;
<TABLE BORDER=1> actual = new Date();
<TR><TH></TH><TH>Apples<TH>Oranges out.print("Hola " + request.getParameter("usuario"));
<TR><TH>First Quarter<TD>2307<TD>4706 out.print("hoy es " + actual.toString());
<TR><TH>Second Quarter<TD>2982<TD>5104 . . .
<TR><TH>Third Quarter<TD>3011<TD>5220 response.sendRedirect("http://www.ucm.es");
<TR><TH>Fourth Quarter<TD>3055<TD>5287
%>
</TABLE></CENTER>
</body>
</BODY>
</html>
</HTML>

Reescritura de URL Applets y jsp formapplet.jsp
<%@ page session="false" %> <html><body>

. . . <form method=post >
<% ¿Quieres probar el applet?<p>
int cont = 0; Si<input type=radio name=respuesta value="SI" checked>
String parm = request.getParameter("cont"); No<input type=radio name=respuesta value="NO">
if (parm != null) cont = Integer.parseInt(parm); <p> <input type=submit>
if (cont == 0) { </form>
%> Es la primera vez. <% } <%
else if (cont == 1) { if (request.getMethod().equals("POST")) {
%> ya has accedidoantes.<% } if (request.getParameter("respuesta").equals("SI")) {
else { out.println("<hr><font color=red>SI!</font>");
%> Has accedido <%= cont %> veces antes.<% %>
} <jsp:include page="euros.jsp"/>
%> <%
<P> Pulsa } else {
<A HREF="Counter7.jsp?cont=<%=cont + 1 %>" out.println("<hr><font color=red>NO!</font>");
>aqui</A> para volver a visitar la página. }
</BODY> } %>
</HTML> </body></html>
<jsp:plugin .....> javaBeans Empleado.jsp
<jsp:plugin Un JavaBean es una clase java que se puede relacionar con una
type="applet" página JSP y que suele tener :
code="DigitalClock.class" Constructor sin argumentos
codebase="/bookstore2" Metodos get/set
jreversion="1.4"
public class Empleado {
align="center"
public String nombre = "sin nombre";
height="25"
public String getNombre(){
width="300" > return nombre;
. . . }
public void setNombre(String nombre){
</jsp:plugin> this.nombre = nombre;
}
}

javaBeans javaBeans: operaciones
Vamos a usar el bean que identificamos como “mibean” y cuya clase

La utilidad de javaBeans es que se puede reutilizar el código de la es “Empleado”
clase en otras aplicaciones. <jsp:useBean id="mibean" class="Empleado" />
Reduce el código java en la página JSP y permite a los diseñadores

trabajar con HTML sin saber mucho de Java. Establecer la propiedad “nombre” de dicho bean:
Veamos un ejemplo en el que se relaciona la clase Empleado <jsp:setProperty name="mibean" property ="nombre"
(javaBean) con una página JSP que accede a los campos de dicha value ="kiko" />
clase, mediante
useBean Obtener la propiedad “nombre” de dicho bean:
<jsp:getProperty name="mibean" property="nombre" />
setProperty
getProperty
Usamos un método del bean en una expresión:
<%= mibean.getNombre() %>

javaBeans beans1.jsp Beans y tratamiento de formularios (1)
<HTML>
<BODY> El modo usual de trabajar con formularios es mediante la definición
<jsp:useBean id="mibean" class="Empleado" /> de un “bean”. El “bean” contiene código Java que se puede llamar
desde la página JSP.
<jsp:setProperty name="mibean"
property="nombre" Se trata de definir una clase con un atributo por cada campo del
formulario.
value="kiko" />
La clase debe tener métodos modificadores y consultores de cada
Bienvenido a nuestra empresa, uno de los atributos (campos).
<jsp:getProperty name="mibean"
Consideramos un formulario que pide el nombre, el e-mail y la edad
property="nombre" /> del cliente.
<br><br> Se trata de enlazar el bean con el servlet o la página JSP para que
<%= mibean.getNombre() %>, por favor visita nuestra web más trabaje con los datos del formulario.
a menudo . . .
</BODY>
</HTML>

Beans y tratamiento de formularios (2) Beans y tratamiento de formularios (3)
public class Usuario{

<HTML> PideDatos.jsp String campousuario;
<BODY>
String campomail; Creamos el bean Usuario.java
int campoedad;
<FORM method=post> action=“guardaenbean.jsp”
Escribe nombre : <INPUT type="text" name=campousuario> <br> public void setCampousuario(String valor){
Escribe e-mail : <INPUT type="text" name=campomail> <br> campousuario=valor;}

public void setCampomail(String valor){
Escribe edad : <INPUT type="text" name=campoedad> <br>
campomail=valor;}
<P><INPUT type=submit value="Enviar">
public void setCampoedad(int valor){
</FORM> campoedad=valor;}
</BODY> public String getCampousuario(){return campousuario;}

public String getCampomail(){return campomail;}
</HTML>
public int getCampoedad(){return campoedad;}
}

Beans y tratamiento de formularios (4) Beans y tratamiento de formularios (5)
Compilamos la clase y verificamos el classpath del servidor web (En Utiliza la instancia de la clase
Blazix podemos colocarla en la carpeta “classes”). Usuario en esta sesión
El programa que procesa el formulario usa las etiquetas useBean y <jsp:useBean id="beanusuario" class="Usuario"
setProperty scope="session"/>
<jsp:useBean id="beanusuario" class="Usuario"

Coge los datos del form. Y
scope="session"/>
los coloca en el bean
<jsp:setProperty name="beanusuario" property="*"/>
... <jsp:setProperty name="beanusuario" property="*"/>
<HTML> <HTML>
<BODY> <BODY>
<A Href=“recuperarbean.jsp">recuperar</A> <A Href=“recuperabean.jsp">Recuperar datos</A>
</BODY> </BODY> Vamos a otra página desde
</HTML> la que recuperamos los
guardaenbean.jsp </HTML>
datos del bean

Beans y tratamiento de formularios (6) Proceso :
<jsp:useBean id="beanusuario" class="Usuario"

scope="session"/> 1.
<HTML> Usa los métodos del bean
<BODY> para obtener atributos
Los datos que introdujo son:<br>
Nombre: <%= beanusuario.getCampousuario() %> <br> 2.
e-Mail: <%= beanusuario.getCampomail() %> <br>
Edad: <%= beanusuario.getCampoedad() %> <br>
<jsp:getProperty name="beanusuario" property="campousuario" />
<jsp:getProperty name="beanusuario" property="campomail" /> 1.Envio los datos delform ulario
<jsp:getProperty name="beanusuario" property="campoedad" /> 2.Los guardo en elbean
</BODY> 3.Los recupero delbean
recuperabean.jsp 3.
</HTML>
Otra forma de obtener
los atributos
Otro enfoque : pideDatos2.jsp Proceso:
<jsp:useBean id="beanusuario" class="Usuario" scope="session"/>

<jsp:setProperty name="beanusuario" property="*"/>
<HTML>
<BODY> N o usam os un script(action)
<FORM method=get>
Escribe tu nombre : <INPUT type="text" name=campousuario> <br>
Escribe tu e-mail : <INPUT type="text" name=campomail> <br>
Escribe tu edad : <INPUT type="text" name=campoEdad> <br>
</FORM>
<% if (request.getParameter("campousuario") != null){
%>
<h1> Hola,<jsp:getProperty name="beanusuario” property="campousuario"/></h1>
<%
}
%> Obtengo una propiedad del bean, en
</BODY> la propia página del formulario
</HTML>

Resumen: beans Carrito compra con beans (1)

public class Product {
Normas en la creación de beans:
Si usamos <jsp:getProperty>, necesitamos el correspondiente private int productId;
método get en el bean private String productName;
private double productPrice;
Si usamos <jsp:setProperty>, necesitamos uno o más métodos
set correspondientes. public Product(int prodid, String prodname, double prodprice) {
Del formulario al bean: productId = prodid; productName = prodname;
productPrice = prodprice;
Localizamos el ejemplar del bean : <jsp:useBean> }
Poner las propiedades en el bean: <jsp:setProperty>
public int getProductId(){ ... }
Del bean al formulario: public void setProductId(int ProductId){...}
Localizamos el ejemplar del bean : <jsp:useBean> public String getProductName(){...}

public void setProductName(String ProductName){... }
Obtenemos las propiedades del bean: <jsp:getProperty> public double getProductPrice(){ ... }
public void setProductPrice(double productPrice){ ...}
}

Carrito compra con beans (2) Carrito compra con beans (3) carrito1.jsp
public class ProductManager { <html> <body> Catalogo de productos

private Product[] productList = new Product[3]; <p> </p>
<form method="POST" action=“tratacarrito1.jsp">
private int productCount;
<table border="0" cellpadding="0" cellspacing="0" width="439">
public ProductManager() {
<tr>
initializeProductList(); } <td width="157"><b>Catalogo</b></td>
private void initializeProductList() { <td width="128"></td>
productList[0] = new Product(1,"Leche",49.99); <td width="148"></td>
productList[1] = new Product(2,"Galletas",59.99); </tr> <tr>
<td width="157" bgcolor="#C0C0C0">
productList[2] = new Product(3,"Pan",39.99);
<font color="#FFFFFF">Producto</font> </td>
}
<td width="128" bgcolor="#C0C0C0">
<font color="#FFFFFF">Precio</font> </td>
public Product[] getProductList(){ <td width="148" bgcolor="#C0C0C0">
return productList; } <font color="#FFFFFF">Selecccionar</font> </td>
public int getProductCount(){ </tr>
<tr>
return productList.length;
<td width="157">Leche JSP</td>
}
<td width="128">2.99</td> <td width="148">
public Product getProductDetails(int prodid) { <input type="checkbox" name="productid" value="1" />
.... </td>
</tr>

Carrito compra con beans (3) carrito1.jsp carrito1.jsp
<tr>
<td width="157">Galletas</td>
<td width="128">3.99</td>
<td width="148">
<input type="checkbox" name="productid" value="2" />
</td>
</tr>
<tr>
<td width="157">Pan</td>
<td width="128">1.99</td>
<td width="148">
<input type="checkbox" name="productid" value="3" />
</td>
</tr>
</table>
<p>
<input type="submit"
value="Añadir al carrito" name="AddToShoppingCartBtn" />
</p>
</form>
</body>
</html>

tratacarrito1.jsp Modelos de accesos JSP
<html> <body>
<b>(Respuesta) </b><br /><br />
Las primeras especificaciones JSP definían dos arquitecturas conocidas como
<jsp:useBean id="pm" class="ProductManager" scope="session">
Modelo 1 y Modelo 2.
</jsp:useBean>
<% La diferencia fundamental radica en donde se encuentra el núcleo del proceso
String[] selProducts = request.getParameterValues("productid"); de las peticiones
int selProductsCount = 0; En el modelo 1, la petición desde el explorador se envía directamente a la
if (selProducts == null) { página JSP, que es responsable de procesarla y de devolver la respuesta al
out.println("No seleccionó nada"); cliente.
} else {
Hay una separación entre el contenido y la presentación, puesto que se suele
selProductsCount = selProducts.length;
acceder a los datos a través de beans.
out.println("El carrito tiene lo siguiente :" +"<BR>");
for(int i=0;i<selProductsCount;i++) { Adecuado en aplicaciones pequeñas
int ProductId = Integer.parseInt(selProducts[i]); Mucho código Java dentro de la página JSP
Product prod = pm.getProductDetails(ProductId);
out.println(prod.getProductName());out.println(prod.getProductPrice());
out.println("<BR>");
} }
%> </body></html>

Modelo 1 (Cliente-Servidor) Modelo 2 (Modelo-Vista-Controlador)

Modelo 2 (Modelo-Vista-Controlador) Modelo 1: ejemplo
Aplicación que solicita al lector datos sobre el coche o moto que le gustaría tener.
Página del formulario: encuesta.html
El proceso se divide entre componentes de presentación y

controladores.
El modelo viene representado por los beans
Los componentes de presentación son páginas JSP que generan la
respuesta HTML
Los controladores procesan las peticiones HTTP y son responsables de Página que procesa los datos del formulario: proencuesta.jsp: Todo el control de los
crear beans. Se pueden implementar como servlets o como páginas datos del formulario los recibe esta página y los manipula, simplemente guardándolos
en un fichero en disco, con el nombre del usuario.
JSP

Clase Properties proencuesta.jsp (1)

<html>
Usaremos la clase Properties para almacenar los datos del formulario <body>
<%@ page import="java.util.*,java.io.*" %>
La clase Properties permite guardar un conjunto de propiedades que se
<h2>Tutorial JSP, resultado encuesta</h2>
pueden volcar a un flujo de salida o se puede cargar desde un flujo
<%
Contiene pares del tipo “clave-valor”, como un string.
String usuario = request.getParameter("usuario");
Creación del objeto Properties: String sexo = request.getParameter("genero");
Properties p = new Properties(); String coche = request.getParameter("coche");
Mapear claves con valores: String moto = request.getParameter("moto");
p.put(clave,valor); if(usuario == null || sexo == null || coche == null || moto ==
null) {
Grabar el objeto en el flujo de salida
%>
p.store (OutputStream , String ) :
<br>Hay opciones no seleccionadas y debe haber una<br>
selección en cada uno para completar la encuesta.<br>
Pulse aquí <a href="javascript:history.back()">volver</a> para
realizar la selección.

proencuesta.jsp (2) proencuesta.jsp (3)
<% } <font face="Verdana,Helvetica" size="-1" color="#000099">
Gracias <b><%= usuario%></b>, su selección ha sido recogida.<br> Los datos
else { son:<br>
// Almacenamos la información del usuario en una instancia del </font><br>
objeto properties <table width="40%" border="0" cellspacing="1" cellpadding="0"
align="center">
Properties p = new Properties();
. . .
p.put( "usuario",usuario );
<font face="Verdana,Helvetica" size="-1" color="#000099">
p.put( "genero",sexo ); Sexo:</font></td> <td nowrap>
p.put( "coche",coche ); <font face="Verdana,Helvetica" size="-1" color="#990000">
p.put( "moto",moto ); <b><%= sexo %></b></font>

</td></tr> <tr><td nowrap>
// Almacenamos el objeto en un fichero con nombre de usuario
<font face="Verdana,Helvetica" size="-1"
FileOutputStream fos = new FileOutputStream(usuario); . . .
p.store( fos,"Encuesta, realizada a -- "+usuario ); </td></tr>
fos.flush(); </table>
<% } %>
fos.close();
</body>
%>

resultado Modelo 2: ejemplo
Página del formulario:encuesta3.html

Definimos un javabean que implemente la lógica de la aplicación:
DatosEncuesta.java
La página proencuesta3.jsp ahora se encarga sólo de la presentación

encuesta3.htm El bean: DatosEncuesta.java
public class DatosEncuesta {

private String usuario; private String genero;
private String coche; private String moto;
public String getUsuario() { return( usuario ); }
public void setUsuario( String _usuario ) {
usuario = _usuario;}
public String getGenero() {
return( genero ); }
public void setGenero( String _genero ) {
genero = _genero; }
public String getCoche() {
return( coche ); }
public void setCoche( String _coche ) {
El valor de action en el formulario es: coche = _coche; }
proencuesta3.jsp public String getMoto() {. . .}
public void setMoto( String _moto ) {. . .}

El bean: DatosEncuesta.java Proceso del bean: Proencuesta3.jsp
// Método que se encarga del almacenamiento del objeto <html> <body>

// p en fichero de disco <h3> Encuesta - revisión datos </h3>
<jsp:useBean id="vbean" scope="request" class="DatosEncuesta" />
public void guardar() throws IOException { <jsp:setProperty name="vbean" property="*" />
Properties p = new Properties();
p.put( "usuario",usuario ); <% // Comprobamos que todos los datos han sido seleccionados
p.put( "genero",genero ); if(vbean.getUsuario() == null || vbean.getGenero() == null ||
p.put( "coche",coche ); vbean.getMoto() == null || vbean.getCoche() == null ) {
p.put( "moto",moto ); %>
FileOutputStream fos = new FileOutputStream(usuario); <br>Hay opciones que no se han seleccionado y debe haber una<br>
p.store( fos,"Encuesta realizada a -- "+usuario ); selección en cada uno de ellos para completar la encuesta.<br>
fos.flush(); Pulse aquí <a href="javascript:history.back()">volver</a> para
fos.close(); realizar la selección.
} <% } else { En este modelo la página JSP

} %> no utiliza casi el lenguaje Java
<% vbean.guardar();%>

Proceso del bean: Proencuesta3.jsp Ejemplo : (Modelo 2)
Gracias <b><jsp:getProperty name="vbean" property="usuario" /></b>,
Página del catálogo: Catalog.jsp
su selección ha sido recogida.<br> Los datos son:<br>
</font><br>
<table width="40%" border="0" cellspacing="1" cellpadding="0" align="center">
<tr><td> <im g src="w roxlogo.gif"
<table width="100%" border="0" cellspacing="0" cellpadding="0">
<tr bgcolor="#999999"><td bgcolor="#003399">
<table width="100%" border="0" cellspacing="1" cellpadding="2">
<tr bgcolor="#FFFFFF"><td nowrap>
. . . .
Moto:</font></td> <jsp:includepage=
<td nowrap> "ShoppingC artSum m ary.jsp"
<b><jsp:getProperty name="vbean" property="moto" /></b></font>
</td></tr>
</table>
. . . .
<% } %>
</body>
</html>

Ejemplos : carrito compra (M2) shoppingCartSummary.jsp
Tratamiento del formulario: WroxShopController.jsp <%@ page import="java.util.Iterator" %>

<jsp:useBean id="cart“ class="ShoppingCart" scope="session"> <jsp:useBean id="cart“ class="ShoppingCart" scope="session">
</jsp:useBean> </jsp:useBean>
<%!String URL="";%> <%
<% String action= request.getParameter("Action"); Iterator contents = cart.getContents();
if (action.equals("AddToCart")) { float totalValue = (float)0.0;
String ISBN = (String)request.getParameter("ISBN"); int totalItems = 0;
String title = (String)request.getParameter("Title"); while (contents.hasNext()) {
float price = Float.parseFloat(request.getParameter("Price")); Book b = (Book)contents.next();
System.out.println(ISBN + "," + title + "," + price); totalItems = totalItems + b.getQuantity();
Book b = new Book(); b.setISBN(ISBN); b.setBookTitle(title); totalValue = totalValue + b.getQuantity()*b.getPrice();
b.setPrice((float)price); b.setQuantity(1); }
cart.addItem(b); out.println("<B><U>Shopping Cart Summary</U></B>" + "<BR>");
URL = "Catalog.jsp"; out.println("Total Items : " + totalItems + "<BR>");
} else if (action.equals("CheckOut")) { out.println("Total Value : $" + totalValue);
URL = "CheckOut.jsp";} %>);
response.sendRedirect(URL);
%>

Checkout.jsp Librería de etiquetas de Blazix
<%@ taglib uri = “Url de librería de etiquetas”

prefix= “prefijo etiqueta” %>
<%@ taglib uri="/blx.tld" prefix="blx" %>
urldelfichero .jar
que contiene la
definición de librería
de etiquetas

Ejemplo (pidenombre3>guardabean>pidenombre5.jsp) Arquitectura de un servlet
<%@ taglib prefix="blx" uri="/blx.tld" %>

<jsp:useBean id="beanusuario" class="Usuario" scope="session"/>
<HTML>
<BODY>
<blx:getProperty name="beanusuario" property="*">
<FORM method=post action="otra2.jsp">
Escribe tu nombre : <INPUT type="text" name=campousuario>
<br>
Escribe tu e-mail &nbsp: <INPUT type="text"
name=campomail> <br>
Escribe tu edad &nbsp: <INPUT type="text"
name=campoedad> <br>
</FORM>
</blx:getProperty>
</BODY>
</HTML>

Ciclo de vida Ejemplo de llama a Servlet
<HTML> <HEAD> <TITLE>Example</TITLE> </HEAD>
...
<H2>Formulario enlazado con un servlet</H2>
Introduzca texto y pulse enviar.<BR>

al pulsar enviar se llama a ExampServlet.java <BR>
que devuelve una página HTML al explorador
<FORM METHOD="POST" ACTION="ExampServlet">
<INPUT TYPE="TEXT" NAME="DATA" SIZE=30>
<P>
<INPUT TYPE="SUBMIT" VALUE="Pulsa">
<INPUT TYPE="RESET">
</FORM>
...
</BODY>
</HTML>

ExampServlet.java Esctructura básica de un servlet

import java.io.*;import javax.servlet.*;import javax.servlet.http.*;
public class ExampServlet extends HttpServlet { Cuando se genera un servlet a partir del fichero jsp es posible ver el código del servlet
public void doPost(HttpServletRequest request,
generado. Si nos fijamos en este archivo podemos encontrar las siguientes clases:
HttpServletResponse response)
throws ServletException, IOException HttpJspPage
{ Ellas definen la interface para el compilador de páginas JSP.
PrintWriter out = response.getWriter();
Nos encontramos también tres métodos:
out.println("<title>Example</title>" + "<body bgcolor=FFFFFF>"); JspInit()
out.println("<h2>Boton Pulsado</h2>"); JspDestroy()
String DATA = request.getParameter("DATA");
_jspService(HttpServletRequest request, HttpServletResponse response)
if(DATA != null){
out.println(DATA); Los dos primeros métodos pueden ser definidos por el autor de la página JSP, pero el
} else { tercer método es una versión compilada de la página JSP, y su creación es
out.println("No text entered."); responsabilidad del motor de JSP
}
out.close();
}} Boton Pulsado
Carlos

Esctructura básica de un servlet Métodos básicos
La implementación de la clase JSP extiende HttpJspBase, que a su vez implementa la

init(): es donde comienza el servlet. Aquí se colocá código que se desea sea
interface javax.servlet.Servlet, que define los siguientes métodos del ciclo de vida:
ejecutado sólo cuando carga el servlet.
service(): maneja las peticiones del cliente.
Métodos: destroy(): cuando el servlet es desmontado se invoca este metodo. Es usado para
jspService(), básicamente inserta el contenido de la página JSP. hacer limpieza.
jspInit() y jspDestroy() se pueden redefinir. doGet() y doPost(): son identicos excepto que uno atiende las peticiones GET y el
otro las POST. Ambos métodos reciben objetos del tipo HttpServletResponse y
HttpServletRequest.
Una vez cargada la clase en el servlet contenedor, el método _jspService() es
responsable de atender las peticiones getServletInfo(): retorna información del servlet, como autor, copyrigth, etc.
Un Servlet es construído e inicializado, después se procesan cero o varias peticiones y

por último se destruye.

Tema 11

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Tema 11

Caricato da

Copyright:

Formati disponibili

Introducción

El lenguaje Java — Tema 11 — JSP

Tipos de peticiones: El navegador responde con:

Luis Hernández Yáñez Luis Hernández Yáñez

Peticiones POST: Cuando el usuario pulsa el botón de envío (submit),

Tecnologías Los servlets

Luis Hernández Yáñez Luis Hernández Yáñez

JSP es una forma de ver un servlet. Concretamente, una forma

Luis Hernández Yáñez Luis Hernández Yáñez

Solicitud de JSP Esquema de un servlet

Luis Hernández Yáñez Luis Hernández Yáñez

import java.io.*; El servlet en forma de página JSP:

Luis Hernández Yáñez Luis Hernández Yáñez

Ventajas de JSP Ventajas de JSP

Frente a ASP: El inconveniente de los servlets es que el contenido de la página

Luis Hernández Yáñez Luis Hernández Yáñez

Luis Hernández Yáñez Luis Hernández Yáñez

Distribución de tareas Instalación de un servidor web para JSP

Vamos a trabajar con el servidor Blazix.

Personas que implementan el controlador y el modelo http://localhost/pagina.jsp

Se deberían poder usar directamente las herramientas

Luis Hernández Yáñez Luis Hernández Yáñez

Desde el navegador: <HTML>

Luis Hernández Yáñez Luis Hernández Yáñez

Elementos JSP Elementos de guión

El signo % identifica a las etiquetas de lenguaje de guiones.

Luis Hernández Yáñez Luis Hernández Yáñez

Archivo solicitado Página resultante Permiten incluir contenido generado dinámicamente.

Cualquier expresión entre <%= y %> será evaluada, convertida

Luis Hernández Yáñez Luis Hernández Yáñez

Ejemplo Hora0.jsp Declaraciones

El código JSP de la página se convierte en una definición de clase.

Luis Hernández Yáñez Luis Hernández Yáñez

Hemos visto cómo incluir expresiones Java en las páginas JSP,

Luis Hernández Yáñez Luis Hernández Yáñez

Ejemplo de scriptlet Hora1.jsp Proceso:

Luis Hernández Yáñez Luis Hernández Yáñez

<HTML> Se puede alternar entre HTML y guiones tanto como se (re)quiera.

Luis Hernández Yáñez Luis Hernández Yáñez

HTML + Java Tabla.jsp HTML + Java

Luis Hernández Yáñez Luis Hernández Yáñez

El scriptlet puede generar HTML mediante el objeto out.

Luis Hernández Yáñez Luis Hernández Yáñez

Objeto intrínseco request Request.jsp Funcionamiento

Luis Hernández Yáñez Luis Hernández Yáñez

Luis Hernández Yáñez Luis Hernández Yáñez

Directivas JSP Directiva de inclusión: include include01.jsp

 page: Información para la página.

Luis Hernández Yáñez Luis Hernández Yáñez

Atributos y posibles valores Atributos y posibles valores

Luis Hernández Yáñez Luis Hernández Yáñez

Directiva de página: import Directiva de página : errorPage

<%@ page import="java.util.*" %> <%@ page errorPage= "urlRelativa" %>

Luis Hernández Yáñez Luis Hernández Yáñez

<%@ page errorPage="paginaerror.jsp" %> <%@ page isErrorPage="true" %>

Directiva de librería de etiquetas Objetos intrínsecos del scriptlet

 Una librería de etiquetas es una colección de etiquetas personalizadas

Luis Hernández Yáñez Luis Hernández Yáñez

Objetos que se pueden llamar directamente desde la página jsp:  application :

Luis Hernández Yáñez Luis Hernández Yáñez

 Mostrar la cadena del GET

 Obtener los Cookies del cliente (devuelve un array con cookies)

Luis Hernández Yáñez Luis Hernández Yáñez

page: Información para la página.

Una librería de etiquetas es una colección de etiquetas personalizadas

Objetos que se pueden llamar directamente desde la página jsp: application :

Mostrar la cadena del GET

Obtener los Cookies del cliente (devuelve un array con cookies)

</algo:etiqueta> Toda acción tiene dos atributos permanentes: id y scope

Una librería de etiquetas es una colección de etiquetas personalizadas <HTML>

<HTML> 1) Creamos el siguiente formulario

</BODY> 2) En la página “Validarlogin.jsp”

login.html (directorio wefiles):

<p><FORM METHOD=POST ACTION="j_security_check">Username:

code="DigitalClock.class" Constructor sin argumentos

codebase="/bookstore2" Metodos get/set

Vamos a usar el bean que identificamos como “mibean” y cuya clase

Reduce el código java en la página JSP y permite a los diseñadores

Localizamos el ejemplar del bean : <jsp:useBean> public String getProductName(){...}

public class ProductManager { <html> <body> Catalogo de productos

El proceso se divide entre componentes de presentación y