Estructura de las Páginas JSP
- Panorama General

Esta sección presenta un panorama global sobre las páginas JSP, sus antecedentes, así como una breve descripción de su funcionamiento.


1. Sobre los Servidores y los Contenedores

Antes de empezar, vale la pena explicar brevemente un par de conceptos: El de los servidores y contenedores, ya que todo el tema de los servlets y JSP gira alrededor de éstos.

Un Servidor Web es un software que acepta peticiones para acceder páginas Web (páginas HTML). Una vez obtenida la página, el servidor la envía de regreso al navegador del usuario que la requirió.

Un Contenedor es un software que contiene Archivos JSP y Servlets, convierte archivos JSP en servlets, compila servlets, y corre servlets creando páginas Web. Todo esto ocurre cuando el servidor Web recibe una petición para acceder un archivo con extensión .jsp:

2. Visión General de los CGI

CGI es acrónimo de Common Gateway Interface. CGI es un protocolo simple que puede ser utilizado para comunicar formas Web con un programa. Un script CGI puede ser escrito en cualquier lenguaje que pueda leer StdIn, escribir a StdOut, y leer Variables de Entorno -esto es, prácticamente cualquier lenguaje de programación (C, Perl) resulta adecuado (aunque tradicionalmente Perl ha sido de los más populares). Básicamente, es el método por el cual un servidor Web puede obtener datos de (o enviar datos a) Bases de Datos, documentos y otros programas, y presentar -vía Web- esos datos a los usuarios.

3. Visión General de los Servlets

Los servlets son el equivalente de la programación CGI, pero con tecnología Java. Básicamente son programas que corren en un servidor Web y se usan para construir páginas Web. Sin embargo, los servlets Java son más eficientes, más fáciles de usar, más potentes, más portables y más económicos que el CGI:

Los servlets permiten un desarrollo relativamente rápido de páginas Web, lo cual resulta indispensable por varias razones:

Los servlets son módulos del lado del servidor, 100% Java puro (lo que los hace independientes de la plataforma sobre la que corren), que encajan de forma transparente en la estructura de un servidor Web con una sobrecarga, mantenimiento y soporte mínimo. A diferencia de otros lenguajes script, los servlets no involucran consideraciones o modificaciones específicas de una plataforma; son componentes de aplicaciones Java que se descargan, según se requieran, a la parte del sistema que los requiere.

En resumen, se puede decir que un servlet es un programa escrito en lenguaje Java que corre en el servidor (a diferencia de un applet que corre en el navegador).

4. Visión General de las Páginas JSP

JSP es acrónimo de Java ServerPages (Páginas Servidoras Java).

La tecnología JSP provee una manera rápida y simplificada de crear páginas Web que desplieguen contenido generado de forma dinámica, ya que acelera el desarrollo por medio de componentes reutilizables y etiquetas (en lugar de apoyarse en el uso de scripts dentro de la página misma). La especificación JSP (desarrollada a través de una iniciativa por parte de la industria y lidereada por Sun Microsystems), está diseñada para ser un estándard abierto, soportando numerosos servidores, navegadores y herramientas, que define la interacción entre el servidor y la página JSP, y que describe el formato y sintaxis de la página.

Básicamente es una tecnología que permite mezclar HTML estático con HTML generado dinámicamente.

Aunque hay otras soluciones para el desarrollo rápido de aplicaciones Web (tales como ASP, PHP, Perl, ColdFusion, y otras), JSP se diferencia de éstas (entre otras cosas) por lo siguiente:

En comparación con otras tecnologías, la tecnología JSP ofrece las siguientes ventajas:

En resumen, las páginas JSP, junto con los Servlets Java y los JavaBeans, permiten desarrollar aplicaciones Web eficientes, escalables y seguras, en poco tiempo, y se usan para entregar al usuario contenido dinámico, utilizando presentación, datos y lógica desde el lado del servidor.

5. Visión Técnica de las Páginas JSP

La tecnología JSP forma parte de la tecnología Java, y por ello representa un componente clave dentro de una arquitectura altamente escalable para aplicaciones basadas en Web. Esta tecnología en realidad es una extensión de la tecnología Servlet Java.

Dado que la especificación JSP representa un espectro ámplio de aportaciones por parte de la industria, las páginas JSP no están restringidas a ninguna plataforma específica o servidor Web específico.

Una página JSP combina:

para así producir finalmente una página Web dinámica.

De manera adicional, la lógica de la aplicación puede residir en recursos localizados en el servidor (tal como la arquitectura de componentes JavaBean), y que una aplicación puede acceder por medio de esas etiquetas. De esta forma, las páginas JSP separan la lógica de la página de su diseño y presentación.

Una página JSP tiene la extensión .jsp, lo cual le indica al servidor Web que será el motor JSP (un componente del contenedor) el que procesará elementos en esa página. Al momento en que las páginas JSP se convierten en servlets, el motor JSP interpreta las etiquetas y genera el contenido requerido para realizar procesamiento en el servidor (ya sea por llamar componentes JavaBean o componentes Enterprise JavaBeans, o accediendo a una base de datos con el API JDBC, o por incluir un archivo externo). Finalmente envía los resultados de regreso en forma de una página HTML (o XML) al navegador. Como puede apreciarse entonces, la lógica que genera el contenido está encapsulada en etiquetas y beans procesados en el servidor.

Aunque todas las implementaciones JSP soportan un lenguaje de script basado en el lenguaje de programación Java (lo cual provee escalabilidad inherente y soporte para operaciones complejas), para la nueva especificación (2.0) también se ha considerado como objetivo primordial el "que no haya la necesidad de aprender Java", esto es, los diseñadores y desarrolladores de páginas Web podrán usar la tecnología JSP sin la necesidad de aprender a escribir scriplets Java. De hecho, los scriplets ya no son requeridos para generar contenido dinámico (aunque se siguen apoyando dentro de la especificación para proveer compatibilidad con versiones anteriores).

6. Procesamiento de una Página JSP

Tal como un servidor Web requiere de un contenedor de servlets para proveer un interface a los servlets, también requiere de un contenedor JSP para procesar páginas JSP.

El contenedor JSP es responsable de interceptar peticiones de páginas JSP. Para procesar todos los elementos en la página, el contenedor primero convierte la página JSP en un servlet, conocido como clase de implementación de página JSP (JSP page implementation class). La conversión es bastante directa. Todas las plantillas de texto (el código HTML estático) se convierten en sentencias out.write(), y todos los elementos JSP se convierten en código Java, el cual implementa el comportamiento dinámico correspondiente. Finalmente el contenedor compila la clase servlet.

El convertir la JSP en un servlet y compilar el servlet, forman lo que se llama la fase de traducción. El contenedor JSP inicia la fase de traducción para una página automáticamente al recibir la primera petición requiriendo esa página. Dado que la fase de traducción toma un poco de tiempo, el primer usuario en requerir la página observa un pequeño retraso en recibirla. La fase de traducción también puede ser iniciada explícitamente (lo que se conoce como precompilación de una página JSP). El precompilar una JSP es una forma de evitarle ese retraso al primer usuario de la página.

El contenedor JSP también es responsable de llamar la clase de implementación de página JSP (esto es, el servlet generado) para procesar cada petición y generar la respuesta. Esto se conoce como fase de procesamiento de la petición.

Estas dos fases se ilustran a continuación:

Cliente
 
Servidor (con Contenedor JSP)
1.- Genera petición de la página Hola.jsp  
 
  Fase de Traducción

  2.- Inicia lectura de la página Hola.jsp
  3.- Genera el servlet Hola.java
  4.- El servlet se compila, generando la clase Hola.class
 
  Fase de Procesamiento de la Petición

  5.- Se ejecuta la clase Hola.class
6.- Recibe el HTML generado  


Mientras la JSP permanezca sin cambio, cualquier petición subsecuente va directo a la fase de procesamiento de la petición (el contenedor simplemente ejecuta el archivo .class). Si se modifica la JSP, entonces se ejecuta de nuevo la fase de traducción antes de entrar a la fase de procesamiento de la petición.

El contenedor JSP generalmente se implementa como un servlet configurado para manejar todas las peticiones de páginas JSP. De hecho, estos dos contenedores (el contenedor servlet y el contenedor JSP) generalmente se combinan en un solo paquete bajo el nombre de Servidor Web.

Dado que las páginas JSP se traducen en servlets, teóricamente uno podría escribir servlets para soportar aplicaciones Web. Sin embargo, la tecnología JSP fue diseñada para simplificar el proceso de crear páginas por separar la presentación del contenido. En muchas aplicaciones, la respuesta enviada al cliente es una combinación de plantilla de datos y datos generados de forma dinámica. En estas situaciones, es mucho más fácil trabajar con páginas JSP que hacer todo en servlets.

Lo anterior se puede apreciar al comparar ambos códigos, el de una JSP y el de un servlet (ambos hacen exactamente lo mismo):

Código JSP:
<html>
<body bgcolor="#ffeada">

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

</body>
</html>
Código Servlet:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;

public class Testservlet extends HttpServlet
{
  public void doGet( HttpServletRequest request,
      HttpServletResponse response )
    throws ServletException, IOException
  {
    response.setContentType( "text/html" );

    PrintWriter out = response.getWriter();

    out.write( "<html>\n" );
    out.write( "<body bgcolor="#ffeada">\n\n" );

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

    out.write( "</body>\n" );
    out.write( "</html>\n" );
  }
}

En resumen, se puede concluir que en cierta forma, una página JSP es sólo otra forma de escribir un servlet sin tener que ser un experto en programación Java. Exceptuando la fase de traducción, una página JSP se maneja como un servlet común: es cargado una sola vez y llamado repetidamente hasta que se apague el servidor. En virtud de terminar convertida en un servlet, una página JSP contiene todas las ventajas de un servlet: Independencia de plataforma, integración, eficiencia, y escalabilidad entre otras.


Ayuda

Para más información: