Java Server Pages, Beans y JSP Tag Library Introducción

Transcripción

Java Server Pages, Beans y
JSP Tag Library
Fernando Pech May
Sintetizado del curso de Mark Baker
University of Portsmouth, UK
1
Introducción
Introducción a los JSP.
Elementos de JSP Scripting.
JSP, directivas de página: Estructura y
generación de Servlets.
Incluyendo archivos en documentos JSP.
Usar los componentes de JavaBeans con
JSP.
Creando JSP tag libraries personalizados.
Integrando Servlets y JSP con la
arquitectura MVC.
2
¿Porqué usar JSP?
Con Servlets es fácil:
Leer datos de un formulario,
Leer las cabeceras de las peticiones HTTP.
Leer los códigos de estado HTTP y las cabeceras de
respuesta,
Usar cookies y seguimiento de sesiones,
Compartir Datos entre Servlets,
Recordar datos entre peticiones.
Qué es lo difícil:
Usar muchas instrucciones println() para generar HTML,
Mantenimiento del HTML.
3
El Framework de JSP
La idea:
Uso de HTML para la mayoría de las páginas Web,
Identificar código del Servlet con etiquetas especiales,
Toda la página JSP es convertida a un Servlet (sólo una vez)
y el Servlet es el que realmente es invocado (por cada
petición).
Ejemplo:
JSP:
URL:
Thanks for ordering <%=request.getParameter(“title”) %/>
http://host/OrderConfirmation.jsp?title=Java+Servlets.
Result:
Thanks for ordering the “Java Servlets”
4
Java Server Pages (JSP)
Arquitectura de JSP
El propósito de JSP es ofrecer una forma más
declarativa y más guiada por la presentación que
aquella conseguida con los servlets.
Las páginas JSP se utilizan en un proceso que
involucra dos fases:
1.
Una fase de traducción dinámica a servlets que se
2.
realiza únicamente cuando la página JSP se crea o
modifica.
Una fase de contestación a peticiones que se
consigue cuando las clases de los servlets
generados se cargan en el contenedor de servlets.
5
Arquitectura de JSP
En
la
segunda
fase,
para
atender
concurrentemente al procesamiento de peticiones,
el servidor lanza un proceso ligero (thread) por
cada uno de los clientes el cual corre el método
_jspService().
El método _jspService() no puede reemplazarse
por otros métodos definidos por el programador,
pero en cambio puede adecuarse su inicialización y
terminación con los métodos jspInit() y
jspDestroy().
6
Arquitectura de JSP
Evento de iniciación
Servlet
_jspInit()
Petición
Respuesta
Evento de terminación
_jspService()
_jspDestroy()
Contenedor de Servlets
7
Benéficos de usar JSP
Ventajas
Independencia del servidor Web.
Substitución del API de los servlets por conjuntos
de elementos de marcado (tags) y fragmentos de
programación (scriptlets).
Altamente recomendable para conseguir el acceso
al servidor Web en arquitecturas de partes
múltiples (multi-tier).
Separación del contenido estático del dinámico.
Separación del contenido dinámico del formato de
la presentación.
8
Ventajas de JSP frente a las
tecnologías similares.
Contra Active Server Pages (ASP):
ASP es una tecnología similar que pertenece a Microsoft
La parte dinámica de JSP es escrita en Java, no en Visual
Basic u otro lenguaje propietario de Microsoft, esto lo hace
un mejor lenguaje.
Es portable con otros sistemas operativos y servidores Web
que no sean de Microsoft.
Contra Servlets:
JSP no proporciona algo más que en principio podría hacerse
con un Servlet.
Pero es mas conveniente para escribir y modificar HTML que
tener muchas sentencias println() para generarlo.
Además, haciendo la separación de vista y contenido, se
puede tener diversas personas en diversas tareas: expertos
en diseño de páginas Web pueden construir el HTML,
dejando lugar para que los programadores de Servlets
inserten el contenido dinámico.
9
Contra Server-Side Includes (SSI):
SSI son tecnologías ampliamente soportadas para incluir, en una
página Web estática, partes definidas externamente.
JSP es mejor porque le permite utilizar Servlets en lugar de un
programa separado para generar la parte dinámica,
SSI está pensado para inclusiones simples, no para programas
reales que usen información de un formulario, conexiones a bases
de datos, etc.
Contra JavaScript:
JavaScript puede generar dinámicamente HTML del lado cliente,
Capacidad útil, pero sólo para manejar situaciones donde la
información dinámica está basada en el medio ambiente del cliente,
Con excepción de las cookies de HTTP y los formularios, el envío de
datos no es posible en JavaScript,
Y, puesto que corre del lado cliente, JavaScript no puede tener
acceso a los recursos del lado servidor como bases de datos,
catálogos, información valiosa, entre otros.
10
Contra HTML estático:
El HTML normal, no puede contener información
dinámica.
JSP es tan fácil y conveniente que es totalmente
factible aumentar las páginas HTML que se verán
beneficiadas por la inserción de cantidades
pequeñas de datos dinámicos.
11
Resumen: JSP vs ASP
Propiedad
Java Server Pages
Active Server Pages
Servidor
La mayoría de los servidores más
Conocidos (Apache, Netscape,
MS IIS)
Los servidores de Microsoft (IIS
y
Personal Web Server)
Plataforma
Cualquiera que corra una máquina
virtual Java
Windows
Modelo de
componentes
Java Beans, Enterprise Java Beans y
librerías de elementos
COM , DCOM , COM +
Programación
(scripting)
Java
JavaScript o Visual Basic Script
Seguridad
Modelo de seguridad de Java
Modelo de seguridad de Windows
NT
Bases de datos
Java Data Base Connectivity
Active Data Objects
Extensibilidad
Abierto a librerías de elementos
Ninguna
12
Malentendidos comunes:
Recordar que JSP es tecnología Server-Side
Pregunta muy común:
¿Por qué esta pregunta no tiene sentido?
¿No puedo hacer XYZ con el HTML, JSP me dejaría
hacerlo?
JSP corre completamente del lado servidor,
No cambia el contenido que el visualizador puede manejar.
Preguntas similares:
¿Cómo pongo un Applet en una página JSP?
Respuesta: Envié una etiqueta del <APPLET…> al cliente.
¿Cómo pongo una imagen en una página JSP?
Respuesta: Envié una etiqueta de la <IMG…> al cliente.
¿Cómo uso un JavaScript/Acrobat/Shockwave/etc?
Respuesta: Envié las etiquetas correspondientes del HTML.
13
2do Malentendidos comunes:
Tiempo de Traducción/Petición
¿Qué sucede al momento de traducción de la página
JSP?
¿Qué pasa en el momento de la petición?
Las JSPs se traducen a código Servlet.
El código del Servlet es ejecutado,
Ninguna interpretación del JSP ocurre al momento de la
petición,
La página JSP original es ignorada al momento de la
petición; solo el Servlet que resulte de la JSP es el que se
toma en cuenta.
¿Cuándo ocurre la traducción de la página?
Generalmente la primera vez que la página JSP es invocada
después de ser modificada,
Esto no debería suceder a usuarios reales – los
desarrolladores deben probar las páginas que instalan,
La traducción de páginas no ocurre en cada petición.
14
http://www.delta.com/
15
https://portal.banamex.com.mx/esp/empresarial/monarca/login.jsp
16
http://www.excite.com/
17
Configurando el medio ambiente.
Configurar CLASSPATH.
Compilar el código
Utilizar los paquetes para evitar conflictos de
nombres.
Coloque la página JSP en el directorio correcto:
<tomcat_home>/Webapps/ROOT.
Use el URL especial para invocar la página JSP.
Advertencias:
Las reglas utilizadas para el acceso al CLASSPATH,
instalación de directorios, etc., aun se aplican a las clases
utilizadas en JSP.
18
Ejemplo.
19
Ejemplo
Con la configuración por defecto, si la
localización es:
<tomcat_home>/Webapps/ROOT/Expression.jsp
EL URL debe ser:
http://localhost:8080/Expressions.jsp
20
Ejemplo
21
Elementos del JSP Scripting
22
Uso de las JSPs
Los elementos de Scripting
Aplicaciones simples
llaman al código del Servlet
directamente.
Los elementos de Scripting llaman
al código del Servlet
indirectamente mediante clases
de uso general(utilities).
Uso de Beans.
Etiquetas personalizadas.
Servlet/JSP combo.
Aplicaciones complejas
23
Tipos de elementos de Scripting
Expresiones:
Scriptlets:
Formato <%=expression %>
Se evalua e inserta en la salida del Servlet, ej., el
resultado en algo como: out.println(expression).
Formato <%code%>
Insertado textualmente dentro del método _jspService en
los Servlet’s (llamada al servicio).
Declaraciones:
Formato <%! code%>
Insertado textualmente dentro del cuerpo de la clase del
Servlet, fuera de cualquier método existente.
24
Expresiones JSP
Formato:
Resultado:
Expresión evaluada, convertida a cadena, y puesta en la
página HTML en el lugar donde ocurrió en la página JSP.
Es decir, la expresión se pone en el _jspService dentro de
out.print.
Ejemplos:
<%= Expresión Java %>
Tiempo actual: <%=new java.util.Date()%>
Tu nombre de maquina: <% request.getRemoteHost()%>
Sintaxis compatible XML :
<jsp:expression> Java Expression </jsp:expression>
Versión de XML no suportada por Tomcat 3.1
Hasta la versión JSP 1.2, los servidores no tiene que darle
soporte.
25
Correspondencia JSP/Servlet
Original JSP:
<H1> A Random Number </H1>
<%= Math.random() %>
Resultado posible del código Servlet:
public void _jspService(HttpServletRequest request,
HttpServletResponse response) throws ServletException
IOException{
request.setContentType(“text/html”);
HttpSession session = request.get Session(true);
JspWriter out = response.getWriter();
out.println(“<H1> Random Number</H1>);
out.println(Math.randon());
…
}
26
Ejemplo usando expresiones JSP
27
Variables predefinidas
Request:
Response:
El HttpSession asociada a la petición (al menos que fuera
deshabilitada con el atributo de la directiva de sesión).
Out:
El HttpSerlvetResponse – 2do argumento para doGet();
Session:
El HttpServletRequest – 1er argumento para doGet();
El flujo de datos (de tipo JspWriter) usado para enviar la
salida al cliente.
Application:
El ServletContext (para compartir datos) como fue
obtenido vía getServletConfig().getContext().
28
Objetos Implícitos
Objeto
Contexto
Descripción
Ámbito
request
HttpServletRequest
Invocación del servicio
Petición
response
HttpServletResponse
Respuesta a la Petición
Página
pageContext
jsp.PageContext
Características de la página
Dependientes de la
implementación, espacios de
nombres y otras facilidades
Página
session
http.HttpSession
Conserva el estado de la
session
Sesión
application
ServletContext
Contexto del servlet
de configuración
Aplicación
out
jsp.JspWriter
Flujo de salida
Página
config
ServletConfig
Configuración del servlet del
JSP
Página
page
Object
Página que procesa
la petición en curso
Página
29
JSP Scriptlets
Formato:
Resultado:
El código insertado textualmente en el
_jspService del Servlet.
Ejemplo:
<% Código Java %>
<%String queryData = request.getQueryString();
out.println(Attached GET data: “ + queryData);%>
<%response.setContentType(text/plain”); %>
Sintaxis compatible XML:
<%jsp:scriptlet> Código Java </jsp:scriptlet>%>
30
Correspondencia JSP/Servlet
Original JSP:
<%= foo() %>
<%= bar() %>
Posible resultado del código Servlet:
public void _jspService(HttpServletRequest request, HttpServletResponse
response) throws ServletException IOException{
request.setContentType(“text/html”);
HttpSession session = request.get Session(true);
JspWriter out = response.getWriter();
out.println(foo());
out.println(bar());
…
}
31
Ejemplo usando JSP Scriptlets
32
Ejemplo usando JSP Scriptlets
33
Declaraciones JSP
Formato:
Resultado:
El código se inserta textualmente en la
definición de la clase del Servlet, fuera de
cualquier método existente.
Ejemplos:
<%! Código Java %>
<%! private int algunCampo=5;%>
<%! private void AlgunMetodo(…) {…} %>
Sintaxis compatible XML :
<jsp:declaration> Código Java </jsp:declaration>
34
Declaraciones JSP
JSP:
<H!>Someheading</H1>
<%!
private String randomHeading(){
return(“<H2>” + Math.random() + “</H2>”);
}
%>
<%= randomHeading()%>
35
Ejemplo usando declaraciones JSP
<!DOCTYPE HTML PUBLIC "//W3C//DTD HTML 4.0
Transitional//EN">
<HTML>
<HEAD>
<TITLE>JSP
Declaraciones</TITLE>
</HEAD>
<BODY>
<H1>JSP Declaraciones</H1>
<%! private int accessCount = 0; %>
<H2>Accesses to page since server
reboot:
<%= ++accessCount %></H2>
</BODY>
</HTML>
36
Ejemplo de una Página JSP:
La siguiente página JSP presenta un saludo.
<%-- Esta página da un saludo y despedida --%>
<HTML>
<BODY>
<H1>Bienvenido a JSP!</H1>
<% out.println("Regrese pronto”); %>
</BODY>
</HTML>
N
bienvenido
helloworld
hellouser
response
NameHandler
37
Ámbito y Visibilidad de los Objetos JSP
Los objetos JSP pueden crearse:
implícitamente por directivas JSP
explícitamente a través de acciones
excepcionalmente usando fragmentos de código
El ámbito del objeto establece su duración
desde su creación hasta su destrucción; su
visibilidad indica los lugares de la página
donde puede usarse el objeto.
38
Ámbito y Visibilidad de Objetos
La siguiente tabla muestra los ámbitos que pueden asociarse a los
objetos recién creados.
Ámbito
Categoría
Descripción
4 (mayor)
Aplicación
Pertenecen a la
misma aplicación
3
Sesión
Pertenecen a la
misma sesión
2
Petición
Provienen de la
petición que es
Atendida
1 (menor)
Página
Pertenecen a la
página en que
fueron creados
39
Objetos Implícitos
Debido a que la tecnología JSP se basa en
aquella de los servlets, existe un conjunto de
objetos predefinidos cuyos nombres pueden
usarse inmediatamente en JSP.
40
Ejemplo
Este ejemplo muestra los cuatro ámbitos de los
objetos JSP.
<%@page import=“java.util.*”%>
<HTML>
<BODY>
Servlet <%= config.getServletName() %><br>
<%
for (int scope = 1; scope <= 4; scope++) {
out.println("<H2>Ambito "+scope+"</H2>");
Enumeration e = pageContext.getAttributeNamesInScope(scope);
while (e.hasMoreElements()) {
out.println(e.nextElement()+”<br>”);
}
}
%>
</BODY>
</HTML>
41
ambitos
Resumen de Elementos Básicos de JSP
Elementos que se intercalan entre aquellos de HTML o XML.
Elemento
Sintaxis
Descripción
Directiva
<%@ . . . . . . . . %>
Importar clases o incluir
archivos HTML
Declaraciones
<%! . . . . . . . . . . %>
Declarar variables o
métodos Java
Expresiones
<%= . . . . . . . . .. %>
Evaluación de expresiones
Java
Scriptlets
<% .. . . . . . . . . .. %>
Ejecución de
instrucciones
Java
Comentarios
<%-- .. . . . .. . . -- %>
Texto no procesado
42
JSP: Resumen Elementos Básicos
Directivas
Las directivas son instrucciones dirigidas al contenedor de servlets
JSP, no al flujo de salida.
Las directivas determinan los atributos de la página y las dependencias
con el contenedor.
La directiva de página tiene la forma:
<%@ page atributos %>
donde los atributos pueden ser:
language que indica el lenguaje usado en la página JSP,
import que establece las clases que se van usar
extends que indica las clases que serán extendidas
include que inserta un archivo HTML
session que cuando toma el valor true, permite usar la variable predefinida
session en la página JSP
buffer que establece el tamaño del área temporal de la página
autoflush que indica si el envío al flujo de salida es inmediato
isThreadSafe que establece que a lo más un proceso está activo a la vez
(por omisión, se tienen múltiples procesos concurrentes)
errorPage que permite indicar si la página se usa para anunciar un error
43
Ejemplos de Directivas
Las directivas:
<%@ page import=”java.sql.*,java.util.*” %> importa
los paquetes java.sql y java.util
<%@ page include=”sty.css” %> inserta los estilos para el
documento que están guardados en el archivo sty.css
<%@ page buffer=”16k” %> establece el tamaño del buffer a
16k
<%@ page isThreadSafe=”true” %> establece que hay sólo
un proceso activo a la vez
44
Declaraciones
La sintaxis de una declaración es <%! declaración %>
o, alternativamente, usando los espacios de nombres
de
XML
<jsp:declaration>
declaración
</jsp:declaration>
Las declaraciones permiten introducir variables y
métodos a nivel de página y deben seguir la sintaxis de
Java.
Las variables declaradas pueden inicializarse y deben
estar terminadas por punto y coma.
Las declaraciones de métodos, además de aquellos
usados en la aplicación, pueden también incluir a
jspInit() y jspDestroy().
45
Ejemplo de Declaración
Código de iniciación para un contador en una
página JSP que declara una variable y los
métodos jspInit() y jspDestroy():
<%! int counter;%>
<%! public void jspInit() {
counter = 0;
}
public void jspDestroy() {
}
%>
46
Expresiones
La sintaxis de una expresión es <%= expresión %> o,
alternativamente, usando los espacios de nombres de XML
<jsp:expression> expresión </jsp:expression>
Las expresiones en JSP permiten que el resultado de la evaluación de
una expresión Java se convierta a una cadena de caracteres que será
incluida en la página generada.
Las expresiones pueden incluirse en gran variedad de contextos y no
deben terminarse por puntos y comas.
Ejemplo de Expresiones
La siguiente expresión produce un elemento H1 usado para escribir el texto
de un encabezado:
<%! int i = 1; %>
<H<%=i%>>Java Server Pages</H<%=i>>
47
Scriptlets
La sintaxis de un scriptlet es <% scriptlet %> o,
alternativamente, usando los espacios de nombres de
XML <jsp:scriptlet> scriptlet </jsp:scriptlet>
Se puede escribir cualquier fragmento de código Java,
extendido por elementos HTML y no limitado a una
línea.
Ejemplo de Scriptlets: El siguiente scriptlet produce
una
secuencia
de
encabezados
con
tamaño
decreciente:
<% for (int i=1; i<5; i++) { %>
<H<%=i%>>Java Server Pages</H<%=i>>
<% } %>
48
Comentarios
comentarios JSP usan elementos especiales,
Los
distintos de los comentarios de HTML, para que no
puedan verse en los documentos enviados al cliente.
Los comentarios pueden usarse también para bloquear
la ejecución de ciertos fragmentos de la página JSP.
Ejemplo: La siguiente instrucción no será ejecutada (ni
siquiera será visible en la página enviada al cliente)
<%-- int i = 1; --%>
49
JSP: Ejemplo (contador de accesos)
Ejemplo de Contador de Accesos: La siguiente página
JSP muestra un contador de accesos a una página.
<%-- Esta página da la fecha y hora cuando fue soliciatada así como el
número de accesos --%>
<%@ page import="java.util.*"%>
<%! Date loadDate = new Date();
int loadCounter = 1;
%>
<HTML>
<BODY>
<H1>Bienvenido!</H1>
<H2>Desde <%=loadDate%>,
ésta página ha sido accesada <%=loadCounter%>
<% if (loadCounter++ == 1)
out.println("vez.<BR>");
else
out.println("veces.<BR>");
%>
<% out.println("Regrese pronto"); %>
</H2>
</BODY>
</HTML>
50
contadoryfecha
JSP: Ejemplo (uso de formularios)
Ejemplo con Formas: El siguiente ejemplo demuestra
como obtener los valores de un formulario.
<%@page import="java.util.*"%>
<HTML>
<BODY>
<%Enumeration fields = request.getParameterNames();%>
<TABLE border="1" >
<TR><TH>Nombre</TH><TH>Valor</TH></TR>
<% while (fields.hasMoreElements()) { %>
<TR>
<%String field = (String)fields.nextElement();%>
<TD align=center><%=field%></TD>
<TD align=center> <%=request.getParameter(field)%></TD>
</TR>
<%}%>
</TABLE>
</BODY>
</HTML>
51
formulario
programa
JSP: Manejo de Concurrencia
Concurrencia
La directiva page con el atributo isThreadSafe ofrece una
forma de evitar los problemas que ocasiona la concurrencia.
El problema con este enfoque es que no es escalable, reduciendo
considerablemente el desempeño de sistemas con muchos
procesos.
Una alternativa es usar regiones críticas en scriptlets para
sincronizar el acceso a objetos compartidos.
<%@page import=”java.util.*”%>
<% synchronized (application)
{
Properties list = application.getAttribute(“users”);
list.add(“ana”,new User(“ana”))
list.setAttribute(“users”,list);
}
%>
52
JSP: Manejo de Excepciones
Manejo de Excepciones
JSP posee un mecanismo apropiado para el manejo de
errores que ocurren a tiempo de ejecución.
El atributo errorPage de la directiva page se usa para
indicar que la página recibe las excepciones lanzadas
por algún scriptlet.
Además, el atributo errorPage de la misma directiva
indica la página JSP a la cual se redirigirá el objeto
implícito exception (de tipo Throwable) que describe el
problema.
53
JSP: Manejo de Excepciones…
Ejemplo de manejo de excepciones
Para manejar errores a tiempo de ejecución, se puede
usar una página que indique la naturaleza del error.
Dicha página debe incluir entre sus directivas la
siguiente:
<%@page isErrorPage=”false” errorPage=”Error.jsp”%>
la página redirige a su vez el objeto exception a la
página Error.jsp .
La página Error.jsp debe contener a su vez, la
directiva:
<%@page isErrorPage=”true” %>
Esta indicación permite acceder al objeto exception
en la página Error.jsp .
54
JSP: Manejo de Sesiones
Manejo de Sesiones
Por omisión todas las páginas JSP participan en una sesión HTTP.
El objeto session (de tipo HttpSession) está disponible para
almacenar objetos que persistan a lo largo de la vida de la
aplicación.
El atributo session de la directiva page se usa para permitir o
negar el acceso al objeto session en la página; por omisión, el
objeto session es accesible.
La directiva <%page session=”false”%> indica que en la página
no se usarán sesiones.
Una sesión se identifica por un nombre único de sesión y se
almacena en el browser del cliente en forma de cookie; si el
browser no maneja cookies, la sesión se mantiene por
reescritura del URL.
La sesión mantiene referencias a todos los objetos almacenados
pero tan pronto como la sesión es invalidada o el plazo de los
objetos expira, los objetos se marcan para su recolección como
basura.
55
JSP: Manejo de Sesiones….
Manejo de Sesiones
No se pueden guardar tipos simples en una sesión, pero se puede
guardar cualquier tipo de objeto identificado por una cadena
única de caracteres.
El siguiente scriptlet hace al objeto Book públicamente
disponible para todas las páginas y servlets JSP que compartan la
misma sesión:
<% Book book = new Book();
session.putValue(“book”,book);
%>
El objeto book puede recuperarse realizando una coerción para
convertirlo al tipo apropiado:
<% Book book = (Book)session.getValue(“book”); %>
No hay límite en el número de objetos que se pueden manejar en
una sesión, aunque un gran número de ellos reducirá el
rendimiento del sistema.
Generalmente, la duración de una sesión está limitada a 30
minutos, aunque la duración puede ampliarse regularmente usando
el método setMaxIntactiveInterval(int secs).
56
JSP: Ejemplo de Sesiones
<%--session.jsp: Ejemplo de una sesion--%>
<HTML>
<BODY>
<H1>Sesion <%=session.getId()%></H1>
<P>La session fue creada el <%=session.getCreationTime()%>
<P>Duracion usual de la session:<%=session.getMaxInactiveInterval()%>
<P>Reducción de la duracion de la session a 5 segundos
<%session.setMaxInactiveInterval(5);%>
<P>Nueva duracion de la session:<%=session.getMaxInactiveInterval()%>
<P>Depositar un objeto nuevo
<%session.setAttribute("bible",new String("Sacred Bible"));%>
<P>Mostrar el objeto depositado:<%=session.getAttribute("bible")%>
</BODY>
<HTML>
session
57
JSP: Ejemplo de Sesiones
<%--session1.jsp: Ejemplo de una sesion con invalidacion--%>
<HTML>
<BODY>
Sesion <%= session.getId() %>
<% if (session.getAttribute("bible")==null) {
session.setAttribute("bible",new String("Sacred Bible"));
out.println("<P>Depositar un nuevo libro:"
+session.getAttribute("bible"));
} else {
out.println("<P>Recuperar el libro:"
+session.getAttribute("bible"));
}
%>
<FORM TYPE="post" ACTION="session2.jsp">
<INPUT TYPE="submit" NAME="invalidar“ VALUE="invalidar">
</FORM>
<INPUT TYPE="submit" NAME="conservar“ VALUE="conservar">
</FORM>
</BODY>
session1
</HTML>
58
JSP: Ejemplo de Sesiones (Cont..)
Los archivos session2.jsp y session3.jsp son llamados por session1.jsp.
<%--session2.jsp: Ejemplo de una sesion con invalidacion--%>
<%@page isErrorPage="false“ errorPage="ErrorPage.jsp"%>
<HTML>
<BODY>
Sesion <%=session.getId()%>
<P>Recuperar al libro: <%= session.getValue("bible") %>
<P>Invalidar la session <% session.invalidate(); %>
<P>Recuperar de nuevo al libro: <%= session.getValue("bible") %>
<INPUT TYPE="submit" NAME="submit“ VALUE="regresar">
</FORM>
</BODY>
</HTML>
<%--session3.jsp--%>
<HTML>
<BODY>
Sesion <%=session.getId()%>
<P>Recuperar el libro: <%= session.getValue("bible") %>
<FORM TYPE=”post” ACTION=”session1.jsp”>
<INPUT TYPE=”submit” NAME=”submit” VALUE=”regresar”>
</FORM>
</BODY>
session2
session3
</HTML>
ErrorPage
59
JSP: Uso de Cookies
Uso de cookies
cookies ya fueron introducidas en la
Las
programación con servlets; en JSP es igual de simple
su programación.
Las cookie se obtienen de la petición HTTP (objeto
request) y se mandan a la respuesta HTTP (objeto
response) siempre que el cliente acepte las cookies.
Una vez obtenida una cookie de la petición, ésta se
puede leer, modificar y alterar su fecha de
expiración (cambiando su edad máxima).
Además, en cualquier momento se puede agregar
nuevas cookies a las ya existentes.
60
JSP: Ejemplo de Cookies
<%--Cookies.jsp: Este programa puede comportarse
distinto en diferentes browsers--%>
<HTML>
<BODY>
Session <%= session.getId() %>
<% Cookie[] cookies = request.getCookies();
for(int i = 0; i < cookies.length; i++) { %>
Cookie con nombre: <%= cookies[i].getName() %> <br>
Valor: <%= cookies[i].getValue() %><br>
Duración máxima en segundos: <%= cookies[i].getMaxAge() %><br>
<% cookies[i].setMaxAge(5); %>
Nueva duración en segundos: <%= cookies[i].getMaxAge() %><br>
<% } %>
<%! int count = 0; int dcount = 0; %>
<% response.addCookie(new Cookie("Bob" + count++,"Dog" + dcount++)); %>
</BODY>
</HTML>
Cookies
61
JSP: Acciones comunes
Acciones Comunes
Las acciones permiten realizar tareas sofisticadas
reduciendo
considerablemente
la
codificación
requerida en Java.
Las
acciones se manifiestan usando elementos
especiales (tags) los cuales promueven la reutilización
de componentes mejorando el mantenimiento de la
aplicación.
Algunas acciones más populares son:
usar componentes JavaBeans
redirigir mensajes
encadenar peticiones
incluir peticiones
62
JSP: Usar componentes JavaBeans
El modelo de componentes de JSP se basa en la
tecnología JavaBeans que son objetos con un esquema
de nombramiento bien definido.
Un bean encapsula sus propiedades, como variables
privadas, las cuales se pueden leer o modificar usando
métodos públicos apropiados.
Un bean debe identificarse con un nombre con ámbito
de sesión antes de que pueda usarse; el elemento XML
<jsp:useBean
id=”bookBean”
class=”com.beans.books”
scope=”session”/>
crea una instancia del Bean y lo agrega a la sesión;
si se encuentra este elemento en otra página, el
objeto se recuperará entonces de la sesión.
63
El elemento jsp:useBean también puede tener estructura, la cual
consiste de un scriptlet que realiza la iniciación de las
propiedades del bean cuando éste se crea.
<jsp:useBean id=”bookBean” class=”com.beans.books” scope=”session”>
<% iniciación de propiedades del bean %>
</jsp:useBean>
Una vez declarados los beans, sus propiedades pueden accederse
usando el elemento
<jsp:getProperty name=”book” property=”name”/>
Para cambiar el valor de una propiedad, se usa el elemento
<jsp:setProperty name=”book” property=”name” value=”Thinking in Java”/>
En el procesamiento de formas es muy conveniente usar las
facilidades que brinda JSP para copiar los valores asociados de
los campos a los atributos del bean.
64
El elemento
<jsp:setProperty name=”book” property=”*”/>
copia los valores pero sólo cuando los nombres en
ambos (los campos de la forma y los atributos del
bean) coinciden.
Cuando
los
nombres
no
coinciden,
la
correspondencia se debe hacer explícita:
<jsp:setProperty name=”book” property=”propName” parameter=”parmName”/>
65
JSP: Ejemplo de JavaBeans
El siguiente JSP es un juego para adivinar un número.
Copyright (c) 1999 The Apache Software Foundation.
All rights reserved. Number Guess Game
Written by Jason Hunter, CTO, K&A Software http://www.servlets.com
-->
<%@ page import = "num.NumberGuessBean" %>
<jsp:useBean id="numguess“ class="num.NumberGuessBean" scope="session"/>
<jsp:setProperty name="numguess" property="*"/>
<html>
<head><title>Number Guess</title></head>
<body bgcolor="white"> <font size=4>
<% if (numguess.getSuccess()) { %>
Congratulations! You got it.
And after just <%= numguess.getNumGuesses() %>
tries.<p>
<% numguess.reset(); %>
Care to <a href="numguess.jsp">try again</a>?
<% } else if (numguess.getNumGuesses() == 0) { %>
Welcome to the Number Guess game.<p>
numguess
66
JSP: Ejemplo de JavaBeans (Cont…)
I'm thinking of a number between 1 and 100.<p>
<form method=get>
What's your guess? <input type=text name=guess>
<input type=submit value="Submit">
</form>
<% } else { %>
Good guess, but nope. Try <b>
<%= numguess.getHint() %></b>.
You have made <%= numguess.getNumGuesses() %>
guesses.<p>
I'm thinking of a number between 1 and 100.<p>
<form method=get>
What's your guess? <input type=text name=guess>
<input type=submit value="Submit">
</form>
<% } %>
</font>
</body>
</html>
67
El siguiente JavaBean se usa en el juego de adivinanza de números.
/* Originally written by Jason Hunter */
package num;
import java.util.*;
public class NumberGuessBean {
int answer;
boolean success;
String hint;
int numGuesses;
public NumberGuessBean() {
reset();
}
public void setGuess(String guess) {
numGuesses++;
int g;
try {
g = Integer.parseInt(guess);
}
catch (NumberFormatException e) {
g = -1;
}
if (g == answer) { success = true; }
else if (g == -1) {hint = "a number next time";
NumberGuessBean
68
}
else if (g < answer) { hint = "higher";}
else if (g > answer) { hint = "lower"; }
}
public boolean getSuccess() {
return success;
}
public String getHint() {
return "" + hint;
}
public int getNumGuesses() {
return numGuesses;
}
public void reset() {
answer = Math.abs(new Random().nextInt() % 100) + 1;
success = false;
numGuesses = 0;
}
}
69
JSP: Redirigir mensajes
Una petición se puede redirigir hacia otra página JSP, servlet o
página HTML estática pasándole el contexto de la página que
hace la invocación.
El procesamiento continúa hasta el punto en el que ocurre la
redirección para entonces detenerse por completo en esa página.
El elemento <jsp:forward page=”anotherPage.jsp”/> redirige el
procesamiento a la página anotherPage.jsp conservando todo el
procesamiento realizado en la página actual.
Un elemento <jsp:forward> también puede tener parámetros para
proporcionar valores a la página invocada:
<jsp:forward page=”anotherPage.jsp”>
<jsp:param name=”aName1” value=”aValue1”/>
<jsp:param name=”aName2” value=”aValue2”/>
</jsp:forward>
70
JSP: Ejemplo, redirigir mensajes
<html>

<% double freeMem = Runtime.getRuntime().freeMemory();
double totlMem = Runtime.getRuntime().totalMemory();
double percent = freeMem/totlMem;
if (percent < 0.5) {
%>
<jsp:forward page="/jsp/forward/one.jsp"/>
<% } else { %>
<jsp:forward page="two.html"/>
<% } %>
</html>
71
JSP: Ejemplo, redirigir mensajes (Cont….)

<html>
<body bgcolor="white">
<font color="red">
VM Memory usage < 50%.
</html>

<html>
<font color="red">
VM Memory usage > 50%.
</html>
72
JSP: Incluir páginas
El elemento <jsp:include> puede usarse para redirigir
una petición a cualquier página estática o dinámica que
esté en el mismo contexto.
La llamada también puede incluir los beans como
parámetros de la petición.
Por
ejemplo,
el
elemento
<jsp:include
page=”shopingCart.jsp” flush=”true”/>
permite tener
acceso a cualquier bean y al contexto dinámico
generado por la página invocante;
finalmente, el contenido generado se inserta en el
lugar del elemento <jsp:include>.
La página incluida no puede hacer algunas cosas como
encabezados HTTP o hacer galletas.
73
JSP: Ejemplo de incluir páginas
La siguiente página inserta la fecha producida por otra.
<html>
<font color="red">
<%@ page buffer="5k" autoFlush="false" %>
<p>In place evaluation of another JSP which gives
you the current time:
<%@ include file="foo.jsp" %>
<p> <jsp:include page="/jsp/include/foo.html“ flush="true"/>
by including the output of another JSP:
<jsp:include page="foo.jsp" flush="true"/>
:-)
</html>
El JSP que produce la hora:
<font color="red">
<%= System.currentTimeMillis() %>
74
Repaso a la directiva page de JSP :
Usada como forma para estructurar los Servlets
generados
75
Propósito de la directiva page
Dar información de alto nivel a cerca del
Servlet que resulte del JSP.
Puede controlar:
Qué clases son importadas,
Qué clases el Servlet extiende o hereda,
Qué tipo MIME se genera,
Cómo se maneja el multi-threading.
Si el Servlet participa en sesiones,
El tamaño y compartimiento del buffer de salida,
Qué página maneja los errores inesperados.
76
El atributo Import
Formato:
Propósito:
<%@ page import=“package.class” %>
<%@ page import=“paqckage1,…, package.classN”%>
Generar las declaraciones para importar clases en la parte
superior del Servlet.
Notas:
Aunque las páginas JSP pueden estar casi en cualquier parte
del servidor, las clases usadas por JSP deben estar en
directorios comunes del Servlet.
Por ejemplo, con Tomcat esto es:
$CATALINA_HOME/Webapps/ROOT/Web-INF/classes
77
Ejemplo del atributo import
mab.*
78
Ejemplo del atributo import
Primer Acceso
Acceso Posterior
79
El atributo contentType
Formato:
<%@ page contentType=“MIME-Type”%>
<%@ page contentType=“MIME-Type;
charset=Character-Set”%>
Proposito:
Especifica el tipo MIME de la página generada
por el Servlet que resulta de la página JSP .
80
El atributo contentType
First Last
Email Address
Mark Baker [email protected]
Larry Brown [email protected]
Bill
Gates [email protected]
Larry Ellison [email protected]
<%@ page contentType="application/vnd.ms-excel" %>
<%-- Son tabs en lugar de espacios entre las columnas --%>
81
El atributo isThreadSafe
Formato:
Propósito:
<%@ page isThreadSafe=“true”%> <%-- Default--%>
<%@ page isThreadSafe=“false”%>
Le dice al sistema cuando el código no es threadsafe, de
modo que el sistema pueda prevenir accesos
concurrentes – instruye al Servlet a implementar un
SingleThreadModel.
Notas:
Por defecto es true – El sistema asume que se tienen
actualizaciones a campos y otros datos compartidos
sincronizadamente.
Proporcionando el valor false se puede afectar el buen
desempeño.
82
Código Non-threadsafe
¿Cuál es el problema con este código?
<%! private int idNum = 0;%>
<%
String UserID = “userID” + idNum;
out.println(“Your ID is “ + userID + “.”);
idNum = idNum + 1;
%>
83
Código Threadsafe
<%! private int idNum = 0;%>
<%
synchronized(this) {
String UserID = “userID” + idNum;
out.println(“Your ID is “ + userID + “.”);
idNum = idNum + 1;
}
%>
acceso seguro a una variable compartida usando la
declaración de sincronización normal.
84
Otros atributos de
la directiva de page
Session:
Buffer:
Cambia la clase padre del Servlet generado.
Error:
Requiere al desarrollador explícitamente vaciar el buffer.
Extends:
Cambia el tamaño minimo del buffer usado por el
JspWriter.
Autoflush:
Permite Elegir no participar en sesiones.
Indica una página para manejar los errores inesperados.
isErrorPage:
Indica que la página se puede utilizar como página del
error.
85
Incluyendo archivos en documentos JSP
86
Incluyendo páginas al momento de la
petición
Formato:
<%jsp:include page=“URL relativo” flush=“true”%>
Propósito:
Reutilizar contenido JSP, HTML o texto plano.
El contenido JSP no puede afectar la página
principal – Solamente es utilizada la salida de
JSP incluido.
Permitir actualizaciones al contenido incluido sin
cambiar la página principal.
87
Ejemplo de inclusión de páginas
88
Ejemplo de inclusión de páginas
89
Incluyendo archivos al momento
de la traducción de la página.
Formato:
<%@include file=“Relative URL”%>
Propósito:
Reutilizar contenido JSP en múltiples páginas, donde el
contenido JSP afecta la página principal.
Notas:
Los servidores no tiene que detectar cambios en los
archivos incluidos, y en la práctica muchos no lo hacen – de
otra manera se necesita cambiar los archivos JSP cuando
los archivos incluidos cambian.
Puede utilizar mecanismos específicos del sistema
operativo tal como el comando touch de UNIX:
<%-- Navbar.jsp modified 27/01/03--%>
<%@include file=“Navbar.jsp%>
90
Contenido JSP reutilizable:
Ejemplo: ContactSection.jsp
<%@ page import="Java.util.Date" %>
<%-- Los siguientes viene a ser campos en cada Servlet que resulta de una
página JSP que incluye este archivo. --%>
<%!
private int accessCount = 0;
private Date accessDate = new Date();
private String accessHost = "<I>No previous access</I>";
%>
<P>
<HR>
This page © 2000
<A HREF="http//www.my-company.com/">my-company.com</A>.
This page has been accessed <%= ++accessCount %>
times since server reboot. It was last accessed from
<%= accessHost %> at <%= accessDate %>.
<% accessHost = request.getRemoteHost(); %>
<% accessDate = new Date(); %>
91
Usando el ContactSection
Embebido en la
página Web:
<HTML>
<BODY>
<HR>
<H1> My Page</H!>
<HR>
<%@ include
file=“contactSection.jsp” %>
</BODY>
</HTML>
92
Creando bibliotecas de etiquetas JSP
personalizadas
Los bibliotecas de etiquetas JSP (JSP TL)
permiten definir y utilizar etiquetas JSP similares
a como se definen y usan en funciones típicas en
los lenguajes de programación.
93
Bibliotecas de etiquetas JSP
La introducción de los Servlets en 1996 hizo a Java
una opción razonable para el desarrollo de páginas
Web dinámicas.
El debut de JavaServer Pages (JSP) seguido por la
inclusión del soporte para etiquetas JSP, fueron
pasos lógicos en la evolución hacia una rápida y
mantenible implementación de páginas Web en Java.
Pero la liberación de JSTL (JSP Standard Tag
Library) hecha a mediados del 2002 representa tal
vez el paso más grande en cuanto a velocidad y
simplificación del proceso de desarrollo.
JSP 2.0 fue liberado en el 2004 y trajo nuevas
mejoras y ayudas adicionales, Tomcat 5.5 comenzó a
darle soporte a esta versión en el 2004.
94
La biblioteca de etiquetas JSP
Las páginas JSTL son también páginas JSP:
También, todas las etiquetas JSTL es XML válido:
Eso significa que si trata el contexto de una página fuera de las
etiquetas JSTL como una plantilla de texto (el cual normalmente
será HTML), las etiquetas JSTL restantes deben ser tratadas
como XML válido.
JSTL proporciona un conjunto de cuatro bibliotecas estándares
(core, internationalization/format, XML y SQL) y soporte para
un lenguaje de expresiones (EL: Expression Language).
JSTL es justamente un súper conjunto de la funcionalidad del JSP.
Un objetivo primario del diseño para JSTL y de EL fue simplificar
el desarrollo e implementación de las páginas Web.
Una etiqueta JSTL corresponde a alguna acción; llamándolas
acciones, nos recuerdan explícitamente que están agregando
comportamiento dinámico a una página que de otra manera sería
estática.
Puede usarse tanto expresiones JSP como JSTL EL.
95
¿Cómo obtener la Librería de
Etiquetas?
El proyecto Apache Taglibs es un repositorio opensource para las bibliotecas de etiquetas
personalizadas JSP y proyectos asociados, tales
como las clases TagLibraryValidator y extensiones
a herramientas para creación de páginas
que
soportan biblioteca de etiquetas.
Jakarta Taglibs http://jakarta.apache.org/taglibs/
Para utilizar el estándar Taglib de la distribución
Jakarta Taglibs, simplemente copie los archivos
JAR que están en el directorio lib de la distribución
al directorio de la aplicación Web-INF/lib.
JSTL 1.0 API classes: jstl.jar,
Standard Taglib JSTL implementation classes:
standard.jar.
96
Instalando JSTL
Para utilizar el JSTL, se debe tener un contenedor
JSP 1.2 (o superior) instalado.
Uno de los contenedores JSP mas comúnmente utilizados es
el servidor Web Apache Tomcat .
Usando sólo Tomcat podrá usar código JSP normal.
Para utilizar JSTL, se deberá instalar JSTL en
Tomcat.
JSTL se puede obtener del mismo lugar que el
Tomcat.
El URL principal para el JSTL es
http://Java.sun.com/products/jsp/jstl/
Para usar JSTL, se deberá descomprimir los archivos de la
distribución e instalarlos en el lugar correcto dentro de
Tomcat.
97
Instalando el JSTL
Copie el archivo JAR del JSTL al directorio lib de Tomcat:
Copie los archivos JSTL TLD al directorio WEB-INF de
Tomcat:
Si usas Windows la localización del directorio lib normalmente es
$CATALINA_HOME\Webapps\ROOT\WEB-INF\lib.
El directorio Web-INF normalmente es:
$CATALINA_HOME\ROOT\WEB-INF\tags\.
Si tu examinas los archivos de la distribución JSTL, notarás que
hay ocho con la extensión TLD que deberán ser copiados al
directorio WEB-INF.
Modificar el archivo Web.xml para incluir los archivos .tld:
Finalmente se deberá modificar el archivo Web.xml y agregar una
entrada para los archivos tag libraries que usted agregue. Esto
consiste en agregar directivas <taglib> dentro de la directiva
principal <Web-app>.
98
Instalando JSTL – Web.xml
99
Instalando JSTL
Después de completar los tres pasos anteriores, esta
listo para probar la instalación del JSTL.
Esto puede ser hecho creando una página JSP que
utilice JSTL.
Se debe de colocar el archivo JSP dentro del
directorio raíz del Web.
($CATALINA_HOME\Webapps\ROOT).
Una vez que el servidor Tomcat es iniciado, se debe
ahora poder visualizar
http://localhost:8080/XXXX.jsp para ver su página.
100
Instalando JSTL
Si no se tiene instalado correctamente el JSTL,
normalmente no habrá mensaje de error.
Si JSTL no esta interpretando sus etiquetas, éstas
serán pasadas directamente al visualizador Web.
El Visualizador Web interpretara estas etiquetas
como etiquetas desconocidas del HTML.
La mayoría de los visualizadores Web normalmente
ignoran estas etiquetas desconocidas.
101
Bibliotecas de etiquetas JSTL
Se habla comúnmente de JSTL como una biblioteca de
etiquetas simple.
JSTL son en realidad cuatro bibliotecas de etiquetas.
Estos bibliotecas son:
Core Tag Library – etiquetas que son esenciales para cualquier
aplicación Web. Ejemplos de esta biblioteca de etiquetas incluyen
ciclos, evaluacion de expresiones, entradas y salidas basicas.
Formatting/Internationalization Tag Library – etiquetas que se
utilizan para analizar datos. Algunas de estas etiquetas analizarán
datos, tales como fechas basadas en forma diferente dependiendo
de la localizacion.
Database Tag Library – etiquetas que pueden ser utilizar para
tener acceso a las bases de datos con SQL.
XML Tag Library – etiquetas que se pueden utilizar para tener
acceso a elementos XML. Debido a que XML es utilizado en muchas
aplicaciones Web, el procesamiento de XML es una característica
importante de JSTL.
102
Lenguaje de expresiones (EL)
(EL) define un lenguaje para expresar expresiones
simples en una sintaxis que sea fácil de aprender.
(EL) fue inspirado en JavaScript y en cierto grado en
XPath, pero EL es mucho más flexible con variables
sin valor (null) y realiza más conversiones de tipos en
forma automática.
Estas características son importantes para
aplicaciones en el Web, donde la entrada esta
principalmente en forma de parámetros de petición:
Los cuales pueden estar presentes en algunas peticiones
pero en otras no, y el visualizador siempre envía los
parámetros de petición como valores de texto, mientras que
la aplicación a menudo necesita usarlos como números o
valores booleanos (falso o verdadero).
De la manera como EL está diseñado, rara vez necesitamos
preocuparnos por ausencia de valores o conversión de tipos.
103
Una expresión EL contiene variables y operadores.
Cualquier Bean contenido en uno de los ámbitos del
JSP (página, petición, sesión o aplicación) puede ser
utilizada como una variable EL.
Las expreesiones del EL combinadas con etiquetas
JSTL tomadas de las cuatro bibliotecas estándares,
provee un conjunto amplio y flexible de
características.
Todas las expresiones EL están encerradas en ${ }.
Las expresiones en JSTL son siempre parte de
valores de atributos en las etiquetas JSTL:
Las expresiones pudieran ser la única parte del atributo o
pudieran estar combinadas e incrustadas en literales de
cadena.
Los atributos de JSTL pueden también contener simples
literales de cadenas.
104
Aquí tenemos a EL que agrega 5 a una variable
llamada amount:
${amount + 5}
Si se desea agregar 5 al valor de una propiedad de un
Bean, se utiliza el operador que accede a la
propiedad:
${order.amount + 5}
EL operador de acceso (punto) le dice a EL que
busque por la propiedad indicada (amount, en este
caso) en el Bean o colección especifica (order, en
este caso, el cual puede ser un Bean o Java.util.Map).
105
Como alternativa, se puede usar el operador de
acceso a elementos de un arreglo:
${order['amount'] + 5}
El valor entre los corchetes debe ser tanto una
cadena para el nombre de la propiedad (como en este
ejemplo) o una variable (o aun una sub-expresión EL
completa ) que mantiene el nombre de la propiedad.
Las expresiones EL pueden ser utilizadas para
asignar valores a cualquier atributo de acción
estándar o personalizado de JSP que acepte un valor
dinámico (o valores de atributo request-time, como
se llaman formalmente):
<c:out value="${order.amount + 5}"/>
106
EL proporciona soporte para acceder propiedades de
objetos y elementos de colecciones, un conjunto de
objetos implícitos y utilizar operadores relacionales
lógicos y aritméticos.
Para las propiedades indizadas, incluyendo arreglos y
clases Java.util.List, los elementos pueden ser
accedidos con la sintaxis siguiente:
${alist[4]}
${aList[someVariable]}
107
Las propiedades de JavaBeans y los elementos de
Java.util.Map (los cuales representan un conjunto de
pares nombre/valor) pueden ser accedidos usando
unas de la siguientes maneras:
En las primeras dos expresiones, podemos acceder a una
propiedad llamada aProperty en un JavaBean o una entrada
a Map con la clave aProperty.
En la tercera expresión (note que no hay comillas), tenemos
acceso a un elemento de anObject con un nombre contenido
en la variable aVariableContainingPropertyName:
${anObject.aProperty}
${anObject["aPropertyName"]}
${anObject[aVariableContainingPropertyName]}
108
Existe un numero de variables implícitas de
EL:
Variable name
Description
pageScope
A collection (a Java.util.Map) of all page scope variables.
requestScope
A collection (a Java.util.Map) of all request scope variables.
sessionScope
A collection (a Java.util.Map) of all session scope variables.
applicationScope
A collection (a Java.util.Map) of all application scope variables.
param
A collection (a Java.util.Map) of all request parameter values as a single String value per parameter.
paramValues
A collection (a Java.util.Map) of all request parameter values as a String array per parameter.
header
A collection (a Java.util.Map) of all request header values as a single String value per header.
headerValues
A collection (a Java.util.Map) of all request header values as a String array per header.
cookie
A collection (a Java.util.Map) of all request cookie values as a single Javax.Servlet.http.Cookie value per
cookie.
A collection (a Java.util.Map) of all application initialization parameter values as a single String value
per parameter.
initParam
pageContext
An instance of the Javax.Servlet.jsp.PageContext class, providing access to various request data.
109
Los operadores describen lo que se desea
hacer con las variables.
Los operadores que se pueden usar en una
expresión EL parecerán familiar si ya se ha
utilizado algún lenguaje de programación
antes, porque son parecidos a los utilizados
por la mayoría de los lenguajes:
110
Operator
Description
.
Access a Bean property or Map entry.
[]
Access an array or List element.
()
Group a subexpression to change the evaluation order.
?:
Conditional test: condition ? ifTrue : ifFalse.
+
Addition.
-
Subtraction or negation of a value.
*
Multiplication.
/ or div
Division.
% or mod
Modulo (remainder).
== or eq
Test for equality.
!= or ne
Test for inequality.
< or lt
Test for less than.
> or gt
Test for greater than.
<= or le
Test for less than or equal.
>= or ge
Test for greater than or equal.
&& or and
Test for logical AND.
|| or or
Test for logical OR.
! or not
Unary Boolean complement.
empty
Test for an empty variable value: null, an empty String, or an array, Map, or Collection without entries).
A function call, where func is the function name and args is zero, one or more comma-separated function
arguments.
func(args)
111
JSTL 1.1 fue pensado para acoplar JSTL con JSP 2.0.
El cambio más visible es que el JSTL 1.0 “bibliotecas gemelas"
(una que acepta expresiones EL y un conjunto que acepta
expresiones de Java) han sido remplazadas por un conjunto
sencillo de bibliotecas que pueden ser utilizadas tanto con EL o
con expresiones Java.
Cuando se importa cualquier biblioteca de etiquetas dentro de
una página JSP, se define un prefijo que señala un espacio de
nombres que corresponde a las etiquetas en esa biblioteca.
Note que se podría definir sus propios prefijos, pero no existe
una buena razón para esto.
Las cuatro bibliotecas de etiquetas estándar, con sus
convenciones de prefijos definidos JSTL, se enumeran en la
diapositiva siguiente.
112
biblioteca
URI
Prefijo
Core
http://Java.sun.com/jstl/core-rt
c
XML processing
http://Java.sun.com/jstl/xml
x
I18N formatting
http://Java.sun.com/jstl/fmt
Database access
http://Java.sun.com/jstl/sql
Functions
http://Java.sun.com/jstl/functions
fmt
sql
fn
113
Otro punto por mencionar acerca de la biblioteca de
etiquetas JSTL es que hay realmente dos versiones
de la mayoría de las etiquetas.
Un conjunto toma ventaja del nuevo lenguaje de
expresiones y el otro no;
Las etiquetas que no hacen uso de un lenguaje de
expresiones utilizan expresiones request-time :
Esto es útil si se desea la flexibilidad
proporcionada por las etiquetas estándares
pero no queremos utilizar el lenguaje de
expresiones soportado aun,
Para tener acceso a estas bibliotecas, simplemente añada -rt
al final del URI que señala a la biblioteca: <%@ taglib
prefix="c" uri="http://java.sun.com/jstl/ea/core-rt" %>
114
Biblioteca de etiquetas JSTL
Para usar la biblioteca de etiquetas core del EL en
una página, incluya la directiva del siguiente ejemplo
en la parte superior de su página:
<%@ taglib prefix="c"
uri=http://java.sun.com/jstl/core-rt %>
Para usar las etiquetas que están en esa librería core,
añada un prefijo a cada etiqueta en la página con el
prefijo que se ha señalado en la declaración que se
incluyó:
<c:out value="${anExpression}"/>
115
Reglas más flexibles del formato
de documentos JSP
La especificación JSP soporta dos tipos de
páginas JSP:
páginas JSP regulares conteniendo cualquier tipo
de texto o marcado y,
Documentos JSP los cuales son documentos XML
bien formados; es decir, documentos con
elementos del XHTML y de JSP,
Para satisfacer los requerimientos de bien
formado, las directivas JSP y los elementos
scripting en un documento JSP deben estar
escritos con una sintaxis diferente a la de
una página regular JSP.
116
Reglas más flexibles del formato
de documentos JSP
Página JSP regular
Documento JSP
<%@ page attribute list %>
<jsp:directive.page attribute list />
<%@ include file="path" %>
<jsp:directive.include file="path" />
<%! declaration %>
<jsp:declaration>declaration</jsp:declaration>
<%= expression %>
<jsp:expression>expression</jsp:expression>
<% scriptlet %>
<jsp:scriptlet>scriptlet</jsp:scriptlet>
117
Ejemplos JSTL
Sencillos
118
Ejemplo (a)
Como ejemplo simple considere el siguiente
fragmento de código que utiliza JSTL.
La acción set crea una variable llamada browser y le
asigna el valor de la propiedad User-Agent.
La acción out imprime entonces el valor de la variable
browser.
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core" %>
<html>
<head> <title>Ejemplo Simple</title> </head>
<body>
<c:set var="browser" value="${header['User-Agent']}"/>
<c:out value="${browser}"/>
</body>
</html>
119
Ejemplo (a)
120
Ejemplo (b)
<%@ taglib prefix="c" uri="http://Java.sun.com/jstl/core-rc" %>
<html>
<head>
<title>Objetos implictos JSTL</title>
</head>
<body bgcolor="#FFFFCC">
<h3>Header info:</h3>
<c:forEach var="head" items="${headerValues}">
param: <c:out value="${head.key}"/><br>
values:
<c:forEach var="val" items="${head.value}">
<c:out value="${val}"/>
</c:forEach>
<p>
</c:forEach>
</body>
</html>
121
Ejemplo (b)
122
Etiquetas XML
XML esta siendo cada vez mas importante para los creadores
de páginas y JSTL proporciona acciones XML que conducen
las necesidades básicas de estos desarrolladores.
Las acciones XML pueden ser divididas en core (núcleo),
control de flujo (control flow) y acciones de transformación.
Las acciones XML core son parecidas a las acciones
proporcionadas por core discutidas anteriormente, e incluyen
<x:out>, <x:set>, and <x:parse>.
La principal diferencia entre las acciones core discutidas
antes y las acciones XML core es que las acciones XML
soportan expresiones XPath, mientras las acciones core no.
De hecho, las acciones XML están basan en expresiones XPath.
Xpath es un lenguaje para definir partes de un documento
XML; XPath utiliza expresiones del tipo path para identificar
nodos en un documento XML.
123
Etiquetas XML
Las acciones del flujo de control XML son las mismas que las
acciones del core discutidas anteriormente.
Estas incluyen: <x:if>, <x:choose>, <x:when>, <x:otherwise>,
and <x:forEach>.
La principal diferencia es que utilizan el atributo select para
especificar expresiones XPath.
ejemplo: <x:forEach select="$output/portfolio/stock"> <x:out
select="price"/> </x:forEach>
En la diapositiva siguiente xml-ex1.jsp utiliza las bibliotecas
de etiquetas core y XML para procesar un documento XML.
En este ejemplo, el documento XML es incrustado dentro de la
página y la etiqueta <x:parse> es utilizada para analizar el
documento.
Entonces una expresión XPath se utiliza para seleccionar
artículos dentro del documento.
124
xml-ex1.jsp - i
<%@ taglib prefix="c" uri="http://Java.sun.com/jstl/core-rt" %>
<%@ taglib prefix="x" uri="http://Java.sun.com/jstl/x-rt" %>
<html>
<head><title>JSTL Support for XML</title></head>
<h3>Books Info:</h3>
<c:set var="xmltext">
<books>
<book>
<title>Book Title A</title>
<author>A. B. C.</author>
<price>17.95</price>
</book>
<book>
<title>Book Title B</title>
<author>X. Y. Z.</author>
<price>24.99</price>
</book>
</books>
</c:set>
125
xml-ex1.jsp – ii
<x:parse xml="${xmltext}" var="output"/>
<b>The title of the first book is</b>: <x:out select="$output/books/book[1]/title"/>
<br>
<b>The price of the second book</b>: <x:out
select="$output/books/book[2]/price"/>
</body>
</html>
126
xml-ex2.jsp
<%@ taglib prefix="c" uri="http://Java.sun.com/jstl/core-rt" %>
<%@ taglib prefix="x" uri="http://Java.sun.com/jstl/x-rt" %>
<html>
<head> <title>JSTL Support for XML</title></head>
<h3>Portfolio</h3>
<c:import url="http://www.Javacourses.com/stocks.xml" var="xmldoc"/>
<x:parse xml="${xmldoc}" var="output"/><p>
<table border="2" width="50%">
<tr>
<th>Stock Symbol</th>
<th>Company Name</th>
<th>Price</th>
</tr>
<tr>
<x:forEach select="$output/portfolio/stock" var="item">
<td><x:out select="symbol"/></td>
<td><x:out select="name"/></td>
<td><x:out select="price"/></td></tr>
</x:forEach>
</table>
</body>
</html>
127
xml-ex2.jsp
128
Extendiendo el JSTL
También es posible que se pueda utilizar JSTL como base para
desarrollar sus propias etiquetas.
Algunas clases abstractas son proporcionadas de tal manera que
asisten en el desarrollo rápido de etiquetas y promueven la
integración de sus propios etiquetas personalizados con el
conjunto de etiquetas JSTL.
Por ejemplo, se puede construir sus propias etiquetas
personalizados que hagan uso de los mecanismo EL de JSTL.
Mediante extender:
Javax.Servlet.jsp.jstl.core.ConditionalTagSupport, se podría
escribir una etiqueta condicional simplemente implementado un
método que regrese un valor booleado correspondiente con el
comportamiento condicional deseado de la etiqueta.
o, Javax.Servlet.jsp.jstl.core.IteratorTagSupport, Le permite a
implementar fácilmente etiquetas de iteración.
129
Desarrollando bibliotecas de etiquetas
personalizadas como archivos de etiquetas
Comenzando con la versión 2.0 de la especificación
JSP, las acciones personalizadas de la biblioteca de
etiquetas pueden ser implementadas de dos maneras:
Como clases de java o,
Como archivos de texto regular conteniendo elementos de
JSP.
En versiones anteriores, las acciones personalizadas
podían solamente ser implementadas como clases de
java, dejándolas con esto fuera del alcance de los no
programadores.
Otro problema con la implementación en java de las
acciones personalizadas es que era forzado a
imprimir código HTML con llamadas a println() para
producir contenido complejo – El mismo problema que
JSP se supone que resuelve.
130
Creando y usando un archivo de
etiquetas
Un archivo de etiquetas es un archivo de texto que
contienen elementos JSP implementando la funcionalidad
de acciones personalizadas.
Se debe utilizar un archivo con extension .tag* para
identificar este tipo de archivo en el contenedor Web.
Todos los elementos JSP que se pueden utilizar en un
archivo JSP también pueden ser utilizados como un
archivo de etiqueta, con excepción a la directiva page (un
archivo de etiqueta no es una página).
También hay algunas directivas JSP que pueden ser
permitidas en un archivo de etiquetas, como lo veremos
mas adelante.
Aparte de esto, crear un archivo de etiquetas no es
diferente de crear una página JSP.
Una vez creado e instalado, el archivo de etiquetas se
utiliza igual que las acciones personalizadas
implementadas en java que se han visto anteriormente. 131
Invocación de una etiqueta
Obtain
handler
doStartTag()
Set
properties
setPageContext()
setParent()
SKIP_BODY
EVAL_BODY_INCLUDE
Process body
Set attribute
values
SKIP_PAGE
doEndTag()
EVAL_PAGE
release()
release()
Stop
Continue
132
Un archivo de etiquetas sencillo
copyright.tag
<%@ tag body-content="empty" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jstl/core_rt" %>
<jsp:useBean id="now" scope="application" class="Java.util.Date" />
Copyright © ${now.year + 1900} My Company
Este archivo de etiquetas inserta una declaración de copyright
con el año actual en la página que se llama.
La primera línea es una directiva de etiqueta.
Se puede utilizar atributos de esta directiva para especificar
una descripción, un icono o un ejemplo, que una herramienta de
desarrollo de páginas puede mostrar al diseñador.
Otros atributos le permiten especificar si las expresiones EL
deben ser procesadas, así como información relacionada al
código del scripting, ejemplo: el mismo tipo de información que
se especifico con la directiva page en las página JSP.
133
Nota de la etiqueta body-content
Un manejador de etiquetas para una etiqueta
con un cuerpo es implementado de manera
diferente dependiendo si el manejador de
etiqueta necesita interactuar con el cuerpo o
no:
Por interactuar, queremos decir que el manejador
de etiqueta lee o modifica los contenidos del
cuerpo o causa evaluación interactiva del cuerpo.
134
En la mayoría de los casos, los autores de archivos de etiquetas
sólo se preocupan del atributo que define el contenido del
cuerpo (body-content):
Este atributo dice cómo el cuerpo de la acción personalizada debe
manejarse, y debe tener uno de los siguientes valores:
Si es empty (vació), el intentar usar el cuerpo de la acción
personalizada da como resultado un error de sintaxis.
El valor scriptless significa que el cuerpo puede contener algunos
elementos JSP :
empty, scriptless (por defecto), o tagdependent.
En otras palabras, el texto de plantilla, las
expresiones EL, las acciones estándares y las
acciones personalizadas, todas son permitidas.
Si el atributo se establece a tagdependent el cuerpo del elemento
de la acción es tratado como un texto de plantilla (ejemplo, los
elementos de la acción y las expresiones EL en el cuerpo no son
procesadas, son manejados como texto plano).
135
El resto del archivo de etiquetas luce como
una página ordinaria JSP.
Declara que utiliza la biblioteca JSTL core,
una acción estándar <jsp:useBean> para crear
una instancia de la clase Java.util.Date que
representa la hora actual y finalmente hace
salir el texto estático mezclado con un valor
dinámico (el año actual) generado por la
expresión EL: ${now.year + 1900}.*
136
Notas
Los archivos Tag pueden ser colocados directamente
en la aplicación Web bajo la estructura del directorio
o subdirectorio Web-INF/tags.
Cada directorio que contiene archivos tag files
representa un tag library separado:
Web-INF/tags/
mytags/
copyright.tag
forEvenAndOdd.tag
htmlFormat.tag
motd.tag
myothertags/
foo.tag
bar.tag
Aquí tenemos dos carpetas de tag:
mytags y myothertags.
La carpeta mytags contiene el archivo
copyright.tag mas otros tres archivos
tag.
Por defecto, el nombre de las acciones
implementadas personalizadas por el
archivo tag es el nombre de archivo
menos la extensión .tag, así que el
archivo copyright.tag representa el
nombre de la acción personalizada
llamada copyright en la librería mytags.
137
Mas ejemplos
Una página JSP debe declarar que utiliza un tag
library representada por los archivos tag en la
estructura de la aplicación Web con una directiva
ligeramente diferente que el usado anteriormente:
<%@ page contentType="text/html" %>
<%@ taglib prefix="my" tagdir="/Web-INF/tags/mytags" %>
<html>
...
<my:copyright/>
</body>
</html>
138
Mas ejemplos
Note que el atributo tagdir es utilizado en lugar que el atributo
del URI.
El valor del atributo tagdir es la trayectoria relativa del
contexto al directorio que contiene los archivos tag para la
biblioteca.
Puede parecer redundante tener que especificar la parte del
path /Web-INF/tags, puesto que todos los directorios tag de la
biblioteca deben comenzar con este path.
Aunque es costoso, el grupo que creó la especificación JSP
decidió requerir esto para tener consistencia con otros
atributos que toman valores del path.
Los archivos tag pueden ser empaquetados en archivos JAR.
Esto requiere un poco mas de trabajo y es sobre todo de interés
para los archivos tag prever ser reutilizado en muchas aplicaciones.
139
El Tag Handler
Hay dos interfases que describen al tag handler:
Tag usado por los manejadores de etiquetas simples no
interesados en la manipulación del contenido del cuerpo.
BodyTag una extensión del tag dando acceso al manejador al
cuerpo.
El Tag Handler tiene dos métodos de acción
principales:
doStartTag() procesa el comienzo del tag de esta acción.
doEndTag() procesa el final del tag de esta acción.
Llamado después de retornar de doStartTag.
release() libera recursos
140
Otros ejemplos
Tags personalizados
141
Tag Handler Hola mundo
Las subclases simples de tag handler soportan la
llamada a las clases SimpleTagSupport.
Esta clase es una muy buena implementación de la
interfase SimpleTag.
Proporciona implementacion de los cinco métodos de
esta interfaz, el más importante es el método
doTag().
El método doTag() en SimpleTagSupport realmente
no hace nada – hasta que el desarrollador
sobreescribe este metodo y codifica la funcionalidad
de su tag.
El código en la diapositiva siguiente muestran este
método en acción.
142
// Greeter.Java
package mab;
import Javax.Servlet.jsp.JspException;
import Javax.Servlet.jsp.tagext.SimpleTagSupport;
import Java.io.IOException;
public class Greeter extends SimpleTagSupport {
public void doTag() throws JspException, IOException {
getJspContext().getOut().write( "Hello, world!" );
}
Compile y sustituya la clase en \Web-INF\classes\mab
143
Esta clase utiliza simplemente doTag() para
imprimir el ‘Hola mundo’ al stream de salida.
Las dos declaraciones de importación nos dan
acceso a todas las clases requeridas:
Usted necesitara el Servlet y las clases JSP API en
su classpath para que este código compile:
Los usuario de Tomcat encontrarán estos en
common/lib como jasper-api.jar and Servlet-api.jar.
Por estas razones, esta clase extiende la
clase SimpleTagSupport y espera que usted
sobrescriba el método doTag().
144
Otra consecuencia de extender la clase es
que un método llamado setJspContext() fue
llamado por el contenedor antes del doTag(),
que hizo la información actual del contexto
del JSP disponible vía getJspContext().
Utilizamos este método para conseguir el
acceso al stream de salida del JSP.
145
Mapeo de tags a clases:
Asumimos que esta clase esta en /WebINF/classes, el siguiente paso debería escribir el
archivo TLD.
El TLD (Tag Library Descriptor) es un archivo
XML que el contenedor utiliza para trazar los tags
personalizados de sus JSPs a su correspondiente
implementación de clases simples del tag handler.
En la siguiente presentación veremos un demo.tld,
un archivo simple del TLD, que cuando esta
instalado en el directorio /WebINF/tags/mytags, traza una un tag llamado
'greeter' a la clase 'demo.mytags.tags.Greeter'.
146
<!– demo.tld -->
<?xml version="1.0"?>
<!DOCTYPE taglib PUBLIC
"-//Sun Microsystems, Inc.//DTD JSP Tag Library 1.2//EN"
"http://Java.sun.com/j2ee/dtds/Web-jsptaglibrary_1_2.dtd">

<taglib>
<tlib-version>1</tlib-version>
<jsp-version>1.2</jsp-version>
<short-name>Demo Tag Library</short-name>
<tag>
<name>greeter</name>
<tag-class>mab.Greeter</tag-class>
<body-content>empty</body-content>
</tag>
</taglib>
Drop this file in Web-INF/tags/mytags/
147
Mapeando Tags a clases:
Los elementos de tlib-version y short-name son bastante directos
y se relacionan con la versión del tag library y con el prefijo por
defecto del tag respectivamente.
El elemento de uri, sin embargo vale la pena discutirlo:
Cuando se inicializa, el contenedor usa una característica de
auto-discovery para trazar todos los elementos de uri a TLD
correspondiente; Por lo tanto esta cadena debe ser única
dentro de la aplicación. As of JSP 1.2, nosotros no tenemos
ninguna necesidad de editar el archivo Web.xml para desplegar
un tag personalizado – la caracteristica del auto-discovery nos
ahorra esta inconvenienza.
La parte interesante es el contenido del elemento del <tag>.
Es donde, entre otras cosas, nosotros podemos dar a nuestro
tag un nombre, definir la clase asociado con el tag handler, y
determinar si nuestro tag se le debe o no permitir acceso al
contenido del cuerpo.
148
Cortesía de las directivas taglib el atributo uri,
tenemos dicho que el JSP esta donde esta nuestro
archivo TDL y, por tanto, donde se localiza nuestra
clase simple de la implementación del tag handler.
El atributo uri traza directamente a uno de los
mappings del contenedor creado cuando se inicializo;
El contenedor traza alternadamente puntos a la
información del TLD.
Generalmente, esto se toma con cuidado, si el
atributo uri no resuelve la traza al contenedor, se
asume el path del archivo:
Esto es útil solo cuando los valores idénticos del uri se
encuentran en diferentes archivos TLD.
149
Hello World Tag Handler
Este código muestra como podemos utilizar nuestra
etiqueta greeter en un JSP:

<?xml version="1.0"?>
<jsp:root xmlns:jsp="http://Java.sun.com/JSP/Page"
xmlns:c="http://Java.sun.com/jstl/core"
xmlns:my="urn:jsptld:/Web-INF/tags/mytags/demo.tld" version="1.2">
<jsp:directive.page contentType="text/html"/>
<html>
<head><title>JSP Page</title></head>
<body>

<my:greeter />
</body>
</html>
</jsp:root>
150
Aquí esta mi comprensión de cómo trabaja el tag
personalizado usando el tag "Hello world!" como
ejemplo:
Cuando la página greeter.jsp es solicitada por primera vez, el
servidor Tomcat traducirá la página JSP a una clase de Java,
Cuando el tag personalizado <my:greeter/>es encontrado
durante la traducción, el servidor Tomcat hará un
seguimiento del archivo TLD para localizar al archivo
Greeter.class :
Observe que el archivo TLD es proporcionado en el
elemento jsp:root.
Después el servidor Tomcat sustituirá el tag personalizado
con un cierto código de Java al instanciar un objeto de la
clase tag, inicializara el objeto y llamara al método doTag() .
Para obtener datos de salida en la página, usted puede usar
el stream del objeto pageContext proporcionado por la
extinción tag JSP, pageContext.getOut():
Esta es la manera de como "Hello world!" es producido. 151
Ejemplo final de Tag
152
153
154
155
Los pasos usados por la extensión JSP para facilitar
el procesamiento de los tag personalizados pueden
ser resumido como sigue:
Instanciamiento del objeto tag,
Llamando a setPageContext() y setParent() del objeto tag,
Procesando los atributos del tag. Ver mis otras notas sobre
como los valores de los atributos son pasados al objeto tag,
Llamando a doStartTag() del objeto tag, que puede retornar
una bandera a la petición para saltar el cuerpo y realizar una
lógica condicional del cuerpo,
Procesamiento del cuerpo del tag,
Llamando a doAfterBody() del objeto tag, que puede
retornar una bandera a la petición para procesar el cuerpo
otra vez y realizar un ciclo lógico del cuerpo,
Llamando a doEndTag() del objeto tag,
Llamando a release() del objeto tag.
156
Open Source Tag Libraries
ver http://jakarta.apache.org/taglibs:
Internationalization,
Database access,
Sending Mail,
JNDI,
Data/time,
Populating/validating fields,
Per regular expressions,
Extracting data from other Web pages
XSL transformations,
And so on…
157
Open Source Tag Libraries
158
Integrando Servlets y JSPs
159
Porque combinar Servlets y JSPs?
Panorama: Se trata de usar JSP para hacer más fácil
el desarrollo y mantenimiento de contenido HTML:
Para código dinámico simple, llamar código del Servlet desde
expresiones scripting,
Para casos moderadamente complejos, utilizar clases
personalizadas llamadas expresiones scripting,
Para casos mas complicados, use Beans y tags
personalizados.
Pero, eso no es suficiente:
Para procesamiento complejo, JSP es lento,
Aún con la conveniencia de separar clases, Beans y tags
personalizados. La asunción detrás es que una página
sencilla de una apariencia sencilla.
160
Arquitectura
Enfoque:
La petición original es contestada por el Servlet,
El Servlet proceso los datos solicitados, hace búsquedas en
la base de datos, accede a la lógica del negocio, etc.
La petición se remite a una página JSP para darle formato
a los resultados,
Diferentes páginas JSP pueden ser usadas para manejar
diferentes tipos de formatos.
Terminología:
A menudo llamada la arquitectura “Model View Controller”
es una aproximación a JSP.
Algo formalizado lo podemos ver en Apache “struts”
framework – http://jakarta.apache.org/structs
161
Apache Struts
162
Enviando peticiones
Primero, llamar al método getRequestDispatcher de
ServletContext:
Proveer un URL relativo a la raíz de las aplicaciones Web.
Ejemplo:
String url = “/presentations/presentation1.jsp”;
RequestDispatcher dispatcher =
getServletContent().getRequestDispatcher(url);
En segundo lugar:
Llamar a forward para transferir completamente el
control a la página destino – vea el ejemplo siguiente.
Llama a include para insertar la salida de la página destino
y continuar.
163
Enviando peticiones: Código
ejemplo.
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
String operation = request.getParameter(“operation”);
if (operation == null) operation = “unknown”;
if (operation.equals(“operation1”)) {
gotoPage(“/operations/presentation1.jsp”, request, response);
} else if (operation.equals(“operation2”)) {
gotoPage(“/operations/presentation2.jsp”, request, response);
} else {
gotoPage(“/operations/unknownRequestHandler.jsp”, request, response);
}
164
Enviando peticiones: Código
ejemplo.(cont..)
public void doGet(HttpServletRequest req, HttpServletResponse res)
throws ServletException, IOException {
ReuestDispatcher dispatcher = getServletContext(). getRequestDispatcher(address);
dispatcher.forward(request, response);
}
165
Almacenar datos para uso
posterior: El objeto session
Propósito:
Almacenar los datos que el Servlet buscó y que la
página JSP utilizará en esta petición y en las
peticiones siguientes del mismo cliente
Sintaxis del Servlet para almacenar datos:
SomeClass value = new SomeClass(…);
Session.setAttribute(“key”, value);
// Use RequestDispatcher to forward to the JSP page.
166
Almacenar datos para uso
posterior: : The Servlet Context
Propósito:
Almacenar los datos que el Servlet buscó y que la
página JSP utilizara en esta petición y en las
peticiones siguientes del mismo cliente
Sintaxis del Servlet para almacenar datos :
SomeClass value = new SomeClass(…);
Get ServletContext().setAttribute(“key”, value);
//Use RequestDispatcher to forward to JSP page
167
On-line Travel Agent
168
Resumen JSP
169
Descripción
JSP hace mas fácil el crear y mantener HTML,
mientras que provee un acceso total al código del
Servlet.
Las páginas JSPs son traducidas a Servlets:
Lo que usted necesita entender sobre Servlets:
Es el Servlet el que se ejecuta al momento de una petición.
Para el cliente es totalmente transparente.
Comprender como trabaja realmente JSP.
El código del Servlet es llamada desde el JSP.
El saber cuenco los Servlets son mejores que los JSP.
Combinar Servlets y JSPs.
Otras tecnologías tienen un acercamiento similar
pero no son portables y no le permiten usar Java
para el código verdadero.
170
Ejemplo:
Combinando JSP + JavaBeans + JDBC
171
Ejemplos: JSP, JDBC
Este ejemplo involucra a dos páginas JSP (alumnos.jsp y
verificaalumnos.jsp) , y un Java Bean -clase- (alumnos.java). Lo
que hace el ejemplo es mostrar una lista de alumnos que se carga
de la base de datos (agendita), y permite registrar nuevos alumnos.
Nota: no existe ninguna validación de que el alumno ya exista, de
hecho ni siquiera existe una llave primaria en la tabla.
El ejemplo hace uso del JavaBean para manipular la tabla de
alumnos, con un scope a nivel de aplicación. El tipo de base de
datos utilizada es MySQL:
Tabla Alumnos:
nombre: varchar(30)
apellido: varchar(30)
direccion: varchar(30)
telefono: varchar(30)
172
Ejemplos: JSP y Java Beans
<html> <head>
<title>Alumnos</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
<%@ page import="java.sql.*" %>
<jsp:useBean
id="alum"
class="dcc.alumnos"
scope="application"
/>
Alumnos.jsp
</head>
<body bgcolor="#FFCCCC">
<div Id="scroll"
Style="position:absolute; left:78px; top:50px; width=570; height=420; overflow = auto; border=solid thin
#B8D0F0; visibility:visible; z-index:2;; width: 813px; height: 518px">
<p align="center"><strong><font face="Georgia, Times New Roman, Times, serif" color="#000099">Lista
de Alumnos</font><font face="Arial" color="#408080" > </font></strong></p>
<%
Connection con;
String url= "jdbc:mysql://localhost/agendita";
String usuario= "bingo";
String password="holahola";
Statement stmt;
ResultSet rs;
try
{
Class.forName("com.mysql.jdbc.Driver").newInstance();
con = DriverManager.getConnection(url,usuario,password);
alum.setCn(con);
stmt = con.createStatement();
%>
<table border="1" cellpadding="0" cellspacing="1" width="100%">
<tr>
<td align="center" bgcolor="#0068C0"><font face="Arial" color="#FFFFFF">Nombre</font></td>
<td align="center" bgcolor="#0068C0"><font face="Arial" color="#FFFFFF">Apellido</font></td>
<td align="center" bgcolor="#0068C0"><font face="Arial" color="#FFFFFF">Direccion</font></td>
<td align="center" bgcolor="#0068C0"><font face="Arial" color="#FFFFFF">Telefono</font></td>
</tr>
173
<%
rs = stmt.executeQuery("Select * from alumnos");
while(rs.next())
{%>
<tr>
<td bgcolor="#B8D0F0"><small><font face="Arial"><%=rs.getString("nomrbe")%></font></small></td>
<td bgcolor="#B8D0F0"><small><font face="Arial"><%=rs.getString("apellido")%></font></small></td>
<td bgcolor="#B8D0F0"><small><font face="Arial"><%=rs.getString("direccion")%></font></small></td>
<td bgcolor="#B8D0F0"><small><font face="Arial"><%=rs.getString("telefono")%></font></small></td>
</tr>
<%}%>
</table>
<%
}
catch(Exception e)
{
System.out.println("Error al conectarse: "+e.toString());
}%>
<form name="form1" method="post" action="VerificaAlumnos.jsp">
<p align="center"><strong><font face="Georgia, Times New Roman, Times, serif" color="#000099">Registro
de Alumnos</font><font face="Arial" color="#408080" > </font></strong></p>
<tr>
<td bgcolor="#B8D0F0" width="27%"><small><font face="Arial">Nombre</font></small></td>
<td width="73%" align="center" bgcolor="#B8D0F0"><small><font face="Arial">
<input type="text" name="nombre" size="80" maxlength="75">
</font></small> </td>
</tr>
<tr>
<td bgcolor="#B8D0F0" width="27%"><small><font face="Arial">Apellido</font></small></td>
<input type="text" name="apellido" size="80" maxlength="75">
</tr>
174
<tr>
<td bgcolor="#B8D0F0" width="27%"><small><font
face="Arial">Direccion</font></small></td>
<input type="text" name="direccion" size="80" maxlength="75">
</tr>
<tr>
<td bgcolor="#B8D0F0" width="27%"><small><font
face="Arial">Telefono</font></small></td>
<input type="text" name="telefono" size="80" maxlength="75">
</tr>
</table>
<br> <center>
<input type="submit" name="btnContinuar" value="Registrar">
</center>
</form>
</div>
</body>
</html>
175
VerificaAlumnos.jsp
<html>
<head>
<title>Alumnos</title>
<meta http-equiv="Content-Type" content="text/html; charset=iso-8859-1">
</head>
<%@ page import="java.sql.*" %>
<jsp:useBean
id="alum"
class="dcc.alumnos"
scope="application"
/>
<body bgcolor="#FFCCCC">
<div Id="scroll"
Style="position:absolute; left:259px; top:122px; width=570; height=420; overflow = auto;
border=solid thin #B8D0F0; visibility:visible; z-index:2;; width: 509px; height: 183px">
<br>
<tr>
<td width="40%" align="center" bgcolor="#0068C0"><font face="Arial"
color="#FFFFFF"><b><font face="Georgia, Times New Roman, Times,
serif">Resultados</font></b></font></td>
<tr>
</tr>
</table>
176
<br>
<jsp:setProperty
<jsp:setProperty
<jsp:setProperty
<jsp:setProperty
name="alum"
name="alum"
name="alum"
name="alum"
property="nombre" param="nombre"/>
property="apellido" param="apellido"/>
property="direccion" param="direccion"/>
property="telefono" param="telefono"/>
<% if (alum.NuevoAlumno())
{ %>
<p align="center"><strong><font face="Georgia, Times New Roman, Times, serif"
color="#000099">El
alumno</font><font face="Arial" color="#408080" >
 <jsp:getProperty name="alum" property="nombre" />
 <jsp:getProperty name="alum" property="apellido" />
  <font face="Georgia, Times New Roman, Times, serif" color="#000099">se
registro correctamente!!!</font> </font></strong></p>
<% }
else
{ %>
<p align="center"><strong><font face="Arial" color="#408080" > <font face="Georgia,
Times New Roman, Times, serif" color="#000099">Se
ha generado un error y no se grabo el alumno</font>
 <jsp:getProperty name="alum" property="nombre" />
 <jsp:getProperty name="alum" property="apellido" />
  <font face="Georgia, Times New Roman, Times, serif"
color="#000099">Verifique...!
</font> </font></strong></p>
<% } %>
<form name="form1" method="post" action="Alumnos.jsp">
<center>
<input type="submit" name="btnContinuar" value="Continuar">
</center>
</form> </div> </body> </html>
177
Bean Alumnos.java
package dcc;
import java.sql.*;
public class alumnos {
private String nombre;
private String apellido;
private String direccion;
private String telefono;
private Connection cn;
public void setCn(Connection cn)
{
this.cn=cn;
}
public Connection getCn()
{
return(cn);
}
public void setNombre(String nombre)
{
this.nombre=nombre;
}
public String getNombre()
{
return(nombre);
}
public void setApellido(String apellido)
{
this.apellido=apellido;
}
public String getApellido()
{
return(apellido);
}
public void setDireccion(String direccion)
{
this.direccion=direccion;
}
public String getDireccion()
{
return(direccion);
}
public void setTelefono(String telefono)
{
this.telefono=telefono;
}
public String getTelefono()
{
return(telefono);
}
178
public boolean isAlumno(String nombre)
{
Statement st;
String sqlQuery;
if (cn!=null)
{
try {
st= cn.createStatement();
sqlQuery="Select * from alumnos where nomrbe='"+nombre.trim()+"'";
ResultSet rs=st.executeQuery(sqlQuery);
if (rs.next())
{
this.nombre=nombre;
apellido=rs.getString("apellido").trim();
direccion=rs.getString("direccion").trim();
telefono=rs.getString("telefono").trim();
rs.close();
return(true);
}
else
{
this.nombre="";
apellido="";
direccion="";
telefono="";
rs.close();
return (false);
}
}
179
//try
catch(SQLException e)
{
this.nombre="";
apellido="";
direccion="";
telefono="";
return (false);
}
}
else return(false);
}
public boolean NuevoAlumno()
{
Statement st;
String sqlInsert;
if (cn!=null)
{
try {
st= cn.createStatement();
sqlInsert="INSERT INTO alumnos VALUES('"+ nombre.trim() + "','"+
apellido.trim()+"','"+direccion.trim()+"','"+telefono.trim()+"')";
st.executeUpdate(sqlInsert);
return(true);
}
catch(SQLException e)
{ return(false);
}
}
else return(false);
}
}
180

Java Server Pages, Beans y JSP Tag Library Introducción

Transcripción

Documentos relacionados

JSP(II) - Aula Virtual