jsp extendido

Java Server Pages, Beans y JSP Tag Library

1

Sintetizado del curso de Mark BakerUniversity of Portsmouth, UK

Dr. Víctor J. Sosa [email protected]

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.

2

� 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.

¿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,

3

� Compartir Datos entre Servlets,� Recordar datos entre peticiones.

� Qué es lo difícil:� Usar muchas instrucciones println() para generar HTML,� Mantenimiento del HTML.

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:

4

� Ejemplo:� JSP:

� Thanks for ordering <%=request.getParameter(“title”) %/>� URL:

� http://host/OrderConfirmation.jsp?title=Java+Servlets.� Result:

� Thanks for ordering the “Java Servlets”

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 queaquella conseguida con los servlets.

� Las páginas JSP se utilizan en un proceso queinvolucra dos fases:

5

involucra dos fases:1. Una fase de traducción dinámica a servlets que se

realiza únicamente cuando la página JSP se crea omodifica.

2. Una fase de contestación a peticiones que seconsigue cuando las clases de los servletsgenerados se cargan en el contenedor de servlets.


� Arquitectura de JSP� En la segunda fase, para atender

concurrentemente al procesamiento de peticiones,el servidor lanza un proceso ligero (thread) porcada uno de los clientes el cual corre el método_jspService().

6

_jspService().� El método _jspService() no puede reemplazarse

por otros métodos definidos por el programador,pero en cambio puede adecuarse su inicialización yterminación con los métodos jspInit() yjspDestroy().


Arquitectura de JSP

_jspInit()

Evento de iniciación Servlet

7

_jspInit()

_jspService()

_jspDestroy()

Petición

Respuesta

Evento de terminación

Contenedor de Servlets

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 deprogramación (scriptlets).

8

programación (scriptlets).� Altamente recomendable para conseguir el acceso

al servidor Web en arquitecturas de partesmúltiples (multi-tier).

� Separación del contenido estático del dinámico.� Separación del contenido dinámico del formato de

la presentación.

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:

9

� 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.


� 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:

10

� 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.


� 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

11

beneficiadas por la inserción de cantidades pequeñas de datos dinámicos.

Resumen: JSP vs ASPPropiedad 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 yPersonal Web Server)

Plataforma Cualquiera que corra una máquinavirtual Java

Windows

12

Modelo de componentes

Java Beans, Enterprise Java Beans ylibrerí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 WindowsNT

Bases de datos Java Data Base Connectivity Active Data Objects

Extensibilidad Abierto a librerías de elementos Ninguna

Malentendidos comunes: Recordar que JSP es tecnología Server-Side

� Pregunta muy común:� ¿No puedo hacer XYZ con el HTML, JSP me dejaría

hacerlo?� ¿Por qué esta pregunta no tiene sentido?

� JSP corre completamente del lado servidor, � No cambia el contenido que el visualizador puede manejar.

� Preguntas similares:

13

� 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.

2do Malentendidos comunes: Tiempo de Traducción/Petición

� ¿Qué sucede al momento de traducción de la página JSP?� Las JSPs se traducen a código Servlet.

� ¿Qué pasa en el momento de la petición?� 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

14

� 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.

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.

18

<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.

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 llaman al código del Servlet directamente.

� Los elementos de Scripting llaman al código del Servlet indirectamente mediante clases

Aplicaciones simples

23

indirectamente mediante clases de uso general(utilities).

� Uso de Beans.� Etiquetas personalizadas.� Servlet/JSP combo. Aplicaciones complejas

Tipos de elementos de Scripting� Expresiones:

� Formato <%=expression %>� Se evalua e inserta en la salida del Servlet, ej., el

resultado en algo como: out.println(expression).

� Scriptlets:� Formato <%code%>

24

� 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.

Expresiones JSP� Formato:

� <%= Expresión Java %>� 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:

25

� Ejemplos:� 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.

Correspondencia JSP/Servlet� Original JSP:

<H1> A Random Number </H1><%= Math.random() %>

� Resultado posible del código Servlet:

public void _jspService(HttpServletRequest request,

26

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());…

}

Ejemplo usando expresiones JSP

27

Variables predefinidas� Request:

� El HttpServletRequest – 1er argumento para doGet();� Response:

� El HttpSerlvetResponse – 2do argumento para doGet();� Session:

� El HttpSession asociada a la petición (al menos que fuera deshabilitada con el atributo de la directiva de sesión).

28

deshabilitada con el atributo de la directiva de sesión).� Out:

� 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().

Java Server Pages (JSP)� Objetos Implícitos

Objeto Contexto Descripción Ámbitorequest 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

Página

29

Dependientes de la implementación, espacios denombres y otras facilidades

session http.HttpSession Conserva el estado de la session

Sesión

application ServletContext Contexto del servletde 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 procesala petición en curso

Página

JSP Scriptlets� Formato:

� <% Código Java %>� Resultado:

� El código insertado textualmente en el _jspService del Servlet.

30

_jspService del Servlet.� Ejemplo:

� <%String queryData = request.getQueryString(); out.println(Attached GET data: “ + queryData);%>

� <%response.setContentType(text/plain”); %>� Sintaxis compatible XML:

� <%jsp:scriptlet> Código Java </jsp:scriptlet>%>

Correspondencia JSP/Servlet � Original JSP:

<%= foo() %><%= bar() %>

� Posible resultado del código Servlet:

public void _jspService(HttpServletRequest request, HttpServletResponse

31

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());

…}

Ejemplo usando JSP Scriptlets

32

Ejemplo usando JSP Scriptlets

33

Declaraciones JSP� Formato:

� <%! Código Java %>� Resultado:

� El código se inserta textualmente en la definición de la clase del Servlet, fuera de cualquier método existente.

34

cualquier método existente.� Ejemplos:

� <%! private int algunCampo=5;%>� <%! private void AlgunMetodo(…) {…} %>

� Sintaxis compatible XML :� <jsp:declaration> Código Java </jsp:declaration>

Declaraciones JSP� JSP:

<H!>Someheading</H1><%!

private String randomHeading(){return(“<H2>” + Math.random() + “</H2>”);

}%><%= randomHeading()%>

35

<%= randomHeading()%>

Ejemplo usando declaraciones JSP

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.0 Transitional//EN">

<HTML><HEAD>

<TITLE>JSP Declaraciones</TITLE>

</HEAD><BODY>

36

<BODY><H1>JSP Declaraciones</H1><%! private int accessCount = 0; %><H2>Accesses to page since server reboot:

<%= ++accessCount %></H2></BODY>

</HTML>

Ejemplo de una Página JSP:� La siguiente página JSP presenta un saludo.

<%-- Esta página da un saludo y despedida --%>

<HTML>


37

<HTML>

<BODY>

<H1>Bienvenido a JSP!</H1>

<% out.println("Regrese pronto”); %>

</BODY>

</HTML>

N

bienvenido helloworld hellouser response NameHandler

Á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


38

� El ámbito del objeto establece su duracióndesde su creación hasta su destrucción; suvisibilidad indica los lugares de la páginadonde puede usarse el objeto.


Ámbito y Visibilidad de Objetos� La siguiente tabla muestra los ámbitos que pueden asociarse a los

objetos recién creados.

Ámbito Categoría Descripción4 (mayor) Aplicación Pertenecen a la

misma aplicación

39

misma aplicación

3 Sesión Pertenecen a la misma sesión

2 Petición Provienen de la petición que esAtendida

1 (menor) Página Pertenecen a lapágina en quefueron creados

Objetos Implícitos� Debido a que la tecnología JSP se basa en

aquella de los servlets, existe un conjunto deobjetos predefinidos cuyos nombres puedenusarse 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>

41

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>

ambitos


Resumen de Elementos Básicos de JSP� Elementos que se intercalan entre aquellos de HTML o XML.

Elemento Sintaxis DescripciónDirectiva <%@ . . . . . . . . %> Importar clases o incluir

archivos HTML

42

archivos HTMLDeclaraciones <%! . . . . . . . . . . %> Declarar variables o

métodos JavaExpresiones <%= . . . . . . . . .. %> Evaluación de expresiones

JavaScriptlets <% .. . . . . . . . . .. %> Ejecución de

instruccionesJava

Comentarios <%-- .. . . . .. . . -- %> Texto no procesado

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:

que indica el lenguaje usado en la página JSP,

JSP: Resumen Elementos Básicos

43

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

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


44

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

Declaraciones� La sintaxis de una declaración es <%! declaración %>

o, alternativamente, usando los espacios de nombresde XML <jsp:declaration> declaración</jsp:declaration>

� Las declaraciones permiten introducir variables ymétodos a nivel de página y deben seguir la sintaxis de


45

métodos a nivel de página y deben seguir la sintaxis deJava.

� Las variables declaradas pueden inicializarse y debenestar terminadas por punto y coma.

� Las declaraciones de métodos, además de aquellosusados en la aplicación, pueden también incluir ajspInit() y jspDestroy().

Ejemplo de Declaración� Código de iniciación para un contador en una

página JSP que declara una variable y losmétodos jspInit() y jspDestroy():


46

<%! int counter;%>

<%! public void jspInit() {

counter = 0;

}

public void jspDestroy() {

}

%>

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 deuna expresión Java se convierta a una cadena de caracteres que seráincluida en la página generada.


47

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>>

Scriptlets� La sintaxis de un scriptlet es <% scriptlet %> o,

alternativamente, usando los espacios de nombres deXML <jsp:scriptlet> scriptlet </jsp:scriptlet>

� Se puede escribir cualquier fragmento de código Java,extendido por elementos HTML y no limitado a una


48

Se puede escribir cualquier fragmento de código Java,extendido por elementos HTML y no limitado a unalínea.

� Ejemplo de Scriptlets: El siguiente scriptlet produceuna secuencia de encabezados con tamañodecreciente:

<% for (int i=1; i<5; i++) { %>

<H<%=i%>>Java Server Pages</H<%=i>>

<% } %>

Comentarios� Los comentarios JSP usan elementos especiales,

distintos de los comentarios de HTML, para que nopuedan verse en los documentos enviados al cliente.

� Los comentarios pueden usarse también para bloquear


49

� Los comentarios pueden usarse también para bloquearla ejecución de ciertos fragmentos de la página JSP.

� Ejemplo: La siguiente instrucción no será ejecutada (nisiquiera será visible en la página enviada al cliente)

<%-- int i = 1; --%>

Ejemplo de Contador de Accesos: La siguiente páginaJSP muestra un contador de accesos a una página.

JSP: Ejemplo (contador de accesos)

<%-- 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>

50

<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>

contadoryfecha

Ejemplo con Formas: El siguiente ejemplo demuestracomo obtener los valores de un formulario.

JSP: Ejemplo (uso de formularios)

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

<HTML>

<BODY>

<%Enumeration fields = request.getParameterNames();%>

<TABLE border="1" >

51

<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>

programaformulario

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 muchosprocesos.Una alternativa es usar regiones críticas en scriptlets para

JSP: Manejo de Concurrencia

52

� Una alternativa es usar regiones críticas en scriptlets parasincronizar 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);

}

%>

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

JSP: Manejo de Excepciones

53

indicar que la página recibe las excepciones lanzadaspor algún scriptlet.

� Además, el atributo errorPage de la misma directivaindica la página JSP a la cual se redirigirá el objetoimplícito exception (de tipo Throwable) que describe elproblema.

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”%>

JSP: Manejo de Excepciones…

54

<%@page isErrorPage=”false” errorPage=”Error.jsp”%>

� la página redirige a su vez el objeto exception a lapágina Error.jsp .

� La página Error.jsp debe contener a su vez, ladirectiva:

<%@page isErrorPage=”true” %>

� Esta indicación permite acceder al objeto exceptionen la página Error.jsp .

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 laaplicación.

� El atributo session de la directiva page se usa para permitir onegar el acceso al objeto session en la página; por omisión, elobjeto session es accesible.La directiva indica que en la página

JSP: Manejo de Sesiones

55

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 elbrowser no maneja cookies, la sesión se mantiene porreescritura del URL.

� La sesión mantiene referencias a todos los objetos almacenadospero tan pronto como la sesión es invalidada o el plazo de losobjetos expira, los objetos se marcan para su recolección comobasura.

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úblicamentedisponible para todas las páginas y servlets JSP que compartan lamisma sesión:<% Book book = new Book();

session.putValue(“book”,book);

JSP: Manejo de Sesiones….

56

session.putValue(“book”,book);

%>

� El objeto book puede recuperarse realizando una coerción paraconvertirlo al tipo apropiado:<% Book book = (Book)session.getValue(“book”); %>

� No hay límite en el número de objetos que se pueden manejar enuna sesión, aunque un gran número de ellos reducirá elrendimiento del sistema.

� Generalmente, la duración de una sesión está limitada a 30minutos, aunque la duración puede ampliarse regularmente usandoel método setMaxIntactiveInterval(int secs).

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()%>

57

<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

<%--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 {

JSP: Ejemplo de Sesiones

58

} 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>

</HTML> session1

� Los archivos session2.jsp y session3.jsp son llamados por session1.jsp.

JSP: Ejemplo de Sesiones (Cont..)

<%--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") %>


59

<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>

</HTML>session2 session3 ErrorPage

Uso de cookies� Las cookies ya fueron introducidas en la

programación con servlets; en JSP es igual de simplesu programación.

� Las cookie se obtienen de la petición HTTP (objetorequest) y se mandan a la respuesta HTTP (objetoresponse) siempre que el cliente acepte las cookies.

JSP: Uso de Cookies

60

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 deexpiración (cambiando su edad máxima).

� Además, en cualquier momento se puede agregarnuevas cookies a las ya existentes.

<%--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>

JSP: Ejemplo de Cookies

61

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

Acciones Comunes� Las acciones permiten realizar tareas sofisticadas

reduciendo considerablemente la codificaciónrequerida en Java.

� Las acciones se manifiestan usando elementosespeciales (tags) los cuales promueven la reutilización

JSP: Acciones comunes

62

especiales (tags) los cuales promueven la reutilizaciónde componentes mejorando el mantenimiento de laaplicación.

� Algunas acciones más populares son:� usar componentes JavaBeans� redirigir mensajes� encadenar peticiones� incluir peticiones

� El modelo de componentes de JSP se basa en latecnología JavaBeans que son objetos con un esquemade nombramiento bien definido.

� Un bean encapsula sus propiedades, como variablesprivadas, las cuales se pueden leer o modificar usandométodos públicos apropiados.

JSP: Usar componentes JavaBeans

63

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.

� El elemento jsp:useBean también puede tener estructura, la cualconsiste de un scriptlet que realiza la iniciación de laspropiedades 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


64

� Una vez declarados los beans, sus propiedades pueden accederseusando 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 lasfacilidades que brinda JSP para copiar los valores asociados delos campos a los atributos del bean.

� El elemento<jsp:setProperty name=”book” property=”*”/>

� copia los valores pero sólo cuando los nombres enambos (los campos de la forma y los atributos delbean) coinciden.


65

bean) coinciden.� Cuando los nombres no coinciden, la

correspondencia se debe hacer explícita:<jsp:setProperty name=”book” property=”propName” parameter=”parmName”/>

� El siguiente JSP es un juego para adivinar un número.

JSP: Ejemplo de JavaBeans

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>

66

<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

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() %>

JSP: Ejemplo de JavaBeans (Cont…)

67

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>

� 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() {

68

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

}

else if (g < answer) { hint = "higher";}

else if (g > answer) { hint = "lower"; }

}

public boolean getSuccess() {

return success;

}


69

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;

}

}

JSP: Redirigir mensajes

� Una petición se puede redirigir hacia otra página JSP, servlet opágina HTML estática pasándole el contexto de la página quehace la invocación.

� El procesamiento continúa hasta el punto en el que ocurre laredirección para entonces detenerse por completo en esa página.

� El elemento <jsp:forward page=”anotherPage.jsp”/> redirige elprocesamiento a la página anotherPage.jsp conservando todo el

70

procesamiento a la página anotherPage.jsp conservando todo elprocesamiento realizado en la página actual.

� Un elemento <jsp:forward> también puede tener parámetros paraproporcionar 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>

<html>



<% double freeMem = Runtime.getRuntime().freeMemory();

double totlMem = Runtime.getRuntime().totalMemory();

double percent = freeMem/totlMem;

JSP: Ejemplo, redirigir mensajes

71

double percent = freeMem/totlMem;

if (percent < 0.5) { %>

<jsp:forward page="/jsp/forward/one.jsp"/>

<% } else { %>

<jsp:forward page="two.html"/>

<% } %>

</html>



<html>



<body bgcolor="white">

<font color="red">

VM Memory usage < 50%.

</html>

JSP: Ejemplo, redirigir mensajes (Cont….)

72



<html>




<font color="red">

VM Memory usage > 50%.

</html>

JSP: Incluir páginas

� El elemento <jsp:include> puede usarse para redirigiruna petición a cualquier página estática o dinámica queesté en el mismo contexto.

� La llamada también puede incluir los beans comoparámetros de la petición.

� Por ejemplo, el elemento <jsp:include

73

� Por ejemplo, el elemento <jsp:include

page=”shopingCart.jsp” flush=”true”/> permite teneracceso a cualquier bean y al contexto dinámicogenerado por la página invocante;

� finalmente, el contenido generado se inserta en ellugar del elemento <jsp:include>.

� La página incluida no puede hacer algunas cosas comoencabezados HTTP o hacer galletas.

JSP: Ejemplo de incluir páginasLa 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" %>

74

<%@ 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() %>

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,

76

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.

El atributo Import� Formato:

� <%@ page import=“package.class” %>� <%@ page import=“paqckage1,…, package.classN”%>

� Propósito:� Generar las declaraciones para importar clases en la parte

superior del Servlet.

Notas:

77

� 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

Ejemplo del atributo import

mab.*

78

Ejemplo del atributo import

Primer Acceso

79

Acceso Posterior

El atributo contentType� Formato:

<%@ page contentType=“MIME-Type”%><%@ page contentType=“MIME-Type;

charset=Character-Set”%>� Proposito:

80

Proposito:� Especifica el tipo MIME de la página generada

por el Servlet que resulta de la página JSP .

El atributo contentTypeFirst Last Email AddressMark Baker [email protected] Brown [email protected] Gates [email protected] Ellison [email protected]<%@ page contentType="application/vnd.ms-excel" %><%-- Son tabs en lugar de espacios entre las columnas --%>

81

<%-- Son tabs en lugar de espacios entre las columnas --%>

El atributo isThreadSafe� Formato:

� <%@ page isThreadSafe=“true”%> <%-- Default--%>� <%@ page isThreadSafe=“false”%>

� Propósito:� 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.

82

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.

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 + “.”);

83

out.println(“Your ID is “ + userID + “.”);idNum = idNum + 1;

%>

Código Threadsafe

<%! private int idNum = 0;%><%

String UserID = “userID” + idNum;synchronized(this) {

84

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.

Otros atributos de la directiva de page

� Session:� Permite Elegir no participar en sesiones.

� Buffer:� Cambia el tamaño minimo del buffer usado por el

JspWriter.� Autoflush:

Requiere al desarrollador explícitamente vaciar el buffer.

85

Autoflush:� Requiere al desarrollador explícitamente vaciar el buffer.

� Extends: � Cambia la clase padre del Servlet generado.

� Error:� Indica una página para manejar los errores inesperados.

� isErrorPage:� Indica que la página se puede utilizar como página del

error.

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

87

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.

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

90

� 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%>

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>";

%>

91

%><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(); %>

Usando el ContactSection� Embebido en la

página Web:

<HTML><BODY><HR><H1> My Page</H!>

92

<H1> My Page</H!>

<HR>

<%@ include file=“contactSection.jsp” %>

</BODY></HTML>

Creando bibliotecas de etiquetas JSP personalizadas

93

Los bibliotecas de etiquetas JSP (JSP TL)permiten definir y utilizar etiquetas JSP similaresa como se definen y usan en funciones típicas enlos lenguajes de programación.

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.

94

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.

La biblioteca de etiquetas JSP� Las páginas JSTL son también páginas JSP:

� JSTL es justamente un súper conjunto de la funcionalidad del 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).

95

(core, internationalization/format, XML y SQL) y soporte para un lenguaje de expresiones (EL: Expression Language).� 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.

¿Cómo obtener la Librería de Etiquetas?

� El proyecto Apache Taglibs es un repositorio open-source para las bibliotecas de etiquetaspersonalizadas JSP y proyectos asociados, talescomo las clases TagLibraryValidator y extensionesa herramientas para creación de páginas quesoportan biblioteca de etiquetas.

� Jakarta Taglibs -http://jakarta.apache.org/taglibs/

96

http://jakarta.apache.org/taglibs/� Para utilizar el estándar Taglib de la distribución

Jakarta Taglibs, simplemente copie los archivosJAR que están en el directorio lib de la distribuciónal directorio de la aplicación Web-INF/lib.� JSTL 1.0 API classes: jstl.jar,� Standard Taglib JSTL implementation classes:

standard.jar.

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.

97

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.

Instalando el JSTL� Copie el archivo JAR del JSTL al directorio lib de Tomcat:

� Si usas Windows la localización del directorio lib normalmente es $CATALINA_HOME\Webapps\ROOT\WEB-INF\lib.

� Copie los archivos JSTL TLD al directorio WEB-INF de Tomcat:� 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

98

� 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>.

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.

100

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.

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.

101

como etiquetas desconocidas del HTML. � La mayoría de los visualizadores Web normalmente

ignoran estas etiquetas desconocidas.

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

102

� 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.

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

103

� 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.

Lenguaje de expresiones (EL)� 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.

104

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.

Lenguaje de expresiones (EL)� 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

105

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).

Lenguaje de expresiones (EL)� 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

106

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}"/>

Lenguaje de expresiones (EL)� 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:

107

clases Java.util.List, los elementos pueden ser accedidos con la sintaxis siguiente:

${alist[4]}${aList[someVariable]}

Lenguaje de expresiones (EL)� 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.

108

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]}

Lenguaje de expresiones (EL)

� Existe un numero de variables implícitas de EL:

Variable name DescriptionpageScope 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 ) of all session scope variables.

109

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.

initParam A collection (a Java.util.Map) of all application initialization parameter values as a single String value per parameter.

pageContext An instance of the Javax.Servlet.jsp.PageContext class, providing access to various request data.

Lenguaje de expresiones (EL)� 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

110

antes, porque son parecidos a los utilizados por la mayoría de los lenguajes:

Lenguaje de expresiones (EL)

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.

111

/ 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).

func(args) A function call, where func is the function name and args is zero, one or more comma-separated function arguments.

Bibliotecas de etiquetas JSTL� 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

112

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.

Bibliotecas de etiquetas JSTL

biblioteca URI Prefijo

Core http://Java.sun.com/jstl/core-rt c

113

Core http://Java.sun.com/jstl/core-rt c

XML processing http://Java.sun.com/jstl/xml xI18N formatting http://Java.sun.com/jstl/fmt fmtDatabase access http://Java.sun.com/jstl/sql sqlFunctions http://Java.sun.com/jstl/functions fn

Bibliotecas de etiquetas JSTL� 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 :

114

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 -rtal final del URI que señala a la biblioteca: <%@ taglib prefix="c" uri="http://java.sun.com/jstl/ea/core-rt" %>

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 %>

115

� 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}"/>

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,

116

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.

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>

117

<%! declaration %> <jsp:declaration>declaration</jsp:declaration>

<%= expression %> <jsp:expression>expression</jsp:expression>

<% scriptlet %> <jsp:scriptlet>scriptlet</jsp:scriptlet>

Ejemplos JSTL

118

Sencillos

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" %>

119

<%@ 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>

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}">

121

<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>

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>.

123

<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.

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

124

� 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.

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>

125

<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>

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>

127

<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>

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.

129

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.

Desarrollando bibliotecas de etiquetaspersonalizadas 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

130

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.

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

131

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.

Invocación de una etiqueta

Obtain

handler

Set

propertiessetPageContext()

setParent()

doStartTag()

Process body

EVAL_BODY_INCLUDE

SKIP_BODY

132

Set attribute

values

doEndTag()

Stop

release()

EVAL_PAGESKIP_PAGE

release()

Continue

Un archivo de etiquetas sencillocopyright.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.

133

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.

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

134

� Por interactuar, queremos decir que el manejador de etiqueta lee o modifica los contenidos del cuerpo o causa evaluación interactiva del cuerpo.

Un archivo de etiquetas sencillo� 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: � empty, scriptless (por defecto), o tagdependent.

� Si es empty (vació), el intentar usar el cuerpo de la acción personalizada da como resultado un error de sintaxis.

135

personalizada da como resultado un error de sintaxis. � El valor scriptless significa que el cuerpo puede contener algunos

elementos JSP :� 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).

Un archivo de etiquetas sencillo� 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

136

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}.*

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/� Aquí tenemos dos carpetas de tag:

mytags y myothertags.

137

mytags/copyright.tagforEvenAndOdd.taghtmlFormat.tagmotd.tag

myothertags/foo.tagbar.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.

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" %>

138

<%@ page contentType="text/html" %><%@ taglib prefix="my" tagdir="/Web-INF/tags/mytags" %><html>

<body bgcolor="white">...<my:copyright/>

</body></html>

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

139

� 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.

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:

140

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

Otros ejemplos

141

Tags personalizados

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().

142

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.

Tag Handler Hola mundo// Greeter.Java

package mab;

import Javax.Servlet.jsp.JspException;import Javax.Servlet.jsp.tagext.SimpleTagSupport;import Java.io.IOException;

143

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

Tag Handler Hola mundo� 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:

144

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().

Tag Handler Hola mundo� 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

145

� Utilizamos este método para conseguir el acceso al stream de salida del JSP.

Tag Handler Hola mundo� Mapeo de tags a clases:

� Asumimos que esta clase esta en /Web-INF/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

146

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 /Web-INF/tags/mytags, traza una un tag llamado 'greeter' a la clase 'demo.mytags.tags.Greeter'.

Tag Handler Hola mundo<!– 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>

147

<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/

Tag Handler Hola mundo � 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

148

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.

Tag Handler Hola mundo� 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

149

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.

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"/>

150

<jsp:directive.page contentType="text/html"/>

<html><head><title>JSP Page</title></head> <body>



<my:greeter /></body>

</html></jsp:root>

Tag Handler Hola mundo� 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

151

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.

Ejemplo final de Tag

152


153


154


155

Ejemplo final de Tag� 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

156

� 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.

Open Source Tag Libraries� ver http://jakarta.apache.org/taglibs:

� Internationalization,� Database access,� Sending Mail,� JNDI,

Data/time,

157

� Data/time,� Populating/validating fields,� Per regular expressions,� Extracting data from other Web pages� XSL transformations,� And so on…

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

160

� 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.

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

161

� 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

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);

163

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.

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”)) {

164

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);

}

Enviando peticiones: Código ejemplo.(cont..)

public void doGet(HttpServletRequest req, HttpServletResponse res)throws ServletException, IOException {

ReuestDispatcher dispatcher = getServletContext(). getRequestDispatcher(address);

165

dispatcher.forward(request, response);}

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:

166

SomeClass value = new SomeClass(…);Session.setAttribute(“key”, value);// Use RequestDispatcher to forward to the JSP page.

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(…);

167

SomeClass value = new SomeClass(…);Get ServletContext().setAttribute(“key”, value);//Use RequestDispatcher to forward to JSP page

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:� Es el Servlet el que se ejecuta al momento de una petición.� Para el cliente es totalmente transparente.

� Lo que usted necesita entender sobre Servlets:

170

� Lo que usted necesita entender sobre Servlets:� 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.

� Ejemplo:

Combinando JSP + JavaBeans + JDBC

171

� Combinando JSP + JavaBeans + JDBC

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.

172

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)

<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"

/></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;

Ejemplos: JSP y Java Beans

Alumnos.jsp

173

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>

<%

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());

}%>

174

}%>

<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>

<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">

175


</tr>

</table>

<br> <center>

<input type="submit" name="btnContinuar" value="Registrar">

</center>

</form>

</div>

</body>

</html>

<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">

VerificaAlumnos.jsp

176

<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>

<br>

<jsp:setProperty name="alum" property="nombre" param="nombre"/>

<jsp:setProperty name="alum" property="apellido" param="apellido"/>

<jsp:setProperty name="alum" property="direccion" param="direccion"/>

<jsp:setProperty name="alum" 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>

<% }

177

<% }

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>

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;

}

Bean Alumnos.java

public void setApellido(String apellido)

{

this.apellido=apellido;

}

public String getApellido()

{

return(apellido);

}

public void setDireccion(String direccion)

{

this.direccion=direccion;

}

public String getDireccion()

{

178

}

public Connection getCn()

{

return(cn);

}

public void setNombre(String nombre)

{

this.nombre=nombre;

}

public String getNombre()

{

return(nombre);

}

{

return(direccion);

}

public void setTelefono(String telefono)

{

this.telefono=telefono;

}

public String getTelefono()

{

return(telefono);

}

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();

179

telefono=rs.getString("telefono").trim();

rs.close();

return(true);

}

else

{

this.nombre="";

apellido="";

direccion="";

telefono="";

rs.close();

return (false);

}

}

//try

catch(SQLException e)

{

this.nombre="";

apellido="";

direccion="";

telefono="";

return (false);

}

}

else return(false);

}

public boolean NuevoAlumno()

{

Statement st;

String sqlInsert;

if (cn!=null)

180

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);

}

}

jsp extendido

Documents