JSP

JavaServer Pages

• Características.
• Requisitos.
• Ventajas.
• Inconvenientes.
• Ejemplo de un programa sencillo.
• Referencias.

Características:

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.

Con JSP podemos crear aplicaciones web que se ejecuten en variados servidores web, de múltiples plataformas, ya que Java es en esencia un lenguaje multiplataforma. Las páginas JSP están compuestas de código HTML/XML mezclado con etiquetas especiales para programar scripts de servidor en sintaxis Java. Por tanto, las JSP podremos escribirlas con nuestro editor HTML/XML habitual.

El motor de las páginas JSP está basado en los servlets de Java, aunque resulta mucho más sencillo de aprender que los servlets.



Requisitos:

Lo primero que necesitamos para trabajar con JSP es un servidor web. Cuando hablamos de servidor, nos referimos tanto a una parte hardware como a una parte sofware. La parte hardware es normalmente un ordenador accesible desde Internet o desde una red corporativa, mientras que la parte sofware es un servidor HTTP ejecutándose en el hardware.
Además del servidor HTTP, es necesario un sofware que implemente un contenedor JSP. Muchos servidores incluyen este contenedor. En otros, será necesario incluir este contenedor. Actualmente, la mayoría de proveedores de servidores HTTP ofrecen API (Application Programming Interfaces) para incorporar la generación de contenido dinámico a la funcionalidad HTTP.

Una vez que tenemos el servidor instalado y configurado, añadiremos los ficheros JSP a la jerarquía normal de documentos del servidor, y se distinguirán del resto por su extensión, normalmente .jsp aunque no siempre es esta. Las clases Java, ya compiladas, que son referidas por nuestros documentos JSP necesitan ser instaladas en el path de las clases Java que utiliza el contenedor Java.

Aparte de conocer HTML, será necesario comprender y tener algo de experiencia en la programación en Java, así como el sistema de Servlets, que da una mejor idea del funcionamiento interno del motor JSP.

Además, necesita descargar e instalar Apache Tomcat (o Jetty), el contenedor de servlets usado en la referencia oficial de implementación de JSP.


Ventajas:

JSP ofrece varios beneficios como sistema de generación de contenido dinámico. Al estar basado en Java, presenta las ventajas que este lenguaje ofrece con respecto a la portabilidad entre plataformas y las derivadas de la orientación a objetos de este lenguaje.

Realización:
Las peticiones de páginas JSP son normalmente implementadas mediante servlets, de forma que el contenedor servlet, al que llamaremos contenedor JSP, maneja múltiples solicitudes a la vez, requiriendo menor overhead, y por tanto requiriendo menos recursos. Esto hace que JSP sea mucho más eficiente que otros modelos como los programas CGI .

Componentes reutilizables:
Esta característica deriva de la orientación a objetos de Java. JSP permite implementar contenido dinámico incluyendo código Java directamente en la página. Sin embargo, también ofrece una serie de etiquetas que le permiten actuar sobre objetos Java residentes en el servidor. Estos objetos se comportan como cajas negras a las que la página accede sin tener que conocer como funcionan internamente, y por tanto, liberando al creador de la página de la programación en Java. Estos objetos, además podrán ser reutilizados sin más que conocer su funcionalidad.

Separación de presentación e implementación:
Esta ventaja proviene directamente de la anterior. El hecho de que la implementación del programa puede ser llevada a cabo por los objetos Java, podemos separar lo que es la presentación en sí, en la página, y el código encargado de generar la información necesaria que aparecerá en la página.

División de labor:
La separación de presentación e implementación permitirá desligar las labores encargadas de desarrollar ambas. Así, alguien que no sepa nada de Java, podría encargarse de la parte de la página relacionada con la presentación, le bastaría conocer las propiedades que les ofrece un conjunto de objetos, y así accediendo a ellos conseguirían la información necesaria. Del mismo modo, un programador Java, siguiendo una serie de normas a la hora de crear los objetos, se encargaría de crear el código que generará la información dinámica, despreocupándose de los problemas de presentación de la página.


Inconvenientes:

Tener que aprender los lenguajes de Java y HTML para mezclarlos después en JSP.

Usadas de manera aislada, incluyendo la lógica de negocio, pueden ser crípticas y además son más difíciles de depurar.

Hay que tener en cuenta temas de concurrencia (hay que comprender el proceso mediante el que se convierten en servlets para evitar problemas potenciales).


Ejemplo de programa sencillo:

En primer lugar hay que decir que el contenedor JSP acepta las etiquetas HTML, de forma que la solicitud a un contenedor JSP local del siguiente fichero, al que habremos dado su correspondiente extensión (normalmente .jsp), sería perfectamente procesado, y por lo tanto sería un fichero JSP válido.

<HTML>
<BODY>
¡Hola, mundo!
</BODY>
</HTML>

Veamos ahora un ejemplo más interesante:

<HTML>
<BODY>
<% String visitante = request.getParameter("nombre");
if (visitante==null) visitante = "mundo"; %>
¡Hola, <%= visitante%>!
</BODY>
</HTML>

Sin entrar en detalles, este fichero JSP declara una variable Java String llamada visitante, y luego la intenta inicializar con un parámetro que busca en la solicitud HTTP. En caso de no encontrarlo, le da el valor mundo, y posteriormente inserta el valor de esta variable en la salida HTML de esta página.
Asumiremos que el URL para esta página JSP es http://localhost:8100/Hola.jsp y así, si un navegador buscara esta URL mediante una solicitud GET el contenedor JSP procesaría esta página y respondería con lo siguiente:

¡Hola, mundo!

En efecto, al no encontrar ningún parámetro en la solicitud, le daría a la variable visitante el valor mundo. Si, por el contrario, accediéramos a dicha página, mediante un GET a http://localhost:8100/Hola.jsp?nombre=Rafa, estaríamos pasando un valor al parámetro nombre de valor Rafa, y así la variable visitante valdría Rafa. Por lo tanto, la respuesta a esta petición sería:

¡Hola, Rafa!

En el código JSP del ejemplo anterior, hemos puesto en negrita el código puramente JSP. Como ya comentamos anteriormente, este código es ejecutado en el lado del servidor, generándose el contenido dinámico, de forma que el usuario al ver el código de la respuesta únicamente vería:

<HTML>
<BODY>
¡Hola, Rafa!
</BODY>
</HTML>

Con este simple ejemplo ya hemos visto la característica central de las páginas con contenido dinámico: dependiendo del valor de los parámetros en la solicitud, el resultado de la misma es distinto. Otro aspecto importante es el hecho de que el navegador no tiene constancia del código JSP de la página. Este código se ejecuta en el contenedor JSP, generando contenido HTML, y devolviéndolo completo al servidor HTTP, que lo devuelve al navegador sin dejar ninguna constancia de toda esta labor. Por último, es interesante reseñar que en este ejemplo el contenido dinámico se ha obtenido mediante la inclusión en la página de scripting, puro lenguaje Java.


Referencias:

http://desarrolloweb.com/articulos/831.php
http://en.wikipedia.org/wiki/JavaServer_Pages