Fundamentos de JSP

JSP Foundation
javaserver pages
AGENDA
JSP COMO PARTE DE JAVA EE
INTRODUCCIÓN A JSP
CICLO DE VIDA DE LAS PÁGINAS JSP
TÉCNICAS DE GENERACIÓN DE CONTEN. DIN. EN JSP
INVOCAR CÓDIGO JAVA USANDO ELEMENTOS DE SCRIPTING
JAVABEANS PARA JSP
MANEJO DE ERRORES
JSP como parte de Java EE
●
Arquitectura de Java EE
●
¿Qué significa Contenido Estático y Dinámico?
− Contenido estático
●
Generalmente página HTML estática.
●
Misma visualización para todos.
− Contenido dinámico
●
El contenido se genera dinámicamente en base a condiciones.
●
Las condiciones pueden ser
− Identificación de usuario.
− Hora del día.
− El usuario ingresó valores en base a formularios y selecciones.
●
JSP y Servlets como componentes Web
¿Qué es una página JSP?
●
Un documento basado en texto capaz de retornar tanto
contenido estático como dinámico a un browser cliente.
●
El contenido estático y dinámico puede estar
entremezclado.
●
Contenido estático
− HTML, XML, Texto.
¿Qué es una página JSP?
●
Contenido dinámico
− Código Java.
− Mostrar propiedades de JavaBeans.
− Invocar lógica del negocio definida en etiquetas
personalizadas.
●
Una página JSP simple
<html>
<body>
Hello World!
<br>
Current time is <%= new java.util.Date() %>
</body>
</html>
●
Beneficios de JSP
− La lógica de contenido y la de visualización están separadas.
− Simplifican el desarrollo de aplicaciones web con JSP,
JavaBeans y etiquetas personalizadas.
− Desarrollo automático
● Se recompila automáticamente cuando se hacen cambios a las
páginas JSP.
●
Facilitan la creación de páginas web.
●
Independientes de la plataforma.
●
¿Porqué JSP sobre Servlet?
− Servlets puede hacer muchas cosas, pero es engorroso:
●
Usar sentencias println() para generar páginas HTML.
●
Mantener dichas páginas HTML.
− No hay necesidad de compilar. Empaquetar, configurar
CLASSPATH.
●
¿Se tiene que hacer uso de JSP sobre Servlet o
viceversa?
− Se puede usar ambas aprovechando las fortalezas de cada
tecnología.
●
La fortaleza de los Servlets es “controlar y despachar”.
●
La fortaleza de los JSP es “visualizar”.
− En un ambiente de producción típico, tanto los Servlets como
los JSP se usan en un patrón muy conocido llamado MVC
(Model-View-Controller).
●
Los Servlets manejan la parte de controlador.
●
Los JSP manejan la parte de vista.
Arquitectura de JSP
Arquitectura de JSP
●
Arquitectura
Ciclo de Vida de una Página JSP
●
¿Cómo trabajan los JSP?
●
Fases del ciclo de vida de un JSP
− Fase de Traducción
− Fase de Compilación
− Fase de Ejecución
●
Fase de Traducción/Compilación
− Los archivos JSP se traducen a código de Servlets, el cual
luego se compila.
− Efectuado automáticamente por el contenedor.
− La primera vez que se accede a la página JSP después que
se despliega (o modifica y re-despliega).
− Para una página JSP “pageName” el código reside en
●
<JWSDP_HOME>/work/StandardEngine/localhost/context_root/
pageName$jsp.java
●
<JWSDP_HOME>/work/StandardEngine/localhost/date/index
$jsp.java
●
Fase de Traducción/Compilación
− Los datos de la Plantilla estática se transforman en código
que emitirá datos en el destino.
− Los elementos del JSP se tratan de manera diferente
●
Las directivas se usan para controlar como el Web container
traduce y ejecuta la página JSP.
● Los elementos de scripting se insertan en la clase Servlet de la
página JSP.
●
Los elementos de la forma <jsp:xxx…> se convierten en llamadas a
métodos para los componentes JavaBeans.
●
Ciclo de vida de un JSP durante la Fase de Ejecución
●
Inicialización de una página JSP
− Declare métodos para realizar las siguientes tareas usando el
mecanismo de declaración de JSP.
●
Leer datos de configuración persistente.
●
Inicializar recursos.
●
Realizar cualquier otra actividad a ejecutar una vez
sobreescribiendo el método jspInit() de la interfaz JspPage.
●
Finalización de una página JSP
− Declare métodos para realizar las siguientes tareas usando el
mecanismo de declaración de JSP.
●
Leer datos de configuración persistente.
●
Liberar recursos.
●
Realizar cualquier otra actividad de limpieza a ejecutar una vez
sobreescribiendo el método jspDestroy() de la interfaz JspPage.
●
Ejemplo: initdestroy.jsp
<%@ page import="database.*" %>
<%@ page errorPage="errorpage.jsp" %>
<%-- Declare initialization and finalization methods --%>
<%-- using JSP declaration --%>
<%!
private BookDBAO bookDBAO;
public void jspInit() {
// retrieve database access object,
//which was set once per web application
bookDBAO =
(BookDBAO)getServletContext().getAttribute("bookDB");
if (bookDBAO == null)
System.out.println("Couldn't get database.");
}
public void jspDestroy() {
bookDBAO = null;
}
} %>
Técnicas para generación de contenido
dinámico en JSP
●
Se pueden seleccionar varias técnicas dependiendo de
los siguientes factores
− Tamaño y complejidad del proyecto.
− Requisitos, necesidad de reusabilidad del código,
mantenimiento, grado de solidez.
●
Técnicas disponibles para incrementar gradualmente la
complejidad.
dinámico en JSP
●
Llamar al código de Java directamente dentro del JSP.
●
Llamar al código de Java indirectamente dentro del JSP.
●
Usar JavaBeans dentro del JSP.
●
Desarrollar y usar sus etiquetas personalizadas.
dinámico en JSP
●
Hacer uso de etiquetas personalizadas JSTL (JSP
Standard Tag Library).
●
Seguir el patrón de diseño MVC.
●
Hacer uso de frameworks Model2.
dinámico en JSP
●
Llamar al código de Java directamente dentro del JSP.
− Colocar todo el código de Java dentro de la página JSP.
− Adecuada sólo para una aplicación web muy simple.
●
Difícil de mantener.
●
Difícil para reutilizar el código.
●
Difícil de entender para los autores de páginas web.
dinámico en JSP
− No recomendada para aplicaciones Web relativamente
sofisticadas.
●
Separación débil entre el contenido y la presentación.
dinámico en JSP
●
Llamar al código de Java indirectamente.
− Desarrollar clases utilitarias separadas.
− Insertar en el JSP sólo el código necesario para invocar a las
clases utilitarias.
− Mejor separación entre la generación del contenido y la
lógica de presentación del método anterior.
− Mejor posibilidad de reutilización y mantenimiento que el
método anterior.
− Aun tiene una separación débil entre el contenido y la
presentación.
dinámico en JSP
●
Usar Java Beans
− Desarrollar clases utilitarias en forma de JavaBeans.
− Aprovechar la facilidad incorporada de los JSP para crear
instancias de JavaBeans, establecer y obtener propiedades
de los JavaBeans.
● Use los elementos de sintaxis de JSP.
− Más fácil de utilizar por los autores de páginas web.
− Mejor facilidad de reutilización y mantenimiento que el
método anterior.
dinámico en JSP
●
Desarrollar y usar Etiquetas personalizadas
− Desarrolle componentes sofisticados llamados etiquetas
personalizadas.
●
Las etiquetas personalizadas están diseñadas específicamente
para JSP.
− Más potentes que los componentes JavaBeans.
● Son más que métodos get y set.
− Capacidad de reutilización, mantenimiento, robustez.
dinámico en JSP
●
Usar Etiquetas personalizadas de terceros o JSTL
− Hay muchas etiquetas personalizadas de código abierto y
comerciales.
●
Apache Struts.
− JSTL (JSP Standard Tag Library) estandariza el conjunto de
etiquetas personalizadas que debería estar disponibles como
mínimo sobre la plataforma Java EE.
dinámico en JSP
●
Usar el patrón de diseño MVC
− Seguir el patrón de diseño MVC.
− O utilizar frameworks Model2 de código abierto o
comerciales.
●
Apache Struts.
●
Java Server Faces.
● Oracle ADF.
●
Otros frameworks
Invocar Código de Java con Elementos de
Script de JSP
●
Permite insertar código de Java en el Servlet que se
generará a partir de la página JSP.
●
Minimizar el uso de elementos de scripting en la página
JSP de ser posible.
●
Hay tres formas
− Expresiones: <%= Expresiones %>
− Scriplets: <% Código %>
− Declaraciones: <%! Declaraciones %>
Scripting de JSP
●
Expresiones
− Durante la fase de ejecución
●
La expresión se evalúa y se convierte en una cadena
●
La Cadena se inserta luego en el stream de salida del Servlet.
●
Se transforma en algo como out.println(expression)
● Puede usar variables predefinidas (objetos implícitos) dentro de la
expresión.
Scripting de JSP
− Formato:
●
<%= Expression %> ó
●
<jsp:expression>Expression</jsp:expression>
●
El punto y coma no está permitido en las expresiones
Scripting de JSP
●
Ejemplo: Expresiones
− Mostrar la fecha actual usando la clase Date
●
Fecha actual: <%= new java.util.Date() %>
− Mostrar un número aleatorio usando la clase Math
●
Número aleatorio: <%= Math.random() %>
Scripting de JSP
− Usar objetos implícitos
●
Nombre del host: <%= request.getRemoteHost() %>
●
Su parámetro: <%= request. getParameter(“yourParameter”) %>
●
Servidor: <%= application.getServerInfo() %>
● ID de Sesión: <%= session.getId() %>
Scripting de JSP
●
Scriplets
− Usado para insertar de manera arbitraria código de Java en el
método jspService() del Servlet.
− Puede hacer mas de lo que permiten las expresiones solas
●
Configurar encabezados de Response y códigos de estado.
●
Escribir a un log de Servlet.
● Actualizar la base de datos.
●
Ejecutar código que contiene ciclos repetitivos, condicionales.
Scripting de JSP
− Puede usar variables predefinidas (objetos implícitos).
− Formato:
●
<% Código de Java %> ó
●
<jsp:scriptlet> Código de Java</jsp:scriptlet>
Scripting de JSP
●
Ejemplo: Scriplets
− Mostrar una cadena de caracteres
●
<%
●
String queryData = request.getQueryString();
●
out.println(“Attached GET data: “ + queryData);
● %>
− Colocar el tipo de response
●
<% response.setContentType(“text/plain”); %>
Scripting de JSP
●
Ejemplo: Scriplet con repetición
<%
Iterator i = cart.getItems().iterator();
while (i.hasNext()) {
ShoppingCartItem item =(ShoppingCartItem)i.next();
BookDetails bd = (BookDetails)item.getItem();
%>
<tr>
<td align="right" bgcolor="#ffffff"><%=item.getQuantity()
%></td>
<td bgcolor="#ffffaa">
<strong>
<a href="<%=request.getContextPath()%>/bookdetails?
bookId=
<%=bd.getBookId()%>"><%=bd.getTitle()%></a></strong>
</td>
...
<%
// End of while
}
%>
Scripting de JSP
●
Se usa para definir variables o métodos que se insertan
en el cuerpo principal de la clase Servlet.
− Fuera del método _jspService()
− Los Objetos implícitos no son accesibles en las
declaraciones.
●
Usualmente se usan con las Expresiones o Scriplets.
Scripting de JSP
●
Para la inicialización y limpieza en las páginas JSP, use
las declaraciones para sobreescribir los métodos
jspInit() y jspDestroy().
●
Formato:
− <%! Código de declaración de variable o método %>
− <jsp:declaration> Código de declaración de variable o método
</jsp:declaration>
Scripting de JSP
●
Ejemplo: Fragmento de página JSP
<H1>Some heading</H1>
<%!
private String randomHeading() {
return(“<H2>” + Math.random() + “</H2>”);
}
%>
<%= randomHeading() %>
Scripting de JSP
● Ejemplo: Código de Servlet resultante
public class xxxx implements HttpJSPPage {
private String randomHeading() {
return(“<H2>” + Math.random() + “</H2>”);
}
public void _jspService(HttpServletRequest request,
HttpServletResponse response)
throws ServletException, IOException {
response.setContentType(“text/html”);
HttpSession session = request.getSession(true);
JSPWriter out = response.getWriter();
out.println(“<H1>Some heading</H1>”);
out.println(randomHeading());
...
}
...
}
Incluir y derivar a otro Recurso Web
● Incluir contenidos en una página JSP
− Dos mecanismos para incluir otro recurso Web en una
página JSP
●
Directiva include
●
jsp:include elemento
●
Directiva Include
− Se procesa cuando la página JSP se traduce en una clase
Servlet.
− El efecto de la directiva es insertar el texto contenido en otro
archivo (texto estático u otra página JSP) en la página JSP
que incluye.
− Se usa para incluir contenido de banner, información de
copyright, o cualquier contenido que se desea reutilizar en
otra página.
●
Directiva Include
− Sintaxis y ejemplo:
●
<%@ include file="filename" %>
●
<%@ include file="banner.jsp" %>
●
jsp:include Elemento
− Se procesa cuando se ejecuta una página JSP
− Le permite incluir un recurso estático o dinámico en una
página JSP.
− Estático: Su contenido se inserta en el JSP que lo llama.
− Dinámico: El requerimiento se envia al recurso incluido, la
página incluida se ejecuta y luego el resultado se incluye en
el response de la página JSP que lo llamó.
●
jsp:include Elemento
− Sintaxis y ejemplo
●
<jsp:include page="includedPage" />
●
<jsp:include page="date.jsp"/>
●
¿Cuál usar?
− Use la directiva si el archivo cambia esporádicamente.
●
Es más rápida que jsp:include.
− Use jsp:include cuando el contenido varía a menudo.
− Use jsp:include cuando el cuál página incluir no se decide
hasta que la página principal es requerida.
● Derivar a otro componente Web
− El mismo mecanismo que en los Servlets
− Sintaxis
●
<jsp:forward page="/main.jsp" />
− El request original es proporcionado al destino vía
jsp:parameter elemento
●
<jsp:forward page="..." >
●
<jsp:param name="param1" value="value1"/>
●
</jsp:forward>
Directivas
●
Las directivas son mensajes al contenedor JSP para
afectar la estructura general del Servlet.
●
No producen salida en el stream de salida actual.
●
Sintaxis
− <%@ directive {attr=value}* %>
Directivas
● Tres tipos de directivas
− page: Comunica atributos dependientes de la página y los
comunican al contenedor JSP.
● <%@ page import="java.util.* %>
− include: Usada para incluir texto y/o código al momento de la
traducción de la página JSP
●
<%@ include file="header.html" %>
− Taglib: Indica una biblioteca de etiquetas que el JSP debería
interpretar
● <%@ taglib uri="mytags" prefix=“mtg" %>
Directivas
●
Directivas de Página
− Dan información de alto nivel sobre el Servlet que resulta de
la página Web.
Directivas
● Directivas de Página
− Controla
● Qué clases se importan
− <%@ page import="java.util.* %>
● Qué tipo MIME se genera
− <%@ page contentType="MIME-Type" %>
● Cómo se maneja el multithreading
− <%@ page isThreadSafe="true" %> <%!--Default --%>
− <%@ page isThreadSafe="false" %>
● Qué página maneja los errores inesperados
− <%@ page errorPage="errorpage.jsp" %>
Objetos de Ámbito
●
Objetos implícitos
− Una página JSP tiene acceso a ciertos objetos implícitos que
siempre están disponibles, sin ser declarados.
●
Creados por el contenedor.
●
Corresponden a clases definidas en el Servlet.
Objetos de Ámbito
● Objetos implícitos
− Objetos implícitos
● request (HttpServletRequest)
● response (HttpServletRepsonse)
● session (HttpSession)
● application(ServletContext)
● out (de tipo JspWriter)
● config (ServletConfig)
● pageContext
Objetos de Ámbito
● Diferente ámbito Objetos accesibles desde páginas
que pertenecen a la misma
aplicación.
Más visible Application
Objetos accesibles desde páginas
en la misma sesión donde fueron
Session creadas.
Objetos accesibles desde páginas

Request que están procesando el request
donde se crearon.
Menos visible Page Objetos accesibles sólo dentro de
las páginas donde se crearon.
Componentes JavaBean para JSP
●
¿Qué son JavaBeans?
− Clases de Java que se pueden reutilizar con facilidad y
ensamblar para formar una aplicación.
− Cualquier clase de Java que sigue ciertas convenciones de
diseño puede ser un JavaBean.
● Propiedades de la clase.
●
Métodos públicos para obtener y establecer propiedades.
●
¿Qué son JavaBeans?
− Dentro de una página JSP, puede crear e inicializar beans y
obtener y establecer valores de sus propiedades.
− Los JavaBeans pueden contener lógica del negocio o lógica
de acceso a base de datos.
●
¿Porqué usar JavaBeans en páginas JSP?
− Las páginas JSP pueden usar los elementos de JSP para
acceder a los objetos que cumplen con las convenciones de
los JavaBeans.
●
<jsp:useBean id="cart" class="cart.ShoppingCart“ scope="session"/>
− Cree una instancia de “ShoppingCart” si no existe, la
almacena como un atributo del objeto de ámbito session, y
pone disponible el objeto en la sesión con el identificador
“cart”.
● Crear un JavaBean
− Declare que la página va a usar un bean que se va a almacenar
y será accesible en un ámbito especificado con jsp:useBean
elemento.
● <jsp:useBean id="beanName“ class="fully_qualified_classname“
scope="scope"/>
●
ó
● <jsp:useBean id="beanName“ class="fully_qualified_classname“
scope="scope">
● <jsp:setProperty .../>
● </jsp:useBean>
●
Establecer propiedades de JavaBeans
− 2 maneras de establecer una propiedad de un bean.
− Vía scriplet
●
<% beanName.setPropName(value); %>
●
− Vía jsp:setProperty
●
<jsp:setProperty name="beanName“ property="propName"
value="string constant"/>
− “beanName” debe ser el mismo que el especificado por el
atributo id en un useBean elemento.
− Debe haber un método setPropName en el bean.
●
− La sintaxis de jsp:setProperty depende de la fuente de la
propiedad
● <jsp:setProperty name="beanName“ property="propName" value="
constante de cadena"/>
● <jsp:setProperty name="beanName“ property="propName"
param="paramName"/>
●
<jsp:setProperty name="beanName“ property="propName"/>
● <jsp:setProperty name="beanName" property="*"/>
● <jsp:setProperty name="beanName“ property="propName" value="<
%= expression %>"/>
●
Ejemplo: jsp:setProperty con parámetro Request
− <jsp:setProperty name="bookDB" property="bookId"/>
− lo mismo
<%
//Get the identifier of the book to display
String bookId = request.getParameter("bookId");
bookDB.setBookId(bookId);
...
%>
●
Ejemplo: jsp:setProperty con expresión
− <jsp:useBean id="currency" class="util.Currency“
scope="session">
− <jsp:setProperty name="currency" property="locale“ value="<
%= request.getLocale() %>"/>
− </jsp:useBean>
− <jsp:setProperty name="currency" property="amount“
value="<%=cart.getTotal()%>"/>
●
Obtener las propiedades de JavaBeans
− Dos maneras diferentes de obtener una propiedad de un Bean
● Convertir el valor de la propiedad a Cadena e insertar el valor en el
objeto implícito “out”.
●
Recuperar el valor de una propiedad sin convertirlo a cadena e
insertarlo en el objeto “out”.
●
Obtener propiedades de los JavaBeans y convertirlos a
Cadena e insertarlo en out
− Dos maneras
●
Vía Scriplet
●
<%= beanName.getPropName() %>
− Vía jsp:setProperty
●
<jsp:getProperty name="beanName“ property="propName"/>
●
Requisitos
− “beanName” debe ser el mismo que el especificado por el id
de atributo en un useBean elemento.
− Debe haber un método “getPropName()” en un bean.
● Obtener las propiedades de un JavaBean sin convertirlo a
Cadena
− Debe usar un Scriplet.
− Formato
● <% Object o = beanName.getPropName(); %>
● Obtener las propiedades de un JavaBean sin convertirlo a
Cadena
− Ejemplo
<%
// Print a summary of the shopping cart
int num = cart.getNumberOfItems();
if (num > 0) {
%>
● Acceder a objetos desde la página JSP
Manejo de Errores
● Crear una página de Errores de Excepción
− Determinar la excepción provocada.
− En cada una de sus JSP, incluir el nombre de la página de error.
● <%@ page errorPage="errorpage.jsp" %>
− Desarrollar una página de error, debería incluir
● <%@ page isErrorPage="true" %>
Manejo de Errores
●
Crear una página de Errores de Excepción
− En la página de error, use la referencia a la excepción para
mostrar información de la excepción
●
<%= exception.toString() %>
Manejo de Errores
●
Ejemplo: initdestroy.jsp
<%@ page import="database.*" %>
<%@ page errorPage="errorpage.jsp" %>
<%!
private BookDBAO bookDBAO;
public void jspInit() {
// retrieve database access object, which was set
// once per web application
bookDBAO =
(BookDBAO)getServletContext().getAttribute("bookDB");
if (bookDBAO == null)
System.out.println("Couldn't get database.");
}
public void jspDestroy() {
bookDBAO = null;
}
} %>
Manejo de Errores
●
Ejemplo: errorpage.jsp
<%@ page isErrorPage="true" %>
<%@ page import="java.util.*" %>
<%
ResourceBundle messages = (ResourceBundle)session.getAttribute("messages");
if (messages == null) {
Locale locale = null;
String language = request.getParameter("language");
if (language != null) {
if (language.equals("English")) {
locale = new Locale("en", "");
} else {
locale = new Locale("es", "");
}
} else
locale=new Locale("en", "");
messages = ResourceBundle.getBundle("BookStoreMessages", locale);
session.setAttribute("messages", messages);
}
%> ...
Manejo de Errores
●
Ejemplo: errorpage.jsp
... (continuación)
<html>
<head>
<title><%=messages.getString("ServerError")%></title>
</head>
<body bgcolor="white">
<h3><%=messages.getString("ServerError")%></h3>
<p>
<%= exception.getMessage() %>
</body>
</html>
Resumen
●
En esta sesión hemos revisado los conceptos básicos
del trabajo con Java Server Pages.

Fundamentos de JSP

Cargado por

Información del documento

Título original

Derechos de autor

Formatos disponibles

Compartir este documento

Compartir o incrustar documentos

Opciones para compartir

¿Le pareció útil este documento?

¿Este contenido es inapropiado?

Copyright:

Formatos disponibles

Fundamentos de JSP

Cargado por

Copyright:

Formatos disponibles

JSP Foundation

Objetos accesibles desde páginas

También podría gustarte