JavaServer Pages (JSP) är en Java-standardteknik som gör att du kan skriva dynamiska, datadrivna sidor för dina Java-webbapplikationer. JSP är byggd ovanpå Java Servlet specifikationen. De två teknikerna fungerar vanligtvis tillsammans, särskilt i äldre Java – webbapplikationer., Ur ett kodningsperspektiv är den mest uppenbara skillnaden mellan dem att med servlets skriver du Java-kod och sedan bädda in klientsidans markering (som HTML) i den koden, medan med JSP börjar du med klientsidans skript eller markering och sedan bädda in JSP-taggar för att ansluta din sida till Java-backend.
JSP är också nära relaterad till JSF (JavaServer Faces), en Java-specifikation för att bygga MVC (model-view-controller) webbapplikationer. JSP är en relativt enklare och äldre teknik än JSF, vilket är standard för Java web ramverk som Eclipse Mojarra, MyFaces, och PrimeFaces., Även om det inte är ovanligt att se JSP används som frontend för äldre JSF-applikationer, är Facelets den föredragna visningstekniken för moderna JSF-implementeringar.
medan 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 servlet behållare som Tomcat. Du kommer att stöta på JSP i äldre Java webbapplikationer, och från tid till annan kan du finna det användbart för att bygga enkla, dynamiska Java webbsidor., Som Java-utvecklare bör du åtminstone vara bekant med 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ädda in JSP-taggar för att ansluta till en Java-servlet och kör sidan i en servlet-Behållare.
Läs tidigare artiklar i denna serie om du vill veta mer om Java servlets och JavaServer Faces.
skriva JSP-sidor
en enkel JSP-sida (.jsp) består av HTML-kod inbäddad med JSP-taggar., När filen bearbetas på servern återges HTML som programvyn, en webbsida. De inbäddade JSP-taggarna kommer att användas för att anropa serversidan kod och data. Diagrammet i Figur 1 visar interaktionen mellan HTML, JSP och webbapplikationsservern.
Figur 1. JSP översikt
Notering 1 visar en enkel JSP-sida.
Lista 1., En enkel JSP-sida
<html> <body> <p>${2 * 2} should equal 4</p> </body></html>i Lista 1 ser du ett block av HTML 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 till HTML. När den exekveras kommer JSP att mata ut resultaten av att utföra vad som finns inuti uttrycket. I det här fallet kommer utmatningen att vara nummer 4.
JSP i servlet-behållaren
JSP-sidor måste distribueras i en Java servlet-Behållare., För att distribuera en Java webbapplikation baserad på JSP och servlets, du kommer att paketera din .JSP-filer, Java-kod och Application metadata i en .krig fil, vilket är en enkel .zip-fil med en konventionell struktur för webbapplikationer.
När du har laddat JSP i din servlet Behållare, det kommer att sammanställas i en servlet. JSPS och Java servlets delar liknande egenskaper, inklusive möjligheten att komma åt och svara på begäran objekt. Apache Tomcat 9x är referensimplementation för Servlet 4.0 och JSP 2.3 specifikationer. (Observera att uppdateringar mellan JSP 2.,2 och 2.3 är relativt små.)
exempel app för JSP
vi använder ett exempelprogram i Tomcat för att komma igång med JavaServer-sidor. Om du inte redan har Tomcat installerat bläddrar du över till Tomcat-nedladdningssidan och väljer Tomcat-installationen för ditt operativsystem. Från och med detta skrivande är Tomcat 9 den aktuella utgåvan, 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 start eller /bin/catalina.bat., Hur som helst, starta Tomcat och gå sedan till localhost:8080 för att se Tomcat-välkomstsidan som visas i Figur 2.
Figur 2. Tomcat welcome page
implicita objekt i Tomcat
på Tomcat welcome page klickar du på Exempellänken och klickar sedan på JSP-exempel.
Öppna sedan de implicita objekten kör webbapplikation. Figur 3 visar utdata för denna ansökan. Ta en minut att studera denna produktion.
Figur 3., Sample JSP output
begär parametrar
implicita objekt är inbyggda objekt tillgängliga via en JSP-sida. Som webbsideutvecklare använder du dessa objekt för att skapa åtkomst till saker som förfrågningsparametrar, vilka är de data som skickas över från webbläsaren när du utfärdar en HTTP-förfrågan. Tänk på webbläsarens URL för implicita objekt:
This example is a very simple introduction to using JSP tags to access server-side request parameters. In this case, the JSP page uses the built-in (implicit) object called param to access the web application’s request parameters. The param object is available inside the JSP expression syntax that you saw in Listing 1.
In that example, we used an expression to do some math: ${2 * 2}, which output 4.
In this example, the expression is used to access an object and a field on that object: ${param.foo}.
JSP in a web application
On the Implicit Objects page, click the back arrow, followed by the Source link. This will lead you to the JSP code for the Implicit Objects web app, which is shown in Listing 2.
Listing 2. JSP code for the Implicit Objects web app
JSP functions
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:
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>syntaxen är ganska tydlig: den importerar de nödvändiga funktionerna och tilldelar dem ett prefix (i det här fallet” fn”) som kan användas i alla följande uttryck.,
JSP Standard Tag Library (JSTL)
radenimport I Lista 2 samtaltaglib, vilket är kort för tag library, eller (i detta fall) JSP Standard Tag Library (JSTL). Tag bibliotek definierar återanvändbara bitar av funktionalitet för JSP. JSTL är standard taggbiblioteket, som innehåller en samling taglibs som levereras med varje servlet och JSP-implementering, inklusive Tomcat.
biblioteket ”funktioner” är bara en av taggarna som medföljer JSTL., En annan vanlig taglib är core – biblioteket, som du importerar genom att ringa:
<%@ taglib uri = "http://java.sun.com/jsp/jstl/core" prefix = "c" %>som ”fn”, ”C” – beteckningen är konventionell, och du kommer att se den på de flesta JSP-sidor.
säkra JSP-sidor
en exempeltagg från kärnbiblioteket är
<c:out value = "${'<div>'}"/> som matar ut<div> – taggen med XML som redan har rymt. Denna funktion är viktig eftersom utmatning av innehåll direkt till en webbsida via ${variable} öppnar dörren till skriptinjektionsattacker., Denna enkla funktion används för att skydda webbsidor från sådana attacker.
kärnbiblioteket innehåller också olika taggar för iteration och flödeskontroll (som IF / ELSE-hantering).
anropa taglibs i JSP-sidor
nu när du har ett handtag på JSP-grunderna, låt oss göra en ändring i exempelprogrammet. För att starta, leta reda på den implicita Objektappen i Tomcat-installationen. Sökvägen är: apache-tomcat-8.5.33/webapps/examples/jsp/jsp2/el.,
öppna den här filen och leta uppfunctions inkludera:
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>strax under den här raden lägger du till en ny rad:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>slå tillbaka och Lägg till en ny rad:
<c:out value = "${'This is a test of the JSTL Core Library'}"/>ladda nu om sidan påhttp://localhost:8080/examples/jsp/jsp2/el/implicit-objects.jsp?foo=bar.
Du bör se dina uppdateringar återspeglas i utdata.
Layout för ett JSP-webbprogram
Tomcat följer standardlayouten för Java servlet-och JSP-sidor., Den allmänna strukturen är en mapp med namnet på programmet, som distribueras i Tomcats/webapps katalog.
i appen implicita objekt är programmet/examples. När du öppnar den mappen visas tre viktiga barn: filen/WEB-INF, katalogenindex.html och en uppsättning andra kataloger.
katalogenWEB-INF innehåller metadata som informerar Tomcat om hur appen körs.
resten av innehållet, inklusive index.,html, är direkt tillgänglig, precis som det skulle vara i en typisk webbserver. På samma sätt ärimplicit-objects.jsp tillgänglig för visning och hanteras automatiskt som en JSP-sida (inte en HTML-sida) av servern.
Request-response architecture
i ett typiskt servlets / JSP-program tar servlets emot förfrågningar och interagerar med komponenter och tjänster på serversidan (t.ex. databasen) för att uppfylla dem. När begäran har hanterats vidarebefordras resultatet till en JSP-sida, som presenterar svaret.,
en servlet använder följande syntax när du skickar ett svar på en JSP-sida:
request.getRequestDispatcher("path/to/jsp.jsp").forward(req,res);Alla data som servlet har infogat i de olika JSP-omfattningarna kommer att vara tillgängliga för JSP. En omfattning är helt enkelt en rad liv för ett visst objekt. Begäran och svar objekt begär scoped, vilket innebär att de lever under hela begäran. Andra omfattningar inkluderar sidomfång (lever så länge som JSP-sidan gör) och sessionsomfång (avslutas när användaren avslutar den givna sessionen).,
slutsats
JavaServer Pages är en välkänd och mångsidig teknik för att utveckla Java web application vyer. I kombination med servlets är JSP-sidor mycket kraftfulla och ger tillgång till hela Java-funktionerna. Även om JSP kanske inte är ditt första val för att utveckla en modern Java – webbapplikation, kommer du att stöta på JSP-sidor i äldre applikationer. Det är också ett bra val för enklare program, där du snabbt vill ansluta din HTML frontend till serversidan Java-kod., JSTL-taggarna kan hantera de flesta webbapplikationskrav, och bibliotek från tredje part utökar den funktionaliteten för specifik teknik och användningsfall.