Cos'è JSP? Introduzione a JavaServer Pages

JavaServer Pages (JSP) è una tecnologia standard Java che consente di scrivere pagine dinamiche basate sui dati per le applicazioni Web Java. JSP si basa sulla specifica Java Servlet. Le due tecnologie in genere funzionano insieme, specialmente nelle vecchie applicazioni web Java. Dal punto di vista della codifica, la differenza più ovvia tra loro è che con i servlet scrivi codice Java e poi incorpori markup lato client (come HTML) in quel codice, mentre con JSP inizi con lo script o markup lato client, quindi incorpori Tag JSP per connettere la tua pagina al backend Java.

JSP è anche strettamente correlato a JSF (JavaServer Faces), una specifica Java per la creazione di applicazioni web MVC (model-view-controller). JSP è una tecnologia relativamente più semplice e precedente di JSF, che è lo standard per i framework web Java come Eclipse Mojarra, MyFaces e PrimeFaces. Sebbene non sia raro vedere JSP utilizzato come frontend per vecchie applicazioni JSF, Facelets è la tecnologia di visualizzazione preferita per le moderne implementazioni JSF.

Sebbene JSP potrebbe non essere la tua prima scelta per la creazione di pagine Web dinamiche, è una tecnologia Web Java di base. Le pagine JSP sono relativamente veloci e facili da costruire e interagiscono perfettamente con i servlet Java in un contenitore di servlet come Tomcat. Incontrerai JSP nelle vecchie applicazioni web Java e di tanto in tanto potresti trovarlo utile per creare pagine web Java semplici e dinamiche. Come sviluppatore Java, dovresti almeno avere familiarità con JSP.

Questo articolo sarà una rapida introduzione a JavaServer Pages, inclusa la JSP Standard Tag Library (JSTL). Gli esempi mostrano come scrivere una semplice pagina HTML, incorporare tag JSP per connettersi a un servlet Java ed eseguire la pagina in un contenitore servlet.

Consultare gli articoli precedenti di questa serie per ulteriori informazioni sui servlet Java e sui JavaServer Faces.

JSP a Jakarta EE

Dopo il rilascio di Java EE 8, Oracle ha trasferito la gestione di Java Enterprise Edition (Java EE) a Eclipse Foundation. In futuro, la piattaforma aziendale Java è stata rinominata Jakarta EE. Insieme alle specifiche Java Servlet e JSF, JSP è una delle tecnologie Web Java incluse per il supporto e gli aggiornamenti continui in Jakarta EE.

Scrittura di pagine JSP

Una semplice pagina JSP (.jsp) è costituita da markup HTML incorporato con tag JSP. Quando il file viene elaborato sul server, l'HTML viene visualizzato come visualizzazione dell'applicazione, una pagina web. I tag JSP incorporati verranno utilizzati per chiamare codice e dati lato server. Il diagramma nella Figura 1 mostra l'interazione tra HTML, JSP e il server delle applicazioni Web.

Matthew Tyson

Il listato 1 mostra una semplice pagina JSP.

Listato 1. Una semplice pagina JSP

${2 * 2} should equal 4

Nel Listato 1, vedete un blocco di HTML che include un'espressione JSP , che è un'istruzione per il server Java scritta utilizzando Expression Language (EL). Nell'espressione " ${2 * 2}", " ${}" è la sintassi JSP per l'interpolazione del codice in HTML. Quando viene eseguito, JSP produrrà i risultati dell'esecuzione di qualsiasi cosa si trovi all'interno dell'espressione. In questo caso, l'uscita sarà il numero 4.

JSP nel contenitore servlet

Le pagine JSP devono essere distribuite all'interno di un contenitore servlet Java. Per distribuire un'applicazione web Java basata su JSP e servlet, impacchetterai i tuoi file .jsp, codice Java e metadati dell'applicazione in un file .war, che è un semplice file .zip con una struttura convenzionale per le applicazioni web.

Una volta caricato il JSP nel contenitore servlet, verrà compilato in un servlet. JSP e servlet Java condividono caratteristiche simili, inclusa la capacità di accedere e rispondere agli oggetti di richiesta. Apache Tomcat 9x è l'implementazione di riferimento per le specifiche Servlet 4.0 e JSP 2.3. (Si noti che gli aggiornamenti tra JSP 2.2 e 2.3 sono relativamente minori.)

Contenitore servlet vs server applicazioni

Nel mondo Java, un servlet container , noto anche come server web, è come una versione lite (birra) di un server delle applicazioni. Un contenitore servlet gestisce le interazioni di richiesta e risposta e consente a tali interazioni di interfacciarsi con un sottoinsieme di capacità aziendali Java per applicazioni web. Un server delle applicazioni Java include il contenitore servlet come parte dello stack aziendale Java completo, inclusi EJB, JPA, JMS e altro.

App di esempio per JSP

Useremo un'applicazione di esempio in Tomcat per iniziare con JavaServer Pages. Se non hai già Tomcat installato, vai alla pagina di download di Tomcat e seleziona l'installazione di Tomcat per il tuo sistema operativo. Al momento della stesura di questo documento, Tomcat 9 è la versione corrente, compatibile con Servlet 4.0 e JSP 2.3.

Puoi installare Tomcat come servizio Windows oppure eseguirlo dalla riga di comando con /bin/catalina.sh starto /bin/catalina.bat. In ogni caso, avvia Tomcat, quindi vai a localhost:8080per visualizzare la pagina di benvenuto di Tomcat mostrata nella Figura 2.

Matthew Tyson

Oggetti impliciti in Tomcat

Nella pagina di benvenuto di Tomcat, fare clic sul collegamento Esempi , quindi fare clic su Esempi JSP .

Successivamente, apri l' applicazione Web Implicit Objects Execute . La Figura 3 mostra l'output per questa applicazione. Prenditi un minuto per studiare questo output.

Matthew Tyson

Richiedi parametri

Gli oggetti impliciti sono oggetti incorporati accessibili tramite una pagina JSP. In qualità di sviluppatore di pagine Web, utilizzerai questi oggetti per creare l'accesso a cose come i parametri di richiesta , che sono i dati inviati dal browser quando si invia una richiesta HTTP. Considera l'URL del browser per gli oggetti impliciti:

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

Il parametro è ?foo=bar, e puoi vederlo riflesso nell'output sulla pagina web, dove la tabella mostra "EL Expression" e il valore è "bar". Per testarlo, cambia l'URL in //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , premi Invio e vedrai la modifica riflessa nell'output.

Questo esempio è un'introduzione molto semplice all'utilizzo dei tag JSP per accedere ai parametri di richiesta lato server. In questo caso, la pagina JSP utilizza l'oggetto incorporato (implicito) chiamato paramper accedere ai parametri di richiesta dell'applicazione web. L' paramoggetto è disponibile all'interno della sintassi dell'espressione JSP che hai visto nel Listato 1.

In quell'esempio, abbiamo usato un'espressione per fare un po 'di matematica:, ${2 * 2}quale output 4.

In questo esempio, l'espressione è usata per accedere a un oggetto e un campo su quell'oggetto: ${param.foo}.

JSP in un'applicazione web

Nella pagina Oggetti impliciti, fare clic sulla freccia indietro, seguita dal collegamento Origine . Questo ti porterà al codice JSP per l'app web Implicit Objects, mostrato nel Listato 2.

Listato 2. Codice JSP per l'applicazione web Implicit Objects

     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.

Dovresti vedere i tuoi aggiornamenti riflessi nell'output.