Wat is JSP? Inleiding tot JavaServer Pages

JavaServer Pages (JSP) is een Java-standaardtechnologie waarmee u dynamische, gegevensgestuurde pagina's voor uw Java-webtoepassingen kunt schrijven. JSP is gebouwd bovenop de Java Servlet-specificatie. De twee technologieën werken doorgaans samen, vooral in oudere Java-webapplicaties. Vanuit een coderingsperspectief is het meest voor de hand liggende verschil tussen hen dat je met servlets Java-code schrijft en vervolgens client-side markup (zoals HTML) in die code insluit, terwijl je met JSP begint met het client-side script of markup en vervolgens insluit JSP-tags om uw pagina te verbinden met de Java-backend.

JSP is ook nauw verwant aan JSF (JavaServer Faces), een Java-specificatie voor het bouwen van MVC-webapplicaties (model-view-controller). JSP is een relatief eenvoudigere en oudere technologie dan JSF, de standaard voor Java-webframeworks zoals Eclipse Mojarra, MyFaces en PrimeFaces. Hoewel het niet ongebruikelijk is dat JSP wordt gebruikt als frontend voor oudere JSF-toepassingen, is Facelets de voorkeursweergavetechnologie voor moderne JSF-implementaties.

Hoewel JSP misschien niet uw eerste keuze is voor het bouwen van dynamische webpagina's, is het een kern-Java-webtechnologie. JSP-pagina's zijn relatief snel en eenvoudig te bouwen, en ze werken naadloos samen met Java-servlets in een servlet-container zoals Tomcat. U zult JSP tegenkomen in oudere Java-webapplicaties, en van tijd tot tijd kan het handig zijn voor het bouwen van eenvoudige, dynamische Java-webpagina's. Als Java-ontwikkelaar moet u in ieder geval bekend zijn met JSP.

Dit artikel is een korte inleiding tot JavaServer Pages, inclusief de JSP Standard Tag Library (JSTL). Voorbeelden laten zien hoe u een eenvoudige HTML-pagina schrijft, JSP-tags insluit om verbinding te maken met een Java-servlet en de pagina uitvoert in een servlet-container.

Zie eerdere artikelen in deze serie voor meer informatie over Java-servlets en JavaServer Faces.

JSP in Jakarta EE

Na de release van Java EE 8 heeft Oracle het beheer van Java Enterprise Edition (Java EE) overgedragen aan de Eclipse Foundation. In de toekomst is het Java-bedrijfsplatform omgedoopt tot Jakarta EE. Samen met de Java Servlet- en JSF-specificaties is JSP een van de Java-webtechnologieën die zijn opgenomen voor voortdurende ondersteuning en upgrades in Jakarta EE.

JSP-pagina's schrijven

Een eenvoudige JSP-pagina (.jsp) bestaat uit HTML-markeringen die zijn ingesloten met JSP-tags. Wanneer het bestand op de server wordt verwerkt, wordt de HTML weergegeven als de toepassingsweergave, een webpagina. De ingebedde JSP-tags worden gebruikt om server-side code en data op te roepen. Het diagram in figuur 1 toont de interactie tussen HTML, JSP en de webtoepassingsserver.

Matthew Tyson

Listing 1 toont een eenvoudige JSP-pagina.

Listing 1. Een eenvoudige JSP-pagina

${2 * 2} should equal 4

In Listing 1 zie je een HTML-blok met een JSP-expressie , een instructie voor de Java-server die is geschreven met Expression Language (EL). In de uitdrukking " ${2 * 2}" is " ${}" de JSP-syntaxis voor het interpoleren van code in HTML. Wanneer uitgevoerd, zal de JSP de resultaten uitvoeren van het uitvoeren van alles wat zich in de uitdrukking bevindt. In dit geval is de uitvoer het nummer 4.

JSP in de servlet-container

JSP-pagina's moeten worden geïmplementeerd in een Java-servletcontainer. Om een ​​Java-webtoepassing op basis van JSP en servlets te implementeren, verpakt u uw .jsp-bestanden, Java-code en toepassingsmetagegevens in een .war-bestand, een eenvoudig .zip-bestand met een conventionele structuur voor webtoepassingen.

Nadat u de JSP in uw servlet-container heeft geladen, wordt deze in een servlet gecompileerd. JSP's en Java-servlets hebben vergelijkbare kenmerken, waaronder de mogelijkheid om verzoekobjecten te openen en erop te reageren. Apache Tomcat 9x is de referentie-implementatie voor de Servlet 4.0- en JSP 2.3-specificaties. (Merk op dat updates tussen JSP 2.2 en 2.3 relatief klein zijn.)

Servletcontainer versus applicatieserver

In de Java-wereld is een servlet-container , ook wel webserver genoemd, als een lite (bier) versie van een applicatieserver. Een servletcontainer verwerkt verzoek-en-antwoord-interacties en staat deze interacties toe om te communiceren met een subset van Java-enterprise-mogelijkheden voor webtoepassingen. Een Java-applicatieserver bevat de servletcontainer als onderdeel van de volledige Java-enterprise-stack, inclusief EJB, JPA, JMS en meer.

Voorbeeld-app voor JSP

We gebruiken een voorbeeldtoepassing in Tomcat om u op weg te helpen met JavaServer Pages. Als je Tomcat nog niet hebt geïnstalleerd, blader dan naar de Tomcat-downloadpagina en selecteer de Tomcat-installatie voor je besturingssysteem. Op het moment van schrijven is Tomcat 9 de huidige release, compatibel met Servlet 4.0 en JSP 2.3.

U kunt Tomcat installeren als een Windows-service of het uitvoeren vanaf de opdrachtregel met /bin/catalina.sh startof /bin/catalina.bat. Start in beide gevallen Tomcat en ga naar localhost:8080om de Tomcat-welkomstpagina te zien die wordt weergegeven in afbeelding 2.

Matthew Tyson

Impliciete objecten in Tomcat

Klik op de welkomstpagina van Tomcat op de koppeling Voorbeelden en vervolgens op JSP-voorbeelden .

Open vervolgens de webtoepassing Implicit Objects Execute . Figuur 3 toont de output voor deze toepassing. Neem even de tijd om deze output te bestuderen.

Matthew Tyson

Verzoek parameters

Impliciete objecten zijn ingebouwde objecten die toegankelijk zijn via een JSP-pagina. Als ontwikkelaar van webpagina's gebruikt u deze objecten om toegang te krijgen tot zaken als verzoekparameters . Dit zijn de gegevens die door de browser worden verzonden wanneer een HTTP-verzoek wordt verzonden. Overweeg de browser-URL voor impliciete objecten:

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

De parameter is ?foo=bar, en je kunt het zien in de uitvoer op de webpagina, waar de tabel "EL Expression" toont en de waarde "bar". Om dit uit te testen, wijzigt u de URL in //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , drukt u op Enter en ziet u de wijziging weerspiegeld in de uitvoer.

Dit voorbeeld is een zeer eenvoudige inleiding tot het gebruik van JSP-tags om toegang te krijgen tot verzoekparameters aan de serverzijde. In dit geval gebruikt de JSP-pagina het ingebouwde (impliciete) object dat wordt aangeroepen paramom toegang te krijgen tot de verzoekparameters van de webtoepassing. Het paramobject is beschikbaar binnen de JSP-expressiesyntaxis die u in listing 1 hebt gezien.

In dat voorbeeld hebben we een uitdrukking gebruikt om wat te rekenen:, ${2 * 2}welke uitvoer 4.

In dit voorbeeld wordt de uitdrukking gebruikt om een object en een veld dat object: ${param.foo}.

JSP in een webapplicatie

Klik op de pagina Impliciete objecten op de pijl-terug, gevolgd door de koppeling Bron . Dit leidt u naar de JSP-code voor de Implicit Objects-webapp, die wordt weergegeven in Listing 2.

Listing 2. JSP-code voor de Implicit Objects-webapp

     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.

U zou uw updates in de uitvoer moeten zien.