¿Qué es JSP? Introducción a las páginas de JavaServer

JavaServer Pages (JSP) es una tecnología estándar de Java que le permite escribir páginas dinámicas basadas en datos para sus aplicaciones web Java. JSP se basa en la especificación Java Servlet. Las dos tecnologías suelen funcionar juntas, especialmente en aplicaciones web Java más antiguas. Desde una perspectiva de codificación, la diferencia más obvia entre ellos es que con los servlets escribes código Java y luego incrusta el marcado del lado del cliente (como HTML) en ese código, mientras que con JSP comienzas con el script o marcado del lado del cliente, luego incrusta Etiquetas JSP para conectar su página al backend de Java.

JSP también está estrechamente relacionado con JSF (JavaServer Faces), una especificación de Java para crear aplicaciones web MVC (modelo-vista-controlador). JSP es una tecnología relativamente más simple y antigua que JSF, que es el estándar para marcos web Java como Eclipse Mojarra, MyFaces y PrimeFaces. Si bien no es raro ver que JSP se utiliza como interfaz para aplicaciones JSF más antiguas, Facelets es la tecnología de vista preferida para las implementaciones JSF modernas.

Si bien JSP puede no ser su primera opción para crear páginas web dinámicas, es una tecnología web Java central. Las páginas JSP son relativamente rápidas y fáciles de construir e interactúan sin problemas con los servlets de Java en un contenedor de servlets como Tomcat. Encontrará JSP en aplicaciones web Java más antiguas y, de vez en cuando, puede resultarle útil para crear páginas web Java simples y dinámicas. Como desarrollador de Java, al menos debería estar familiarizado con JSP.

Este artículo será una introducción rápida a JavaServer Pages, incluida la biblioteca de etiquetas estándar JSP (JSTL). Los ejemplos le muestran cómo escribir una página HTML simple, incrustar etiquetas JSP para conectarse a un servlet Java y ejecutar la página en un contenedor de servlets.

Consulte los artículos anteriores de esta serie para obtener más información sobre los servlets Java y JavaServer Faces.

JSP en Yakarta EE

Tras el lanzamiento de Java EE 8, Oracle trasladó la administración de Java Enterprise Edition (Java EE) a Eclipse Foundation. En el futuro, la plataforma empresarial de Java ha sido rebautizada como Jakarta EE. Junto con las especificaciones Java Servlet y JSF, JSP es una de las tecnologías web Java incluidas para el soporte continuo y las actualizaciones en Jakarta EE.

Escribir páginas JSP

Una página JSP simple (.jsp) consta de marcado HTML incrustado con etiquetas JSP. Cuando el archivo se procesa en el servidor, el HTML se representa como la vista de la aplicación, una página web. Las etiquetas JSP integradas se utilizarán para llamar a código y datos del lado del servidor. El diagrama de la Figura 1 muestra la interacción entre HTML, JSP y el servidor de aplicaciones web.

Matthew Tyson

El Listado 1 muestra una página JSP simple.

Listado 1. Una página JSP simple

${2 * 2} should equal 4

En el Listado 1, verá un bloque de HTML que incluye una expresión JSP , que es una instrucción para el servidor Java escrita con Expression Language (EL). En la expresión " ${2 * 2}", " ${}" es la sintaxis JSP para interpolar código en HTML. Cuando se ejecuta, JSP generará los resultados de la ejecución de lo que esté dentro de la expresión. En este caso, la salida será el número 4.

JSP en el contenedor de servlets

Las páginas JSP deben desplegarse dentro de un contenedor de servlets Java. Para implementar una aplicación web Java basada en JSP y servlets, empaquetará sus archivos .jsp, código Java y metadatos de la aplicación en un archivo .war, que es un archivo .zip simple con una estructura convencional para aplicaciones web.

Una vez que haya cargado el JSP en su contenedor de servlets, se compilará en un servlet. Las JSP y los servlets Java comparten características similares, incluida la capacidad de acceder y responder a los objetos de solicitud. Apache Tomcat 9x es la implementación de referencia para las especificaciones de Servlet 4.0 y JSP 2.3. (Tenga en cuenta que las actualizaciones entre JSP 2.2 y 2.3 son relativamente menores).

Contenedor de servlets frente a servidor de aplicaciones

En el mundo de Java, un contenedor de servlets , también conocido como servidor web, es como una versión lite (cerveza) de un servidor de aplicaciones. Un contenedor de servlets maneja interacciones de solicitud y respuesta y permite que esas interacciones interactúen con un subconjunto de capacidades empresariales de Java para aplicaciones web. Un servidor de aplicaciones Java incluye el contenedor de servlets como parte de la pila empresarial Java completa, incluidos EJB, JPA, JMS y más.

Aplicación de ejemplo para JSP

Usaremos una aplicación de ejemplo en Tomcat para comenzar con JavaServer Pages. Si aún no tiene Tomcat instalado, navegue hasta la página de descarga de Tomcat y seleccione la instalación de Tomcat para su sistema operativo. En el momento de escribir estas líneas, Tomcat 9 es la versión actual, compatible con Servlet 4.0 y JSP 2.3.

Puede instalar Tomcat como un servicio de Windows o ejecutarlo desde la línea de comandos con /bin/catalina.sh starto /bin/catalina.bat. De cualquier manera, inicie Tomcat, luego vaya a localhost:8080para ver la página de bienvenida de Tomcat que se muestra en la Figura 2.

Matthew Tyson

Objetos implícitos en Tomcat

En la página de bienvenida de Tomcat, haga clic en el enlace Ejemplos y luego haga clic en Ejemplos JSP .

A continuación, abra la aplicación web Implicit Objects Execute . La Figura 3 muestra el resultado de esta aplicación. Tómese un minuto para estudiar este resultado.

Matthew Tyson

Solicitar parámetros

Los objetos implícitos son objetos integrados accesibles a través de una página JSP. Como desarrollador de páginas web, utilizará estos objetos para crear acceso a cosas como parámetros de solicitud , que son los datos que se envían desde el navegador al emitir una solicitud HTTP. Considere la URL del navegador para objetos implícitos:

 //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar 

El parámetro es ?foo=bar, y puede verlo reflejado en la salida de la página web, donde la tabla muestra "Expresión EL" y el valor es "barra". Para probar esto, cambie la URL a //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , presione Enter y verá el cambio reflejado en la salida.

Este ejemplo es una introducción muy simple al uso de etiquetas JSP para acceder a los parámetros de solicitud del lado del servidor. En este caso, la página JSP utiliza el objeto incorporado (implícito) llamado parampara acceder a los parámetros de solicitud de la aplicación web. El paramobjeto está disponible dentro de la sintaxis de expresión JSP que vio en el Listado 1.

En ese ejemplo, usamos una expresión para hacer algunas matemáticas:, ${2 * 2}cuyo resultado 4.

En este ejemplo, la expresión se utiliza para acceder a un objeto y un campo en ese objeto: ${param.foo}.

JSP en una aplicación web

En la página Objetos implícitos, haga clic en la flecha hacia atrás, seguida del enlace Fuente . Esto lo llevará al código JSP para la aplicación web Objetos implícitos, que se muestra en el Listado 2.

Listado 2. Código JSP para la aplicación web Objetos implícitos

     JSP 2.0 Expression Language - Implicit Objects   
    
This example illustrates some of the implicit objects available in the Expression Language. The following implicit objects are available (not all illustrated here):
  • pageContext - the PageContext object
  • pageScope - a Map that maps page-scoped attribute names to their values
  • requestScope - a Map that maps request-scoped attribute names to their values
  • sessionScope - a Map that maps session-scoped attribute names to their values
  • applicationScope - a Map that maps application-scoped attribute names to their values
  • param - a Map that maps parameter names to a single String parameter value
  • paramValues - a Map that maps parameter names to a String[] of all values for that parameter
  • header - a Map that maps header names to a single String header value
  • headerValues - a Map that maps header names to a String[] of all values for that header
  • initParam - a Map that maps context initialization parameter names to their String parameter value
  • cookie - a Map that maps cookie names to a single Cookie object.
Change Parameter foo =

EL Expression Result
\${param.foo} ${fn:escapeXml(param["foo"])}
\${param["foo"]} ${fn:escapeXml(param["foo"])}
\${header["host"]} ${fn:escapeXml(header["host"])}
\${header["accept"]} ${fn:escapeXml(header["accept"])}
\${header["user-agent"]} ${fn:escapeXml(header["user-agent"])}

JSP functions

If you're familiar with HTML, then Listing 2 should look pretty familiar. You have the expected HTML elements, followed by the ${ } JSP expression syntax introduced in Listing 1. But notice the value for param.foo: ${fn:escapeXml(param["foo"])} . The "fn:escapeXML()" is a JSP function.

A JSP function encapsulates a chunk of reusable functionality. In this case, the functionality is to escape XML. JSP offers a variety of functions, and you can also create functions yourself. To use a function, you import its library into your JSP page, then call the function.

In Listing 2, the escapeXML function is included with the line:

The syntax is pretty clear: it imports the required functions and assigns them a prefix (in this case "fn") that can be used in all following expressions.

The JSP Standard Tag Library (JSTL)

The import line in Listing 2 calls taglib, which is short for tag library, or (in this case) JSP Standard Tag Library (JSTL). Tag libraries define reusable bits of functionality for JSP. JSTL is the standard tag library, containing a collection of taglibs that ship with every servlet and JSP implementation, including Tomcat.

The "functions" library is just one of the taglibs included with JSTL. Another common taglib is the core library, which you import by calling:

Like "fn", the "c" designation is conventional, and you will see it across most JSP pages.

Securing JSP pages

An example tag from the core library is


    

which outputs the tag with the XML already escaped. This function is important because outputting content directly to a web page via ${variable} opens the door to script injection attacks. This simple function is used to protect web pages from such attacks.

The core library also includes various tags for iteration and flow control (like IF/ELSE handling).

JSTL tag classifications

There are five sets of tags included in JSTL, each designed for a specific area of web application functionality:

  • JSTL core: Dealing with logic and execution flow; conventional tag: "c"
  • JSTL formatting: Dealing with formatting (like dates) and internationalization; conventional tag: "fmt".
  • JSTL SQL: Dealing with querying SQL databases (this is usually discouraged in the view layer); conventional tag: "sql".
  • JSTL XML: Dealing with working with XML documents; conventional tag: "x".
  • JSTL functions: Dealing primarily with String manipulations; conventional tag: "fn".

Calling taglibs in JSP pages

Now that you've got a handle on JSP basics, let's make a change to the example application. To start, locate the Implicit Object app in your Tomcat installation. The path is: apache-tomcat-8.5.33/webapps/examples/jsp/jsp2/el.

Open this file and locate the functions include:

just below this line, add a new line:

Hit Return and add another new line:

Now reload the page at //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar.

Debería ver sus actualizaciones reflejadas en el resultado.