Estructura de las Páginas JSP
- Elementos Básicos

Una página JSP se puede componer de alguno de los siguientes cuatro grupos de componentes: Plantilla de Texto, Elementos de Script, Directivas y Etiquetas.

En esta sección se consideran solamente los 3 primeros:


1. Plantilla de Texto: HTML Estático

En muchos casos, un gran porcentaje de una JSP consiste simplemente de HTML estático, el cual se conoce como Plantilla de Texto. Excepto en un solo caso, este HTML se ve como un HTML normal, sigue todas las reglas de sintaxis y es simplemente "enviado" al cliente por el servlet creado para manejar la página. No sólo este HTML se ve normal, sino que puede ser creado con cualquiera de las herramientas típicas en la creación de páginas Web.

La única excepción en cuanto a la regla de que la plantilla de texto se envía directamente, es que si se desea tener la secuencia "<%" en la salida, uno requiere escribir "<\%" en la plantilla de texto.

Escribimos el siguiente código:

<html>

<head>
<title>
Plantilla de Texto
</title>
</head>

<body bgcolor="#ffeada">

<p>
Soy una página HTML y me van a convertir en una página JSP!
</p>

<hr>
<p>
Hay que cambiar la extensión de esta página (de .html a .jsp).
</p>

</body>
</html>

• Archivo: p041_Htm2Jsp.html

Lo salvamos en dir_code/web.

Visualmente podemos comprobar que cumple con la estructura típica de una página HTML funcional. Si cargamos la página en un navegador, comprobaremos que efectivamente, es una página HTML válida.

Renombramos esta página cambiando su extensión de .html a .jsp, ejecutamos el Ant, activamos nuestro servidor y accesamos la página con la URL:
http://localhost/curso/p041_Htm2Jsp.jsp.

Veremos que la página compila y corre exitosamente. El punto a tener en mente con este pequeño ejercicio, es que todas las páginas JSP se convierten en servlets Java y se compilan como clases Java estándard, así que en realidad una página JSP no es más que una manera sencilla de representar un servlet Java. Esto lo podemos comprobar abriendo el servlet producido por el servidor:
dir_tom/work/Standalone/localhost/curso/p041_Htm2Jsp_jsp.java.

Como se podrá apreciar, no es más que código Java, y que lo que teníamos como código HTML se convirtió en sentencias de salida (out.write()) dentro del método _jspService.

Acabamos de ver cómo la plantilla de texto forma la parte de presentación de una JSP, y como vimos, se compuso tan sólo de código HTML. Los siguientes componentes de una JSP nos permitirán trabajar con la parte de la lógica.

2. Elementos de Script

Los elementos de script permiten insertar código Java dentro del servlet a ser generado por la página JSP (por ejemplo, una sentencia if para generar HTML dependiente de ciertas condiciones). Los elementos de script se ejecutan cuando la página es requerida.

Existen cuatro tipos:

Elemento Descripción
<%-- comentario --%> Para colocar comentarios que no van a aparecer en el código generado.
<%= expresión %> Expresiones. Éstas se evalúan e insertan directamente en el flujo de salida.
<% código; %> Scriptlets. Éstos se insertan dentro del método _jspService() del servlet.
<%! declaración; %> Declaraciones a Nivel Clase. Éstas se insertan en el cuerpo de la clase servlet, fuera de cualquier método existente.

• Tabla: Elementos de Script

Nota:  Antes de ver cada uno de estos elementos, vale la pena aclarar que éstos deben usarse con cierto cuidado, en el sentido de que si se incluye demasiado código en las páginas JSP, uno puede acabar teniendo el mismo tipo de problemas de mantenimiento que en los servlets que incluyen HTML.

2.a. Comentarios

Así como se pueden colocar comentarios en el código HTML, también las páginas JSP cuentan con un mecanismo para colocar comentarios.

La sintaxis de un comentario JSP es como sigue:

<%-- este es un comentario JSP --%>

Un comentario JSP tiene la característica de que éste no aparece en la página generada, esto es, en la salida resultante del servlet.

2.b. Expresiones

Una expresión JSP es una forma "corta" de escribir valores Java directamente al flujo (stream) de salida, esto es, el contenido de una expresión se inserta en el método out.print(); exactamente como se haya escrito en la expresión.

La sintaxis de una expresión JSP es como sigue:

<%= expresión Java %>

La expresión Java es evaluada, convertida en una cadena (de texto) e insertada en la página. Esta evaluación se realiza al momento en que se requiere la página JSP, y por lo tanto tiene acceso completo a la información sobre la petición.

El siguiente fragmento JSP:

La fecha y hora actual: <%= new java.util.Date() %>

se convertirá en algo como lo siguiente:

out.write( "La fecha y hora actual: " );
out.print( new java.util.Date() );

en donde se muestra la fecha y hora (del servidor) en que la página fue requerida.

La sintaxis XML para definir expresiones es como sigue:

<jsp:expression>
  expresión Java
</jsp:expression>

Nota:  En cuanto a las expresiones, es importante recordar:

  1. Siguen las reglas de la programación Java.
  2. No se usa el punto y coma (;) al final de la expresión Java!
2.c. Scriptlets

Los scriplets JSP se utilizan para hacer cosas más complejas que simplemente insertar expresiones en la salida. Dentro de los scriptlets uno puede agregar todo el código Java que uno desee. Al momento de convertirse en un servlet, el código dentro del scriplet se coloca dentro del método _jspService(), debido a ello, no pueden declararse ni métodos ni variables a nivel clase (métodos o variables estáticos) dentro de un scriplet.

La sintaxis de un scriplet es como sigue:

<% código Java; %>

Al igual que las expresiones, los scriplets tienen acceso a las mismas variables definidas automáticamente (u objetos implícitos). Así, si se desea que la salida aparezca en la página resultante, uno utilizaría la variable out:

<%
  String sNombre = "Mónica";

  out.write( "Mi nombre es " + sNombre );
%>

El código anterior declara una variable sNombre con el valor Mónica y la despliega en la pantalla.

Hay que notar que el código escrito dentro de un scriplet se inserta exactamente como se haya escrito, y cualquier plantilla de texto (HTML estático) antes o después del scriplet se convierte en sentencias out.write().

Lo anterior significa que no se requiere colocar sentencias Java completas dentro de los scriplets, y los bloques dejados abiertos pueden afectar al HTML estático fuera de los scriplets.

El siguiente fragmento JSP:

<% if( Math.random() < 0.5 ) { %>
  Tengo mucho <b>calor</b>!
<% } else { %>
  Tengo mucho <b>frío</b>!
<% } %>

se convertirá en algo como lo siguiente:

if( Math.random() < 0.5 ) {
  out.write( "Tengo mucho <b>calor</b>!" );
} else {
  out.write( "Tengo mucho <b>frío</b>!" );
}

en donde se muestra un texto que depende de un resultado aleatorio.

El siguiente ejemplo contiene un scriplet y una expresión:

<%
  int iSaldo = request.getAttribute( "saldo" );

  if( iSaldo < LIMITE )
  {
    println( SIN_CREDITO );
  }
  String sSaldo = formatAsMoney( iSaldo );
%>
Su saldo actual es de $<%= iSaldo %>.

La sintaxis XML para definir scriplets es como sigue:

<jsp:scriptlet>
  Código
</jsp:scriptlet>

Nota:  En cuanto a los scriplets, es importante recordar:

  1. Siguen las reglas de la programación Java.
  2. se usa el punto y coma (;) al final del código Java!
  3. Un bloque de código puede empezar en un scriplet y terminar en otro.
  4. Si se requiere la secuencia "%>", uno tendrá que escribirla así "%\>".
2.d. Declaraciones a Nivel Clase

Las declaraciones a nivel clase (o declaraciones simplemente), permiten que uno agregue sus propios métodos y variables a nivel clase, los cuales pueden entonces ser accesados por los scriplets.

Nota:  Los métodos y variables a nivel clase quedan en el cuerpo principal (esto es, fuera de cualquier método) de la clase servlet que procesa la petición.

La sintaxis de una declaración es como sigue:

<%! declaración; %>

Por ejemplo:

<%! int iMaximo = 10; %>
<%! String sNombre = "Laura"; %>
<%! private void unMetodo() { ... } %>

Debido a que las declaraciones no generan ninguna salida, normalmente se utilizan en conjunción con las expresiones o los scriplets.

El siguiente fragmento JSP:

<%! private int iAccessCnt = 0; %>

La página se ha accesado  <%= ++iAccessCnt %>  veces.

se convertirá en algo como lo siguiente:

public class NombreDeLaClase
{
  private int iAccessCnt = 0;

  public void _jspService( ... ) throws ...
  {
    ...
      out.write( "La página se ha accesado " );
      out.print( ++iAccessCnt );
      out.write( " veces." );
    ...
  }
}

en donde se muestra el número de veces que la página actual ha sido requerida desde que el servidor arrancó (o que la clase servlet fue cambiada y recargada en memoria).

La sintaxis XML para definir declaraciones es como sigue:

<jsp:declaration>
  declaración
</jsp:declaration>

Nota:  En cuanto a las declaraciones, es importante recordar:

  1. Las variables y métodos se declaran utilizando la sintaxis estándard de Java.
  2. se usa el punto y coma (;) al final de la declaración.
  3. Cada variable o método debe ser declarado antes de poder ser referenciado.
  4. Si se requiere la secuencia "%>", uno tendrá que escribirla así "%\>".

3. Directivas

Las directivas son etiquetas de control en tiempo de compilación. Las directivas permiten personalizar la forma en que las páginas JSP se van a convertir en servlets Java, ya que una directiva afecta la estructura global de la clase servlet. Las directivas especifican información sobre la página misma, y que se mantiene igual a lo largo de múltiples peticiones (la página de manejo de excepciones, el rastreo de sesión, etc.).

La sintaxis de una directiva JSP es como sigue:

<%@ directiva atributo="valor" %>

También es posible combinar múltiples atributos para una sola directiva:

<%@ directiva atributo1="valor1"
              atributo2="valor2"
                     ...         %>

Existen tres tipos de directivas:

Directiva Descripción
<%@ page ... %> Para hacer cosas como importar clases, personalizar la super-clase servlet, y similares. También define atributos dependientes de la página, tales como rastreo de sesión, página de error, requerimientos de memoria.
<%@ include ... %> Para insertar un archivo en la clase servlet al momento en que el archivo JSP se está convirtiendo en servlet, esto es, permite incluir un archivo durante la fase de traducción.
<%@ taglib ... %> Para que los desarrolladores JSP puedan definir sus propias etiquetas -al declarar una biblioteca de etiquetas (tag library) conteniendo acciones personalizadas-, y que van a ser usadas en la página.

• Tabla: Directivas

La sintaxis XML para definir directivas es como sigue:

<jsp:directive.directiva atributo=valor />

Por ejemplo, el equivalente XML de:

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

es:

<jsp:directive.page import="java.util.*" />
3.a. page

La directiva page se coloca al inicio de la página JSP y permite que uno personalice diferentes características de la página.

La sintaxis de la directiva page es como sigue:

<%@ page atributo="valor" %>

Esta directiva permite definir uno o más de los siguientes atributos (sensibles a mayúsculas/minúsculas):

atributo="valor" Descripción
import="package.class" o

import="package.class1,..."
Especifica una lista (separada por comas) de clases, interfaces y/o paquetes a ser importados (incluidos) en la página. Por ejemplo:

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

El atributo import es el único que se permite que aparezca varias veces.
contentType="MIME-Type" o

contentType="MIME-Type;
  charset=Character-Set"
Especifica el tipo de contenido (tipo MIME) de la página JSP actual. El valor por omisión es text/html. Por ejemplo, la directiva:

 <%@ page contentType="text/plain" %>

tiene el mismo efecto que el scriplet:

 <% response.setContentType("text/plain"); %>
isThreadSafe="true|false" Un valor de true (valor por omisión) indica que el motor JSP enviará todas las peticiones que vayan llegando, a la misma instancia del servlet (lo cual es el procesamiento normal del servlet, donde múltiples peticiones pueden ser procesadas simultáneamente con una sola instancia de un servlet, bajo la presunción de que el autor sincronizó los accesos a las variables instanciadas).

Un valor de false indica que el servlet debe implementar el SingleThreadModel (modelo de hilo sencillo), bajo el cual, las peticiones van a ser entregadas al servlet en serie (una tras otra), o en el que las peticiones simultáneas serán enviadas a instancias separadas del servlet.
session="true|false" Un valor true (valor por omisión) indica que la variable predefinida session (del tipo HttpSession) debe anexarse a la sesión existente (si es que existe alguna), de lo contrario, deberá crearse una nueva sesión y anexarse a esa.

Un valor false indica que ninguna sesión será utilizada, y los intentos de acceder la variable session terminarán en errores al momento de convertir la JSP en un servlet.
buffer="none|tamaño" Especifica el tamaño (en Kb) del buffer para la variable out del JspWriter.

Se define en none (cuando no se desea utilizar "buffering"), o se define en un valor mayor a 8Kb (que es el valor por omisión -aunque en realidad, el valor por omisión es específico del servidor, pero debe ser de al menos de 8kb).
autoflush="true|false" Un valor de true (valor por omisión), indica que al llenarse el buffer, éste (su contenido) debe enviarse al cliente.

Un valor de false (raramente utilizado), indica que debe lanzarse una excepción al desbordarse el buffer.

El valor false es ilegal si al mismo tiempo se está utilizando el atributo: buffer="none".
extends="package.class" Indica la clase Java a ser "extendida" por el servlet generado.
info="mensaje" Define el mensaje que va a ser obtenido cuando se utilice el método getServletInfo.
errorPage="url" Especifica la URL de la página JSP que procesará todas las excepciones (Throwable) no atrapadas por la página actual.
isErrorPage="true|false" Un valor de true indica que la página actual es la página de error que va a recibir las excepciones no atrapadas por otras páginas. (esto es, si ésta es la página de error de otras páginas JSP, o no).

El valor por omisión es false.
language="java" Especifica el lenguaje utilizado en la página JSP. Por ahora, no hay que preocuparse por este atributo, ya que java es tanto el lenguaje por omisión, como el único lenguaje válido.
pageEncoding="encodingInfo" Especifica la codificación de caracteres para la página JSP.
El valor por omisión es utf-8.

• Tabla: Atributos de la directiva page

3.b. include

La directiva include permite que en la página JSP se inserte el contenido de otro archivo.

Debido a que el contenido del archivo incluido se interpreta como texto regular JSP, éste puede incluir HTML estático, elementos de script, directivas y etiquetas JSP (acciones).

La sintaxis de la directiva include es como sigue:

<%@ include file="URL relativa" %>

La URL especificada normalmente se interpreta como siendo relativa a la página JSP que hace referencia a ella. Sin embargo, uno puede indicarle al sistema que interprete la URL como absoluta (esto es, relativa al directorio base del servidor Web), por iniciar la URL con una diagonal ("/").

Por ejemplo:

<%@ include file="items/encabezado.html" %>

<body bgcolor="#ffeada">

<%@ include file="items/navbar.html" %>

<!-- código ... -->

</body>
</html>

El código anterior incluye por un lado, la sección correspondiente del encabezado de la página, y por otro, la sección correspondiente a la barra de navegación de la página.

El objetivo de esta directiva, es evitar el problema de mantenimiento de estar copiando un código (que es fijo) en cada una de las páginas que lo requiera.

Puesto que la directiva include inserta el contenido de los archivos durante la fase de traducción (cuando la página se traduce), si el contenido de estos archivos cambia, uno requiere re-traducir todas las JSP que hagan referencia a éstos.

Para una situación donde la página incluida cambia de manera poco frecuente, esta directiva resulta en una solución eficiente. Sin embargo, si los archivos incluidos cambian muy seguido, una mejor opción sería la de utilizar la Etiqueta (Acción) jsp:include (ver más adelante). Esta etiqueta incluye al archivo durante la fase de procesamiento de la petición (cuando el servlet es ejecutado).

3.c. taglib

Esta directiva sirve para utilizar Etiquetas Personalizadas en una página JSP.

La sintaxis de la directiva taglib es como sigue:

<%@ taglib uri="tag-lib-uri" prefix="tag-prefix" %>

Como puede observarse, esta directiva requiere dos atributos.

El atributo uri contiene la localización del archivo TLD (Tag Library Descriptor) de la Biblioteca de Etiquetas, mientras que el atributo prefix es el prefijo de etiqueta que uno desea utilizar para su etiqueta personalizada.

Por ejemplo:

<%@ taglib uri="/WEB-INF/tlds/tags.tld" prefix="xgms" %>

<xgms:hora />

El código anterior describe una etiqueta con el prefijo xgms que muestra la hora actual.

El tema de las etiquetas personalizadas se verá más adelante.

4. Ejemplos

En los ejemplos a continuación se va a utilizar la sintaxis JSP, sin embargo, en la práctica puede ser más fácil y más recomendable utilizar la sintaxis XML (es más clara la intención y no hay que estar recordando una sintaxis críptica y rebuscada).

4.a. Ejemplo 1

El primer ejemplo es la consolidación de todos los fragmentos de código previos, así que incluye todos los elementos básicos de una página JSP: Plantilla de texto, expresiones, scriplets y directivas. Este ejemplo consta de dos archivos, ya que se va a ver el atributo include de la directiva page.

Escribimos el código correspondiente a la página principal:

<%@ page buffer="none" %>

<%@ include file="p052_Hdr.jsp" %>

<body bgcolor="#ffeada">

<p>
La fecha y hora actual del servidor:
<%= new java.util.Date() %>
</p>

<p>
La página se ha accesado  <%= ++iAccessCnt %>  veces desde
el arranque del servidor o desde la última compilación de
la página.
</p>

<p>
<%
  String sNombre = "Mónica";

  out.write( "Mi nombre es " + sNombre );
  out.write( ", y " );
%>

  <% if( Math.random() < 0.5 ) { %>
    tengo mucho <span style="color:red;">calor</span>!
  <% } else { %>
    tengo mucho <span style="color:blue;">frío</span>!
  <% } %>
</p>

</body>
</html>

• Archivo: p051_Pag.jsp

Y el código correspondiente al encabezado a ser incluido:

<html>

<head>
<title>
Inclusión de un Archivo
</title>

<%!
  private int iAccessCnt = 0;
%>
</head>

• Archivo: p052_Hdr.jsp

Los salvamos en dir_code/web, ejecutamos el Ant y accesamos la página principal con el URL: http://localhost/curso/p051_Pag.jsp.

4.b. Ejemplo 2

Este es un ejemplo sencillo en el cual se va a ver el atributo pageEncoding de la directiva page. El objetivo es desplegar un par de Kanji (ideogramas japoneses) que representan la palabra Nihon (Japón en japonés):

<%@ page pageEncoding="euc-jp" %>

<html>

<head>
<title>
Codificación de una Página
</title>
</head>

<body bgcolor="#ffeada">

<p>
<big>
**** - La palabra "Jap*n" en "Kanji".
</big>
</p>

</body>
</html>

• Archivo: p061_Kanji.jsp

Antes de salvar el archivo, hay que hacer algunos cambios:

  1. Colocamos el teclado en modo numérico y sobreescribimos el primer grupo de asteriscos por los siguientes códigos ASCII (presionando la tecla Alt y el número de código):
    • Alt-146
    • Alt-129
    • Alt-211
    • Alt-154
  2. Y sobreescribimos el último asterisco con la siguiente secuencia:
    • &#243;

Una vez hechos los cambios, salvamos el archivo en dir_code/web, ejecutamos el Ant y accesamos la página con el URL: http://localhost/curso/p061_Kanji.jsp.

Podemos ver el efecto sobre la página resultante si cambiamos el valor del atributo pageEncoding, de euc-jp:

<%@ page pageEncoding="euc-jp" %>

a utf-8 (el valor por omisión):

<%@ page pageEncoding="utf-8" %>

El cambio lo hacemos directamente sobre la página en dir_app. Para ver el cambio actualizamos la vista de la página.

4.c. Ejemplo 3

Este ejemplo muestra los atributos errorPage y isErrorPage de la directiva page.

Ya conocemos el proceso, salvar los archivos en dir_code/web, ejecutar el Ant y acceder la página con el URL: http://localhost/curso/p071_Ndx.jsp.

La página de inicio:

<%@ page
  import="java.util.Calendar, java.util.Date, java.text.DateFormat" %>

<html>

<head>
<title>
Manejo de Excepciones
</title>
</head>

<body bgcolor="#ffeada">

<p>
Este ejemplo muestra el manejo de excepciones.

<a href="p072_Menu.jsp">Continuar</a>.
</p>

<%!
  Calendar calHoy = Calendar.getInstance();
  Date     fchHoy = calHoy.getTime();
%>

<hr>
<p>
La fecha de hoy:

<%=
  DateFormat.getDateInstance().format( fchHoy )
%>
</p>

</body>
</html>

• Archivo: p071_Ndx.jsp

La página del menú de opciones:

<%@ page errorPage="p079_ErrPrc.jsp" %>

<html>

<head>
<title>
Manejo de Excepciones - Menú
</title>
</head>

<body bgcolor="#ffeada">

<p>
En esta página vamos a activar diferentes excepciones
por medio de:
</p>

<ol>
<li>
Una página que ocasiona una
<a href="p073_Cero.jsp">división entre cero</a>.
</li>

<li>
Una página que intenta acceder un
<a href="p074_Vector.jsp">vector nulo</a>.
</li>

<li>
Una página que
<a href="p07x_NoExiste.jsp">no existe</a>.
</li>
</ol>

</body>
</html>

• Archivo: p072_Menu.jsp

La página que ocasiona una excepción de división entre cero:

<%@ page errorPage="p079_ErrPrc.jsp" %>

<html>

<head>
<title>
Manejo de Excepciones
</title>
</head>

<body bgcolor="#ffeada">

<%
  int i = 5 / 0;
%>

</body>
</html>

• Archivo: p073_Cero.jsp

La página que ocasiona una excepción al intentar acceder un método de un vector nulo:

<%@ page
      import="java.util.Vector"
      errorPage="p079_ErrPrc.jsp"
%>

<html>

<head>
<title>
Manejo de Excepciones
</title>
</head>

<body bgcolor="#ffeada">

<%! Vector vec = null; %>

<p>
Un vector de  <%= vec.size() %>  elementos.
</p>

</body>
</html>

• Archivo: p074_Vector.jsp

La página de proceso de excepciones:

<%@ page
      isErrorPage="true"
      session="false"
%>

<html>

<head>
<title>
Manejo de Excepciones - Despliegue
</title>
</head>

<body bgcolor="#ffeada">

<h4>
Se ha detectado un error!
</h4>

<%!
  Exception ex;
  String    sExMsg;
  String    sExClass;
%>

<%
  ex = pageContext.getException();

  if( ex == null )
  {
    sExMsg   = "Excepción nula";
    sExClass = "Desconocida";
  }
  else
  {
    sExMsg   = ex.getMessage();
    sExClass = ex.getClass().getName();
  }
%>

<p>
Excepción:  <%= sExMsg %>
</p>

<p>
Excepción en la Clase:  <%= sExClass %>
</p>

<p>
Servidor de Aplicaciones:  <%= application.getServerInfo() %>
</p>

<p>
[ <a href="p072_Menu.jsp"><< Regresar</a> ]
</p>

</body>
</html>

• Archivo: p079_ErrPrc.jsp

La siguiente parte es una breve referencia a todas las variables definidas automáticamente (u objetos implícitos). De hecho hicimos uso de algunas de ellas (out, pageContext y application) en los ejemplos anteriores.

5. Objetos Implícitos

La tecnología JSP pone a la disposición de cualquier página JSP un conjunto de objetos conocidos como objetos implícitos. Estos objetos implícitos son instancias de clases Java (esto es, representan objetos Java) creadas automáticamente por el mecanismo JSP. Proveen métodos útiles e información para una página JSP, y permiten una interacción con el ambiente servlet subyacente.

Nota:  Estos objetos implícitos sólo pueden utilizarse dentro de scriptlets o expresiones.

Si se intentan usar estos objetos en un método definido en una declaración, se ocasionará un error de compilación durante la fase de traducción, ya que tal uso causa que la página haga referencia a una variable indefinida.

A continuación se describe cada uno de ellos.

5.a. page

El objeto page representa la instancia del servlet generado desde esta página JSP. Es creada cuando la página se traduce (a un servlet), Por omisión, la clase servlet es nombrada como el archivo JSP.

Para utilizar el objeto page, uno debe convertirlo al tipo de clase del servlet que implementa la página JSP, ya que está definido como una instancia de la clase java.lang.Object.

Puesto que al utilizarse dentro de un scriplet (en una página JSP), page es sinónimo de la palabra reservada Java this, en lugar de utilizar page, se recomienda que uno utilice this para referenciar la instancia del servlet y obtener acceso a los parámetros de inicialización.

5.b. request

El objeto request representa una petición HTTP, esto es, representa un objeto HttpServletRequest (es una instancia de la clase que implementa el interface javax.servlet.http.HttpServletRequest, que a su vez extiende el interface javax.servlet.ServletRequest).

Este objeto contiene información sobre la petición del navegador y tiene métodos útiles para obtener una cookie, el encabezado y datos de la sesión.

5.c. response

El objeto response representa una respuesta HTTP, esto es, representa un objeto HttpServletResponse (es una instancia de la clase que implementa el interface javax.servlet.http.HttpServletResponse, que a su vez extiende el interface javax.servlet.ServletResponse).

Este objeto contiene varios métodos útiles para crear la respuesta enviada al navegador (desde una página JSP).

5.d. pageContext

El objeto pageContext representa el contexto de la página de una página JSP, esto es, representa un objeto PageContext (es una instancia de la clase javax.servlet.jsp.PageContext).

Está provisto para almacenamiento y acceso de todos los objetos pertenecientes al alcance page (más adelante) de una instancia de una página JSP.

El objeto pageContext tiene un alcance page, lo cual lo hace accesible sólo a la instancia de la página JSP a la que está asociado.

5.e. session

El objeto session representa una sesión HTTP, esto es, representa un objeto HttpSession para la petición (es una instancia de la clase javax.servlet.http.HttpSession).

La directiva session está definida en true por omisión, así que el objeto session es válido por omisión (si la directiva se define en false, entonces el uso de la palabra clave session resulta en un error fatal -durante la fase de traducción).

5.f. application

El objeto application representa el contexto del servlet para la aplicación Web, esto es, representa un objeto ServletContext (es una instancia de la clase javax.servlet.ServletContext).

El objeto application es accesible desde cualquier instancia de página JSP corriendo como parte de cualquier instancia de la aplicación dentro de una sola Máquina Virtual Java (JVM). Se utiliza para obtener información sobre el motor servlet y el ambiente servlet.

Al redireccionar o incluir peticiones, uno puede acceder al servlet requestDispatcher por utilizar el ServletContext, o uno puede utilizar la directiva forward para reenviar peticiones a otros servlets, y la directiva include para incluir la salida de otros servlets.

5.g. out

El objeto out es una instancia de la clase javax.servlet.jsp.JspWriter (que a su vez extiende la clase java.io.Writer).

Éste es un objeto que es utilizado para escribir al flujo de salida de una instancia de una página JSP. El objeto out se asocia con el objeto response para una petición en particular.

5.h. config

El objeto config representa la configuración servlet de una página JSP, esto es, representa un objeto ServletConfig (es una instancia de la clase que implementa el interface javax.servlet.ServletConfig).

De forma general, los contenedores servlet utilizan instancias ServletConfig para proveer acceso a los parámetros de inicialización de la instancia del servlet.

5.i. exception

Éste aplica sólo para páginas de error JSP. Éstas son las páginas que a las que se redirecciona el proceso cuando una excepción es arrojada en alguna página JSP. Deben tener definido en true el atributo isErrorPage de la directiva page.

El objeto implícito exception es una instancia de java.lang.Exception que representa la excepción sin atrapar que fue arrojada por otra página JSP y que resultó en la invocación de la página de error actual.

El objeto exception es accesible sólo desde la página de error JSP a la que se redireccionó el proceso al detectarse la excepción.


Ayuda

Para más información: