Denna sida beskriver kort hur man använder Java Server Pages (JSP). Det som behandlas på denna sida är bl.a. grundläggande om JSP samt skapandet av en enkel JSP-sida. Fortsatt läsning är hemsidorna som förklarar hur man använder Java Beans och servlets i en JSP-sida.
I beskrivningarna kommer även likheter och olikheter mellan JSP och Microsofts Active Server Pages (ASP) att påpekas. Kan du inte ASP kan du bortse från dessa kommentarer.
Inte alla webbservrar (som Björns studiewebb replikerats till) stödjer JSP. Detta kan leda till att du får ett felmeddelande när du försöker köra exemplen.
JSP bygger på Java men det finns ändå något av en "inlärningskurva" att passera innan vi kan börja använda JSP. Vi börjar med att titta lite på teorin bakom JSP. Har du bråttom med att komma igång eller vill se kod kan du hoppa till nästa avsnitt (Enkel JSP-sida).
JSP-sidor är egentligen HTML-kod där speciella taggar infogats där man vill ha dynamiskt innehåll i hemsidan, d.v.s. innehåll som kan ändras/anpassas mellan begäran av JSP-sidan. När en webbläsare begär en JSP-sida så kommer webbservern (eller snarare JSP-/servlet-servern) att gå igenom JSP-sidans kod och leta efter dessa speciella taggar. När servern hittar taggen så exekverar servern Java-koden som finns mellan den öppnande och avslutande taggen. Resultatet från exekveringen infogas i den resulterande hemsidan där koden fanns. Nedan visas ett exempel på var och hur JSP-kod kan infogas för att t.ex. visa antalet besök på en hemsida.
<P>Denna hemsida har besökts <% kod för räknare %> gånger.</P>
Bakom kulisserna kompileras JSP-sidan till en servlet första gången som sidan begärs av en webbläsare. Efterföljande begäran om JSP-sidan kommer använda den servlet som kompilerades vid första anropet. Skulle JSP-sidan ändras så kommer servlet-servern att upptäcka detta och kompilera den nya JSP-sidan till en ny servlet. Detta leder till att man alltid har en initial väntetid då en ny JSP-sida läggs ut på webbservern. Men detta bör vara acceptabelt då det inte är JSP-sidorna som ska uppdateras kontinuerligt utan det resultat de presterar.
Detta är egentligen inte något vi behöver bry oss om som skapare av JSP-sidor, men det kan t.ex. förklara varför en del av JSP:s syntax. Bl.a. så ska man utelämna semikolon (";") ibland för att koden i JSP-sidans resulterande servlet ska fungera. Det ska även nämnas att man kan be servern att kompilera en JSP-sida till servlet innan första besökaren begär den.
JSP-sidor bygger på XML-standarden, d.v.s. syntaxen är mer strikt hållen än den för HTML (du måste m.a.o. lägga bort eventuell fula ovanor du fått när du skapat "vanliga" hemsidor :-). Detta innebär bl.a. att alla JSP-relaterade taggar måste skrivas enligt JSP-specifikation eftersom servern är känslig för bokstävers skiftläge (d.v.s. gemener och versaler). Den statiska HTML-koden i ett JSP-dokument behandlas dock inte av servern, utan skickas direkt till besökarens webbläsare. HTML-koden brukar även kallas för malltext (eng. template text).
Precis som i XML så måste alla JSP-taggar användas med sin avslutande tagg
<jsp:useBean id="ett_namn" ...>
...
</jsp>
Undantaget från denna regel är de taggar som inte har något innehåll (inget mellan öppnande och avslutande tagg). Den avslutande taggen kan utelämnas om den öppnande taggen avslutas med ett snedstreck (eng. slash - "/").
<jsp:useBean ... />
Liksom HTML (och XML) så kan taggar ha attribut som anges i den öppnande taggen. Attributens namn, liksom dess värden, är också känsliga för skiftläge. Värdena måste anges inom enkla eller dubbla citattecken.
JSP-sidor kan innehålla bl.a.
Det som skiljer en JSP-sida från en vanlig hemsida är de tre sista i listan ovan. Dessa tre typer av element blandas in i HTML-koden och tolkas av serlvet-servern innan ett resulterande HTML-dokument (hemsida) skickas till besökarens webbläsare.
Skriptelementen påminner mycket om Microsofts ASP, men använder (oftast) Java som språk istället för VBScript/JScript. En av de mer iögonfallande likheterna (bortsett från förkortningen :-) är att man bl.a. kan använda <% och %> för att skilja JSP-koden från HTML-koden.
Det finns fyra olika typer av skriptelement:
Elementen har varsin tagg, vilka beskrivs nedan. Observera att alla dessa taggar måste skrivas utan mellanslag! (se vidare nedan).
Uttryckselement används bl.a. för att skriva ut enklare saker, t.ex. innehållet i variabler.
<%= strVariabel %>
Observera att likhetstecknet ("=") måste skrivas direkt efter det inledande procenttecknet ("%"), d.v.s. "<%=", och avsaknaden av semikolon (";") innan avslutande procenttecknet! (Placeringen av likhetstecknet är bl.a. en av de punkter som JSP är striktare än ASP.)
Scriptlets är små snuttar av kod som bäddats in i HTML-koden inom taggarna <% och %>. Koden som skrivs här är "vanlig" Java-kod - vi har alltså tillgång till Javas alla kontrollstukturer (if- och case-satser samt for- och while-loopar).
I scriptlet-koden kan man deklarera variabler precis som i "vanliga" Java-program, d.v.s. följande kod dekalerar en variabel som sen används som räknare i for-loopen.
<%
int i = 0;for( i = 0; i < 5; i++)
out.println('Detta är loop-varv ' + i + '<br>');
%>
I JSP kan man deklarera variabler m.h.a. taggen <%! %>. Men man bör undvika denna form av deklaration av variabler!
<%! int variabel = 0; %>
Skälet till detta är att JSP-koden kommer kompileras till en servlet (se mer nedan) och värdet för variabler, som deklareras på detta sätt, kan manipuleras av alla metoder i den resulterande servlet. Variabler deklarerade på detta sätt blir s.k. instansvariabler och det finns endast en instans av varje JSP-sidas servlet. Detta innebär att om två besökare begär samma JSP-sida (d.v.s. dess resulterande servlet) så kommer bägge besökarenas bägge JSP-sidor använda samma variabel.
JSP-kommentarer är egentligen inte ett "riktigt" skriptelement. Men denna typ av kommentarer är ganska praktiska då de är synliga i koden för ett JSP-dokument men inte i den resulterande hemsidans HTML-kod. Syntaxen påminner mycket om HTML-kommentarer och har följande utseende
<%-- Kommentartext... --%>
I JSP finns ett antal variabler (objekt) som alltid är tillgängliga (precis som i ASP - de har för övrigt motsvarande funktion som i just ASP). De mest använda är följande:
Andra objekt som också finns och som man brukar komma i kontakt med är session, application och exception. (Ytterligare fler objekt som det är mindre sannolikt att man kommer i kontakt med är config, pgae och pageContext.)
För att hämta värden från ett formulär använder vi t.ex. metoden getParameter() i objektet request, som vi skickar namnet på formulärets kontroll som parameter till.
<%= request.getParameter('namn_pa_kontroll') %>
Inuti scriptlets måste vi, precis som i servlets, använda metoderna print() eller println() för att skriva till den resulterande hemsidan och för detta finns objektet out. Skillnaden mot servlets är att vi inte behöver fråga efter objektet utan det finns alltid tillgängligt i variabeln out. (Exempel på hur metoderna används hittar du under Scriptlets ovan där lite text och en räknare skrivs ut i for-loopen.)
Scriptlets bör hållas till ett minimum, d.v.s. man bör inte använda scriptlets för att hantera all logik i en JSP-sida (som många tenderar till att göra med ASP och PHP). Istället bör man använda (statisk) HTML-kod samt skapa Java Beans eller servlets för att hantera logiken och det dynamiska innehållet i hemsidan. Servlets och Java Beans används sen m.h.a. händelseelementen (se nedan). JSP-sidor bör m.a.o. endast användas för att skapa ett presentationsskikt åt Java Beans och servlets.
Det ska nämnas att inte alla uppskattar JSP, bl.a. för dess likhet med ASP. De anser även att JSP leder till att man lockas till att använda många scriptlets istället för att placera logiken i servlets och Java Beans. (Se bl.a. servlets.com.)
Direktiven innehåller information om själva JSP-dokumentet (förblir de samma mellan anrop till sidan), t.ex. filer som ska inkluderas och språk för skriptelement. Det finns tre stycken direktiv:
Direktiven använder attribut för att ange värden. Attributet file (som är det enda attributet) för include-direktivet används t.ex. för att inkludera andra (statiska) filer i JSP-dokumentet. page-direktivet har ett flertal attribut, bl.a. language och contentType som bör vara med i alla JSP-dokument.
<%@ page language="Java" contentType="text/html" %>
<%@ page import="GurkKlass" %>
<%@ include file="sidhuvud.html" %>
Vill vi använda Java Beans i ett JSP-dokument så behöver vi importera klassen för Java Beans med attributet import för page-direktivet.
Händelseelementen används för att bl.a. använda Java Beans och för att inkludera (dynamiska) filer. Taggar för händelseelement består av tre delar:
Syntaxen för händelseelementen är följande:
<taggbilbiotek:händelse attribut1="värde1" ...>
ev. innehåll
</taggbibliotek:händelse>
Som nämnt ovan så kan taggar utan innehåll förkortas genom att använda ett snedstrek sist i taggen. Ovanstående kod kan då förkortas till
<taggbilbiotek:händelse attribut1="värde1" ... />
Där finns händelser för att skapa Java Beans samt för att sätt och hämta värden på egenskaper i Java Beans. Programmerare kan även skapa egna händelseelement (behandlas ännu inte på denna webbplats).
<jsp:useBean id:'salt' scope='application' class='Gurka' />
<jsp:include page="sidhuvud.html">
Skillnaden mellan att använda direktivet include och händelseelementet <jsp:include> för att inkludera filer är att direktivet endast kan inkludera statiska filer. Med statiska filer menas filer som inte ändras vid exekvering av JSP-dokumentet. Händelseelementet kan även hantera resultatet från en t.ex. servlet eller annan JSP-sida som genererats (dynamiskt) vid exekvering av JSP-dokumentet.
Till skillnad mot servlets så brukar inte servern vara känslig för skiftläget (gemener och versaler) på JSP-sidans filnamn. D.v.s. helloworld.jsp och HelloWorld.jsp bör fungerar båda två.
| Till början på sida |
Denna första, enkla JSP-sida visar hur vi anger språket för JSP-koden samt hur vi kan använda scriptlets för att skriva ut variabler och resultatet från enkla Java-satser (dagens datum i detta fall).
I exemplet nedan så börjar vi med att ange programmeringsspråket som ska användas i JSP-sidan.
<%@ page language="Java" %>
Enligt JSP-specifikationen så ska man kunna använda vilket språk som helst, men de flesta servrar har bara implementerats för Java (Resin tillåter även JavaScript). Därefter följen några rader med vanlig HTML-kod. Efter rubriken (H1) finns ett stycke (P) där dagens datum och aktuell tid skrivs ut.
<%= new java.util.Date().toString()%>
Vad som sker är att ett nytt datumobjekt skapas och som direkt konverteras till en sträng för utskrift.
<%@ page language="Java" %>
<HTML>
<HEAD>
<TITLE>Hello World</TITLE>
</HEAD>
<BODY>
<H1>Hello world</H1>
<P>Idag är det <B><%= new java.util.Date().toString()
%></B></P>
</BODY>
</HTML>
JSP-sidorna kan placeras i vilken mapp som helst (utom WEB-INF och undermappar) under en av serverns s.k. servlet contexts (<rotmapp>\doc som standard med Resin - se Installera Resin-server).
På Björns studiewebb har (på vissa webbservrar - se Replikering på sidan Om i huvudwebben) mappen JAVA konfigurerats som ett servlet context. Alla JSP-filer har placerats i mappen JSP under denna mapp.
För att testa JSP-sida så öppnar man en URL som liknar följande
https://server-namn:8080/Filnamn.jsp
eller bara
https://server-namn/Filnamn.jsp
om server för servlets (t.ex. Resin eller Tomcat) har "integrerats" med ordinarie webbserver.
| Till början på sida | Tillbaka till Java |