Vad är JSP? Introduktion till JavaServer-sidor

JavaServer Pages (JSP) är en Java-standardteknik som gör att du kan skriva dynamiska, datadrivna sidor för dina Java-webbapplikationer. JSP är byggt ovanpå Java Servlet-specifikationen. De två teknikerna fungerar vanligtvis tillsammans, särskilt i äldre Java-webbapplikationer. Ur ett kodperspektiv är den mest uppenbara skillnaden mellan dem att med servlets skriver du Java-kod och sedan bäddar in klientsidesmarkering (som HTML) i den koden, medan du med JSP börjar med klientsidesskriptet eller markeringen och sedan bäddar in JSP-taggar för att ansluta din sida till Java-backend.

JSP är också nära besläktat med JSF (JavaServer Faces), en Java-specifikation för att bygga MVC-webbapplikationer (model-view-controller). JSP är en relativt enklare och äldre teknik än JSF, vilket är standarden för Java-webbramar som Eclipse Mojarra, MyFaces och PrimeFaces. Även om det inte är ovanligt att se JSP som frontend för äldre JSF-applikationer, är Facelets den bästa visningstekniken för moderna JSF-implementeringar.

Även om JSP kanske inte är ditt första val för att bygga dynamiska webbsidor är det en grundläggande Java-webbteknik. JSP-sidor är relativt snabba och enkla att bygga, och de interagerar sömlöst med Java-servlets i en servletbehållare som Tomcat. Du kommer att stöta på JSP i äldre Java-webbapplikationer, och då och då kan du hitta det användbart för att bygga enkla, dynamiska Java-webbsidor. Som Java-utvecklare bör du åtminstone känna till JSP.

Den här artikeln kommer att vara en snabb introduktion till JavaServer-sidor, inklusive JSP Standard Tag Library (JSTL). Exempel visar hur du skriver en enkel HTML-sida, bäddar in JSP-taggar för att ansluta till en Java-servlet och kör sidan i en servlet-behållare.

Se tidigare artiklar i denna serie för att lära dig mer om Java-servlets och JavaServer Faces.

JSP i Jakarta EE

Efter lanseringen av Java EE 8 flyttade Oracle förvaltningen av Java Enterprise Edition (Java EE) till Eclipse Foundation. Framöver har Java-företagsplattformen ombetygts till Jakarta EE. Tillsammans med Java Servlet och JSF-specifikationerna är JSP en av de Java-webbtekniker som ingår för pågående support och uppgraderingar i Jakarta EE.

Skriva JSP-sidor

En enkel JSP-sida (.jsp) består av HTML-markering inbäddad med JSP-taggar. När filen bearbetas på servern återges HTML som applikationsvy, en webbsida. De inbäddade JSP-taggarna används för att anropa koden och data på serversidan. Diagrammet i figur 1 visar samspelet mellan HTML, JSP och webbapplikationsservern.

Matthew Tyson

Listning 1 visar en enkel JSP-sida.

Listning 1. En enkel JSP-sida

${2 * 2} should equal 4

I Listing 1 ser du ett HTML-block som innehåller ett JSP-uttryck , vilket är en instruktion till Java-servern skriven med Expression Language (EL). I uttrycket " ${2 * 2}" är " ${}" JSP-syntax för interpolering av kod i HTML. När den körs kommer JSP att mata ut resultaten av att köra vad som helst i uttrycket. I det här fallet blir utgången siffran 4.

JSP i servletbehållaren

JSP-sidor måste distribueras i en Java-servletbehållare. För att distribuera en Java-webbapplikation baserad på JSP och servlets paketerar du dina .jsp-filer, Java-kod och applikationsmetadata i en .war-fil, som är en enkel .zip-fil med en konventionell struktur för webbapplikationer.

När du har laddat JSP i din servletbehållare kommer den att sammanställas till en servlet. JSP och Java-servlets delar liknande egenskaper, inklusive möjligheten att komma åt och svara på förfrågningsobjekt. Apache Tomcat 9x är referensimplementeringen för specifikationerna Servlet 4.0 och JSP 2.3. (Observera att uppdateringar mellan JSP 2.2 och 2.3 är relativt små.)

Servlet behållare kontra applikationsserver

I Java-världen är en servletbehållare , även känd som en webbserver, som en lite (öl) version av en applikationsserver. En servlet-behållare hanterar begäran-och-svar-interaktioner och gör att dessa interaktioner kan gränssnitt med en delmängd av Java-företagets funktioner för webbapplikationer. En Java-applikationsserver inkluderar servletbehållaren som en del av hela Java-företagsstacken, inklusive EJB, JPA, JMS och mer.

Exempel på app för JSP

Vi använder ett exempel på en applikation i Tomcat för att komma igång med JavaServer Pages. Om du inte redan har Tomcat installerat, bläddra över till Tomcat-hämtningssidan och välj Tomcat-installationen för ditt operativsystem. När detta skrivs är Tomcat 9 den aktuella versionen, kompatibel med Servlet 4.0 och JSP 2.3.

Du kan installera Tomcat som en Windows-tjänst eller köra den från kommandoraden med /bin/catalina.sh starteller /bin/catalina.bat. Hur som helst, starta upp Tomcat och gå sedan till för localhost:8080att se Tomcat välkomstsida som visas i figur 2.

Matthew Tyson

Implicita objekt i Tomcat

Klicka på länken Exempel på Tomcat välkomstsida och klicka sedan på JSP-exempel .

Därefter öppnar Implicit Objects Utför webbapplikation. Figur 3 visar utdata för denna applikation. Ta en minut att studera denna produktion.

Matthew Tyson

Begär parametrar

Implicita objekt är inbyggda objekt som är tillgängliga via en JSP-sida. Som webbutvecklare kommer du att använda dessa objekt för att skapa åtkomst till saker som förfrågningsparametrar , vilket är den data som skickas över från webbläsaren när du utfärdar en HTTP-begäran. Tänk på webbläsarens URL för implicita objekt:

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

Parametern är ?foo=bar, och du kan se den återspeglas i utdata på webbsidan, där tabellen visar "EL-uttryck" och värdet är "bar". För att testa detta ändrar du webbadressen till //localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=zork , tryckerEnter och du ser ändringen återspeglas i utdata.

Detta exempel är en mycket enkel introduktion till att använda JSP-taggar för att få åtkomstparametrar på serversidan. I det här fallet använder JSP-sidan det inbyggda (implicita) objektet som kallas för paramatt komma åt webbapplikationens begäranparametrar. Den paramobjektet är tillgängligt inne i JSP uttryck syntax som du såg i Listning 1.

I det exemplet använde vi ett uttryck för att göra lite matematik:, ${2 * 2}vilken utdata 4.

I det här exemplet är det uttryck som används för att komma åt ett objekt och ett område på det objektet: ${param.foo}.

JSP i en webbapplikation

Klicka på bakåtpilen på sidan Implicit objekt följt av källkoden . Detta leder dig till JSP-koden för webbappen Implicit Objects, som visas i Listing 2.

Listning 2. JSP-kod för Implicit Objects webbapp

     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.

Du bör se dina uppdateringar återspeglas i utdata.