Java Server Pages (JSP)
JPS es una tecnología Java que permite generar contenido dinámico para web, en forma de documentos HTML, XML o de otro tipo. Esta tecnología es un desarrollo de la compañía Sun Microsystems. La Especificación JSP 1.2 fue la primera que se liberó y en la actualidad está disponible la Especificación JSP 2.1. Las JSP's permiten la utilización de código Java mediante scripts. Además, es posible utilizar algunas acciones JSP predefinidas mediante etiquetas. Estas etiquetas pueden ser enriquecidas mediante la utilización de Bibliotecas de Etiquetas (TagLibs o Tag Libraries) externas e incluso personalizadas.
Arquitectura
JSP puede
considerarse como una manera alternativa, y simplificada, de construir servlets. Es
por ello que una página JSP puede hacer todo lo que un servlet puede hacer, y
viceversa. Cada versión de la especificación de JSP está fuertemente vinculada
a una versión en particular de la especificación de servlets. El funcionamiento
general de la tecnología JSP es que el Servidor de Aplicaciones interpreta el
código contenido en la página JSP para construir el código Java del servlet a
generar. Este servlet será el que genere el documento (típicamente HTML) que se
presentará en la pantalla del Navegador del usuario.
JSP -> Servidor Aplicaciones (Servlets)
-> Cliente (Navegador)
Es posible
enriquecer el lenguaje de etiquetas utilizado por JSP. Para ello debemos
extender la capa de alto nivel JSP mediante la implementación de Bibliotecas de
Etiquetas (Tags Libraries). Un ejemplo de estas bibliotecas son las
proporcionadas por Sun bajo la denominación de JSTL o las distribuidas por
Apache junto con el Framework de Struts.
TagLibs -> JSP -> Servidor Aplicaciones
(Servlets) -> Cliente (Navegador)
El rendimiento
de una página JSP es el mismo que tendría el servlet equivalente, ya que el
código es compilado como cualquier otra clase Java. A su vez, la máquina
virtual compilará dinámicamente a código de máquina las partes de la aplicación
que lo requieran. Esto hace que JSP tenga un buen desempeño y sea más eficiente
que otras tecnologías web que ejecutan el código de una manera puramente
interpretada. La principal ventaja de JSP frente a otros lenguajes es
que el lenguaje Java es un lenguaje de propósito general que excede el mundo
web y que es apto para crear clases que manejen lógica de negocio y acceso a
datos de una manera prolija. Esto permite separar en niveles las aplicaciones
web, dejando la parte encargada de generar el documento HTML en el archivo JSP.
Otra ventaja es que JSP hereda la portabilidad de Java, y es posible ejecutar
las aplicaciones en múltiples plataformas sin cambios. Es común incluso que los
desarrolladores trabajen en una plataforma y que la aplicación termine siendo
ejecutada en otra.
Los servlets y
Java Server Pages (JSPs) son dos métodos de creación de páginas web dinámicas
en servidor usando el lenguaje Java. En ese sentido son similares a otros
métodos o lenguajes tales como el PHP, ASP o los CGIs, programas que generan páginas web
en el servidor. Sin embargo, se diferencian de ellos en otras cosas. Para
empezar, los JSPs y servlets se ejecutan en una máquina virtual Java, lo cual
permite que, en principio, se puedan usar en cualquier tipo de ordenador,
siempre que exista una máquina virtual Java para él. Cada servlet (o JSP, a
partir de ahora lo usaremos de forma indistinta) se ejecuta en su propia hebra,
es decir, en su propio contexto; pero no se comienza a ejecutar cada vez que
recibe una petición, sino que persiste de una petición a la siguiente, de forma
que no se pierde tiempo en invocarlo (cargar programa + intérprete). Su persistencia le permite
también hacer una serie de cosas de forma más eficiente: conexión a bases de
datos y manejo de sesiones, por ejemplo. Las JSPs son en realidad una forma
alternativa de crear servlets ya que el código JSP se traduce a código de
servlet Java la primera vez que se le invoca y en adelante es el código del
nuevo servlet el que se ejecuta produciendo como salida el código HTML que
compone la página web de respuesta.
Ejemplo de Documento JSP
Ejemplo de código de una página JSP:
<%@ page
errorPage="myerror.jsp" %>
<%@ page
import="com.foo.bar" %>
<html>
<head>
<%! int serverInstanceVariable =
1;%>
...
<% int localStackBasedVariable =
1; %>
...
Ejemplo de una
compilación o "Salida" JSP:
package jsp_servlet;
import java.util.*;
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
import javax.servlet.jsp.*;
import javax.servlet.jsp.tagext.*;
import com.foo.bar; //importado como
resultado de <%@ page import="com.foo.bar" %>
import ...
class _myservlet implements
javax.servlet.Servlet, javax.servlet.jsp.HttpJspPage {
//insertado
como
//resultado de <%! int serverInstanceVariable = 1;%>
int
serverInstanceVariable = 1;
...
public void _jspService( javax.servlet.http.HttpServletRequest request,
javax.servlet.http.HttpServletResponse response )
throws javax.servlet.ServletException,
java.io.IOException
{
javax.servlet.ServletConfig config = ...;//obtener la configuración del
servlet
Object page = this;
PageContext pageContext = ...;//obtener el contexto de la pagina para
esta petición
javax.servlet.jsp.JspWriter
out = pageContext.getOut();
HttpSession session = request.getSession( true
);
...
Para ejecutar
las páginas JSP, se necesita un servidor Web con un contenedor Web que cumpla
con las especificaciones de JSP y de Servlet. Tomcat 5 es una
completa implementación de referencia para las especificaciones Java Servlet
2.2 y JSP 1.1.
Variables Implícitas
Las páginas JSP
incluyen ciertas variables privilegiadas sin necesidad de declararlas ni
configurarlas:
Variable
|
Clase
|
pageContext
|
javax.servlet.jsp.PageContext
|
request
|
javax.servlet.http.HttpServletRequest
|
response
|
javax.servlet.http.HttpServletResponse
|
session
|
javax.servlet.http.HttpSession
|
config
|
javax.servlet.ServletConfig
|
application
|
javax.servlet.ServletContext
|
out
|
javax.servlet.jsp.JspWriter
|
page
|
java.lang.Object
|
exception
|
java.lang.Exception
|
Directivas
Son etiquetas a
partir de las cuales se genera información que puede ser utilizada por el motor
de JSP. No producen una salida visible al usuario sino que configura cómo se
ejecutará la página JSP.
Su sintaxis es:
<%@ directiva atributo="valor"
%>
Las directivas
disponibles son:
- include: Incluye el contenido de un
fichero en la página mediante el atributo file.
<%@ include file="cabecera.html" %>
- taglib: Importa bibliotecas de etiquetas
(Tag Libraries)
<%@ taglib uri="/tags/struts-html"
prefix="html" %>
- page: Especifica atributos relacionados
con la página a procesar. Los atributos son:
Atributo
|
Sintaxis
|
Utilización
|
import
|
<%@ page import="class; class" %>
|
Importa clases y paquetes Java
para ser utilizadas dentro del fichero JSP.
|
session
|
<%@ page session="false" %>
|
Especifica si utiliza los datos
contenidos en sesión; por defecto "true".
|
contentType
|
<%@ page contentType="class; class" %>
|
Especifica el tipo MIME del objeto
"response"; por defecto "text/html; charset=ISO-8859-1".
|
buffer
|
<%@ page buffer="12KB" %>
|
Buffer utilizado por el objeto
writer "out"; puede tomar el valor de "none"; por defecto
"8KB".
|
errorPage
|
<%@
page errorPage="/path_to_error_page" %>
|
Especifíca la ruta de la página de
error que será invocada en caso de producirse una excepción durante la
ejecución de este fichero JSP.
|
isErrorPage
|
<%@ page isErrorPage="true" %>
|
Determina si este fichero JSP es
una página que maneja excepciones. Únicamente a este tipo de páginas pueden
acceder a la variable impícita "exception", que contiene la
excepción que provocó la llamada a la página de error.
|
Declaraciones
Nos permiten
declarar variables, funciones y datos estáticos.
<%! int maxAlumnosClase = 30; %>
Scriptlets
Los scriptlets
son partes de código Java incrustadas entre los elementos estáticos de la
página.
<% ... código Java ... %>
Expresiones
Las expresiones
se evalúan dentro de la servlet. No deben acabar en ";".
<%= maxAlumnosClase + 1%>
El siguiente
ejemplo pondría como título de la página el atributo "título"
contenido en el objeto request:
<%
String titulo = "";
if (request.getAttribute("titulo") != null) {
titulo = (String) request.getAttribute ("titulo");
}
%>
...
<title><%=titulo%></title>
....
Etiquetas
Etiquetas JSP
para simplificar el código y dar mayor funcionalidad.
Desarrollar
sitios web utilizando etiquetas presenta ciertas ventajas como:
- facilitar
el aprendizaje.
- facilitar
el mantenimiento.
- fomentar
la modularidad y la reutilización.
- simplificar
el código y reducir el número de líneas necesarias.
Su sintaxis
sería:
<%@ taglib uri="/taglib/lycka"
prefix="lycka" %>
...
<lycka:hola/>
...
A la hora de
generar el código Java de la Servlet, esta etiqueta hola será
interpretada por el Servidor de Aplicaciones como perteneciente a la biblioteca
de etiquetas (Tag Library) lycka. Esta biblioteca estará identificada en
el fichero descriptor de nuestra aplicación (web.xml) con el nombre de recurso
(URI) /taglib/lycka.
<taglib-uri>/taglib/lycka</taglib-uri>
<taglib-location>/WEB-INF/tags/lycka.tld</taglib-location>
Una
implementación de este fichero descriptor, /WEB-INF/tags/lycka.tld
podría ser:
<?xml version="1.0"
encoding="ISO-8859-1" ?>
<!DOCTYPE taglib PUBLIC "-//Sun
Microsystems, Inc.//DTD JSP Tag Library 1.1//EN"
<taglib>
<tlibversion>1.0</tlibversion>
<jspversion>1.1</jspversion>
<shortname>simp</shortname>
<info>A simple sample tag library</info>
<tag>
<name>hola</name>
<tagclass>org.lcyka.taglibs.miEtiqueta</tagclass>
<bodycontent>empty</bodycontent>
<info>Alaba la belleza de mi gata.</info>
</tag>
</taglib>
Y por fin, el
servidor de aplicaciones sustituirá la etiqueta por su código Java asociado, org.lcyka.taglibs.miEtiqueta:
package org.lcyka.taglibs;
import ...;
public class miEtiqueta extends TagSupport {
public int doStart {
try {
pageContext.getOut().print("Mi gata
es preciosa");
} catch (IOException ioe) {
}
return SKIP_BODY;
}
Y finalmente el
navegador mostraría:
Mi gata es preciosa
Etiquetas JSP
Son las
etiquetas pertenecientes a la especificación JSP. Proporcionan una
funcionalidad básica.
Un primer grupo
de etiquetas proporciona funcionalidad a nivel de la página de una manera muy
simple:
- <jsp:forward>, redirige
la request a otra URL
- <jsp:include>, incluye
el texto de un fichero dentro de la página
- <jsp:plugin>, descarga
un plugin de Java (una applet o un Bean).
Un segundo
grupo permite manipular componentes JavaBean sin conocimientos de Java.
- <jsp:useBean>, permite
manipular un Bean
(si no existe, se creará el Bean), especificando su ámbito (scope), la
clase y el tipo.
- <jsp:getProperty>, obtiene
la propiedad especificada de un bean previamente declarado y la escribe en
el objeto response.
- <jsp:setProperty>,
establece el valor de una propiedad de un bean previamente declarado.
Etiquetas JSTL
Son
proporcionadas por Sun dentro de la distribución de JSTL.
- core,
iteraciones, condicionales, manipulación de URL y otras funciones
generales.
- xml, para la
manipulación de XML y para XML-Transformation.
- sql, para
gestionar conexiones a bases de datos.
- i18n, para la
internacionalización y formateo de las cadenas de caracteres como cifras.
Etiquetas Struts TagLib
Distribuidas
por Apache
para funcionar junto con el Framework de Struts.
- PHP
- Bean
- HTML
- Logic
- Nested
- vjgp
Etiquetas personalizadas
Anteriormente
hemos visto un ejemplo para crear una etiqueta personalizada almacenada en
nuestra propia biblioteca de etiquetas.
Para
desarrollar etiquetas personalizadas, utilizaremos la API de las bibliotecas de
etiquetas (Tag Libraries).
La API de las
Servlet de Java es:
javax.servlet.*
La API de JSP
extiende de esta API,
javax.servlet.jsp.*
Finalmente, la
API de las bibliotecas de etiquetas (Tag Libraries) extiende de esta última,
javax.servlet.jsp.tagext.*
Lo más
relevante de esta API son:
- Las interfaces
- Tag, que
todas las etiquetas deben implementar.
- BodyTag,
extiende a la anterior y define métodos adicionales para inspeccionar el
cuerpo de una etiqueta.
- Las clases
- BodyContent,
un manejador (handler) para leer y escribir en el cuerpo de una etiqueta.
- BodyTagSupport,
que implementa la interfaz BodyTag.
- TagAttributeInfo,
para obtener la información de los atributos de la etiqueta declarados en
el TLD.
- TagData,
que contiene los valores de los atributos.
- TagExtraInfo,
para especificar información extra de una etiqueta, como las variables
que introduce en el código o los atributos que serán validados.
- TagInfo,
basado en la información de la TLD.
- TagLibraryInfo,
representa la información de una TLD.
- TagSupport,
implementa la interfaz Tag.
- VariableInfo,
contiene información como el tipo y ámbito de las variables creadas o
modificadas por la etiqueta.
Podemos
encontrar una descripción más detallada en http://java.sun.com/j2ee/sdk_1.3/techdocs/api/javax/servlet/jsp/tagext/package-summary.html
Otro ejemplo de
etiqueta podría ser el siguiente código Java:
package org.lycka.taglibs;
import ...;
public class LowerCaseTag extends
BodyTagSupport {
public int doAfterBody() throws JspException {
try {
BodyContent body = getBodyContent();
JspWriter writer =
body.getEnclosingWriter();
String bodyString = body.getString();
if ( bodyString != null ) {
writer.print(
bodyString.toLowerCase());
}
} catch(IOException ioe) {
throw new JspException("Error:
IOException while writing to the user");
}
return SKIP_BODY;
}
}
Al encontrar el
inicio de la etiqueta, el runtime primero se invocará el método doStart() una
vez instanciada la clase. Puede devolver uno de los siguientes valores:
- SKIP_BODY,
no procesa el contenido del cuerpo de la etiqueta.
- EVAL_BODY_INCLUDE
, evalúa el cuerpo de la etiqueta.
- EVAL_BODY_TAG
, evalúa el cuerpo de la etiqueta y lanza el resultado a otro stream
almacenado en una propiedad de la etiqueta.
El método
doAfterBody() después de procesar el cuerpo de la etiqueta.
Finalmente se
invocará el método doEndTag(). Puede devolver:
- EVAL_PAGE,
para seguir procesando la página JSP
- SKIP_PAGE,
para dejar de procesar la página JSP, para por ejemplo redirigir la página
Declarado en el
descriptor de la biblioteca como
<tag>
<name>lowercase</name>
<tagclass>org.lycka.taglibs.LowerCaseTag</tagclass>
<bodycontent>JSP</bodycontent>
<info>Put body in lowercase.</info>
</tag>
Utilizado en la
página JSP
<%@ taglib
uri="/taglib/lycka" prefix="lycka" %>
...
<lycka:lowercase>Esto es un
EJEMPLO</lycka:lowercase>
Y su salida
sería
esto
es un ejemplo
No hay comentarios:
Publicar un comentario