JavaBeans y JavaServer Pages: Guía rápida
Manuel Urueña
2 de diciembre de 2002
1. JavaBeans
Los JavaBeans se idearon como un mecanismo para diseñar componentes, generalmente
de tipo gráfico, que pudiesen ser reutilizados por los entornos de desarrollo integrado (IDE).
Para ello el interfaz de un JavaBean debería ser capaz de mostrar su contenido en tiempo de
ejecución. Esta característica ha hecho que los JavaBeans se utilicen en otros entornos, como
puede ser el desarrollo de aplicaciones web.
Un JavaBean no es más que una clase java que sigue ciertas convenciones en el nom-
brado de sus métodos, de forma que sea posible operar con ella en tiempo de ejecución.
Se dice que un JavaBean tiene propiedades1 (propiedad) y en función de que los métodos
getPropiedad() y setPropiedad() estén definidos la propiedad será de lectura, de escritura
o de lectura/escritura.
1.1. Ejemplo
public class UserInfoBean implements java.io.Serializable
{
private String first_name;
private String last_name;
private int lucky_number;
private boolean registered;
private byte[] categories;
// Un JavaBean debe tener, al menos, un constructor sin argumentos.
//
public UserBean()
{
//Does nothing
}
public String getFirstName()
{
return first_name;
}
public void setFirstName ( String name )
{
first_name = name;
}
public String getLastName()
{
return last_name;
1Además de propiedades los JavaBeans tienen eventos asociados aunque por simplicidad no se describen
en este documento.
2
}
public void setLastName ( String name )
{
last_name = name;
}
// Una propiedad no tiene que coincidir con un atributo de la clase.
//
public String getFullName()
{
return first_name + " " + last_name;
}
// Las propiedades pueden ser de cualquier tipo básico,
// no sólo ’String’.
//
public void setLuckyNumber ( int num )
{
lucky_number = num;
}
public int getLuckyNumber()
{
return lucky_number;
}
// Una propiedad de tipo ’boolean’ tiene una convención de nombres
// diferente para el método ’get()’
//
public boolean isRegistered()
{
return registered;
}
public void setRegistered ( boolean reg )
{
registered = reg;
}
}
3
2. JavaServer Pages
La tecnología de las JavaServer Pages (JSP) aparece para aliviar el engorro que supone
generar páginas web mediante servlets. Además de esta forma es posible dividir el trabajo de
construir una aplicación web entre programadores (servlets) y diseñadores gráficos (JSPs).
Una página JSP no es más que una página HTML que contiene ciertas etiquetas especiales
(acciones) o fragmentos de código (scriptlets) para incluir contenido dinámico en dichas pági-
na. El código HTML se añade tal cual a la respuesta, mientras que los elementos dinámicos
se evalúan con cada petición.
Figura 1: Petición de una página JSP
Cuando un cliente pide esa página al servidor de aplicaciones, se traduce a un fichero fuente
de Java que implementa un Servlet, se compila y se ejecuta para devolver el resultado de la
petición.
Una vez compilado el servlet, las peticiones posteriores se reducen a ejecutar dicho servlet
en lugar de realizar el proceso una y otra vez. Esta es la razón por la que la primera petición
tarda mucho más en responderse que las siguientes.
Dado que una JSP no es más que un servlet, hay que recordar que tódo el código se ejecuta
en el servidor, las respuestas son púramente páginas HTML 2.
2También es posible incluir javascript, applets o cualquier otro código que ejecute en el cliente
4
2.1. Ejemplo
Veamos ahora un sencillo ejemplo de página JSP3 y los diferentes estados por los que va
pasando.
Página JSP original:
<%@ page language=’java’ contentType=’text/html;charset=iso-8859-1’%>
<%@ page import=’java.util.Date’ %>
<html>
<head>
<title>Hola Mundo</title>
</head>
<body>
Hola, esto es una página JSP.
<p>La hora del servidor es <%= new Date() %></p>
</body>
</html>
Tras la fase de traducción, se obtiene el siguiente Servlet:
package org.apache.jsp;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import org.apache.jasper.runtime.*;
// <%@ page import=’java.util.Date’ %>
//
import java.util.Date;
public class hola_jsp extends HttpJspBase {
private static java.util.Vector _jspx_includes;
public java.util.List getIncludes() {
return _jspx_includes;
}
public void _jspService(HttpServletRequest request,
throws java.io.IOException, ServletException {
HttpServletResponse response)
// Ver sección de variables implícitas
//
3La sintaxís de las páginas JSP es muy similar a la utilizada por las ASPs.
5
JspFactory _jspxFactory = null;
javax.servlet.jsp.PageContext pageContext = null;
HttpSession session = null;
ServletContext application = null;
ServletConfig config = null;
JspWriter out = null;
Object page = this;
JspWriter _jspx_out = null;
try {
_jspxFactory = JspFactory.getDefaultFactory();
// <%@ page language=’java’ contentType=’text/html;charset=iso-8859-1’%>
//
response.setContentType("text/html;charset=ISO-8859-1");
pageContext = _jspxFactory.getPageContext(this, request, response,
null, true, 8192, true);
application = pageContext.getServletContext();
config = pageContext.getServletConfig();
session = pageContext.getSession();
out = pageContext.getOut();
_jspx_out = out;
out.write("\n");
out.write("\n\n");
out.write("<html>\n ");
out.write("<head>\n
out.write("<title>Hola Mundo");
out.write("</title>\n ");
out.write("</head>\n ");
out.write("<body>\n
out.write("<p>La hora del servidor es ");
");
Hola, esto es una página JSP.\n
");
// <%= new Date() %>
//
out.print( new Date() );
out.write("</p>\n ");
out.write("</body>\n");
out.write("</html>\n");
} catch (Throwable t) {
out = _jspx_out;
if (out != null && out.getBufferSize() != 0)
out.clearBuffer();
if (pageContext != null) pageContext.handlePageException(t);
} finally {
if (_jspxFactory != null) _jspxFactory.releasePageContext(pageContext);
}
}
6
}
Evidentemente el servlet tiene más cosas que la traducción directa de la página JSP y no
es necesario comprender totalmente su significado. Normalmente el diseñador de páginas JSP
nunca accede a este fichero si no es para depurar ciertos errores al compilar el Servlet, y por
supuesto nunca lo modifica directamente sino el JSP que lo genera.
Trás la ejecución del servlet anterior, este es el resultado:
<html>
<head>
<title>Hola Mundo</title>
</head>
<body>
Hola, esto es una página JSP.
<p>La hora del servidor es Wed Nov 06 13:25:34 CET 2002</p>
</body>
</html>
Como puede verse, el resultado es muy similar a la página JSP original.
2.2. Comentarios
<%!-- Esto es un comentario --%>
Los comentarios JSP, a diferencia de los comentarios en HTML, no se envían al cliente. Hay
que recordar que las páginas JSP son interpretadas exclusivamente por el servidor.
2.3. Directivas
<%@ page language=’java’ contentType=’text/html’
isErrorPage=’false’ errorPage=’error.jsp’
%>
Todas las páginas JSP deberían tener esta directiva. Los atributos más usuales son:
language: lenguaje empleado por la JSP (java por defecto).
contentType: contenido de la página JSP (text/html por defecto).
isErrorPage: indica si es una página de error (false por defecto).
errorPage: página a la que dirigirse cuando ocurre una excepción al procesar esta página.
Ver isErrorPage.
<%@ include file=’footer.html’ %>
Esta directiva añade el contenido del archivo especificado antes de comenzar la fase de tra-
ducción a Servlet.
<%@ page import=’java.util.*’ %>
Con esta directiva se puede importar clases que se utilizan en scriptlets dentro de la página.
7
2.4. Scriplets
Los Scriptlets no son más que fragmentos de código delimitados entre <% y %>, que se
ejecutan para resolver la petición de un usuario.
Hay un tipo especial de Scriplet delimitado entre <%= y %>. La expresión4 contenida se
calcula y el resultado se añade a la respuesta. Es decir,
<%= user.getName() %>
es exactamete igual a:
<% out.println(user.getName()); %>
Veamos ahora algunos fragmentos de scriptlets:
Browser:
<%
String user_agent = request.getHeader("User-Agent");
if (user_agent.indexOf("MSIE") != -1) {
%>
Internet Explorer
<% } else if (user_agent.indexOf("Mozilla") != -1) { %>
Netscape
<% } else { %>
Unknown
<% } %>
Dependiendo del tipo de navegador que emplea el cliente, la respuesta contendrá la cadena
de texto adecuada.
Otro ejemplo, en este caso se crea una tabla con tantas filas como elementos tenga el
catálogo:
<table>
<tr><th>Product</th><th>Price</th></tr>
for (int i=0; i<catalog.length; i++ ) {
ProductInfoBean product = catalog[i];
<%
%>
<tr>
<th>
<a href=’<%= response.encodeURL("view?id=" + product.getId()) %>’>
<%= product.getShortName() %>
</a>
</th>
<td><%= product.getPrice() %> Euros</td>
</tr>
<% } %>
</table>
4Nótese que no es necesario añadir un ’;’ puesto que se trata de una expresión.
8
En este ejemplo es también interesante la utilización del método encodeURL(String).
Aunque el servidor de aplicaciones suele emplear cookies para enlazar peticiones con sesiones
de clientes automáticamente, suele ser interesante reescribir los enlaces a otras páginas de la
aplicación para que contengan dicho identificador de sesión. Eso es lo que hace exactamente
el método encodeURL(String).
2.4.1. Variables implícitas
Al traducir una página JSP, el servlet generado define una serie de variables que pueden
emplearse en los scriptlets de la página:
javax.servlet.ServletContext
javax.servlet.ServletConfig
javax.servlet.jsp.JspWriter
javax.servlet.jsp.PageContext
javax.servlet.http.HttpServletRequest request
javax.servlet.http.HttpServletResponse response
javax.servlet.http.HttpSession
application
config
out
pageContext
session
java.lang.Throwable
exception
El caso de la variable exception es un poco especial. Esta variable sólo se define en las pági-
nas de error, es decir aquellas que definen en su directiva page el atributo is
Crear cuenta
Comentarios de: JavaBeans y JavaServer Pages: Guía rápida (0)
No hay comentarios