close

Java-serversidor

Gå till navigering Gå till sök
JSP
Förlängning .jsp
MIME -typ application/jsp
Utvecklaren Eclipse Foundation
Senaste släppningen 3.1.0 (15 maj 2022 ; 5 månader sedan ) ( 2022-05-15 )
Formattyp filformat , mallmotor och teknisk specifikation
Standard(er) JSR 245
Hemsida projects.eclipse.org/… ​(  engelska)
 Mediafiler på Wikimedia Commons

JSP ( JavaServer Pages ) är en teknik som gör att webbutvecklare kan skapa innehåll som har både statiska och dynamiska komponenter. En JSP-sida innehåller två typer av text: statisk källdata, som kan vara i ett av textformaten HTML , SVG , WML eller XML , och JSP-element som konstruerar dynamiskt innehåll. Dessutom kan JSP-taggbibliotek, såväl som Expression Language (EL), användas för att bädda in Java -kod i det statiska innehållet på JSP-sidor.

JSP-sidkoden översätts till Java-servletkod med Jasper JSP-sidkompilatorn och kompileras sedan till Java Virtual Machine ( JVM ) bytekod . Servlet-behållare som kan köra JSP-sidor är skrivna på det plattformsoberoende Java-språket. JSP:er laddas på servern och hanteras från en speciell Java-serverpaketstruktur som kallas Jakarta EE Web Application. Vanligtvis är sidor förpackade i .war- och .ear -filarkiv .

JSP-teknik är en plattformsoberoende, portabel och lätt utbyggbar teknik för att utveckla webbapplikationer .

Versioner

Sedan version 1.2 har utvecklingen av JavaServer Pages skett under Java Community Process . JSR 53 definierar JSP 1.2- och Servlet 2.3-standarderna, medan JSR 152 definierar JSP 2.0-specifikationen. I maj 2006 släpptes JSP-specifikationen 2.1 under JSR 245 som en del av Java EE 5 . Den 10 december 2009 släpptes JSP 2.2-specifikationen som innehållet i JSR 245- versionen .

JSP 1.0 och JSP 1.1

Dessa versioner skiljer sig fundamentalt från de tidigare versionerna, som uppfattades som Javas svar på ASP . Några av kärnfunktionerna i tidigare versioner (som möjligheten att utveckla taggbibliotek) har tagits bort eller ersatts i enlighet med principen om separation av kod och innehåll. Eftersom det är svårt att navigera och separera innehållet från själva koden i stora volymer källkod , kom idén att separera (överföra) dem med hjälp av JSP-taggar, som <jsp:useBean/>. För att implementera denna idé har JSP-taggar delats upp i tre logiska grupper: direktiv, skriptelement och åtgärder.

JSP 1.2

JSP 1.2 utökar JavaServer Pages 1.1 (JSP 1.1)-specifikationen enligt följande:

  • Kräver Java 2 -plattformsversion 1.2 eller senare;
  • Använder Servlet 2.3 som grund för sin semantik;
  • Definierar XML -syntaxen för JSP-sidor;
  • Tillhandahåller JSP-sidavalidering under översättningsfasen;
  • Anger rensningen av taggbiblioteket vid körning;
  • Förbättrar tagghanterarens kontrakt;
  • Ger förbättrat stöd för sida auktorisering ;
  • Förbättrar teckenkodning och lokaliseringsstöd;
  • Tar bort begränsningen "spolning innan du inkluderar" från JSP 1.1.

JSP 2.0

Den nya versionen av JSP-specifikationen lägger till följande funktionalitet:

  • Expression Language (EL)  - ett uttrycksspråk som bland annat låter utvecklare skapa mallar i Velocity -stilen ;
  • Ett enklare och snabbare sätt att skapa nya taggar med hjälp av filer .tag, nu behöver du inte kunna Java för att skapa nya taggar;
  • Bekvämt sätt att hantera kapslade bönor ( JavaBeans );
  • Ett snabbare och enklare sätt att visa variabla parametrar:
Hej $ { param . _  besökare } <%-- liknande : Hej , < %= begäran . getParameter ( "besökare" ) %> --%>

JSP 2.1

Java EE 5-plattformen fokuserar på enkel utveckling med hjälp av Java-språkanteckningar som introducerades av J2SE 5.0 . JSP 2.1 stöder detta mål genom att definiera annoteringar om beroendeinjektion på JSP-uttalanden och kontextlyssnare.

Översikt

JavaServer Pages (JSP) låter dig separera den dynamiska delen av sidorna från den statiska HTML . Den dynamiska delen är innesluten i speciella taggar "<% %>": 

 Ditt  värdnamn : <% =  begäran . getRemoteHost () %>

JSP-sidor har ett tillägg .jspoch placeras på samma plats som vanliga webbsidor. Strukturen på sådana sidor kan bestå av fem konstruktioner: HTML , kommentarer, skriptelement, direktiv och åtgärder. JSP-sidan kompileras till en servlet med statiskt innehåll som skickas till utgångsströmmen som är kopplad till tjänstemetoden . Därför, på den första begäran, kan denna process orsaka en liten fördröjning. Kommentarer i ett dokument eller program får inte programmet att sakta ner, eftersom de ignoreras av kompilatorn och utföraren. Skriptelement låter dig specificera Java -kod som senare kommer att bli en del av den slutliga servleten, direktiv låter dig kontrollera hela strukturen för servleten, och åtgärder tjänar till att specificera de befintliga komponenterna som används, samt styra beteendet hos JSP-motorn . För att göra skript enklare finns det fördefinierade variabler som request, response, pageContext, session, out, application, config, page, exception. Ett exempel på en JSP-sida som använder alla JSP-komponenter:

JSP exempel med cooments.JPG

Kommentarer

Kommentarer används för att förklara källkoden för ett program. På JSP-sidor kan kommentarer delas in i två grupper:

  • JSP-källkodskommentarer
  • HTML -markeringskommentarer .

JSP-källkodskommentarer är markerade med en speciell teckensekvens: <%--i början och --%>i slutet av kommentaren. Denna typ av kommentar tas bort när JSP-sidan kompileras. JSP-kommentarexempel: 

<% 
	-- Visar  produktkatalogen  och den aktuella varukorgen 
	. --%>

HTML -markeringskommentarer formateras enligt reglerna för HTML-språket. Den här typen av kommentarer behandlas som statisk text av JSP-kompilatorn och placeras i HTML-dokumentet. JSP-uttryck inuti HTML-kommentarer körs. HTML-kommentarexempel: 

<!--  Sidans skapandedatum :  < %= new java . util . Datum () %> -->

Skriptelement

JSP-specifikationen särskiljer tre typer av skriptelement:

  • Deklarationer <%!en eller flera deklarationer%>
  • Uttryck <%=enstaka uttryck%>
  • skriplets <%_%>

Deklarationer används vanligtvis för att definiera variabler, metoder, inre klasser och andra giltiga Java-konstruktioner på klassnivå. Uttrycken blir argument till out.print()-metoden. Med hjälp av scriptlets bäddas fungerande delar av Java-koden in i JSP-sidor.

JSP-deklarationer

JSP-deklarationer låter dig definiera variabler, metoder, inre klasser och så vidare. Deklarationer används för att definiera Java-konstruktionerna som används i programmet. Eftersom deklarationer inte renderas används de vanligtvis tillsammans med JSP-uttryck eller scriptlets. JSP-exemplet visar antalet förfrågningar till den här sidan sedan servern startades (eller sedan servleten senast ändrades och laddades om). Observera att vi i exemplet använder både en deklaration och ett uttryck, och att inuti konstruktionen finns ett semikolon ( ; ) efter deklarationen: 

<%!  privat  int  accessCount  =  0 ;  % 
> Antal  sidträffar  sedan serverladdning : < % = ++ accessCount  % >

JSP-uttryck

JSP-uttryck används för att infoga Java-värden direkt i utgången. Java-uttryck utvärderas, konverteras till en sträng och infogas på sidan. Dessa beräkningar sker vid körning (det vill säga när sidan efterfrågas), och därför finns det full tillgång till information om själva begäran. I uttryck kan du använda konstanter, variabler, anrop till olika metoder. Alla uttryck, oavsett hur komplext innehållet är, utvärderas till ett enda resultat eller nummer. JSP-sidor förlitar sig på JSP Writer , som tar alla resultat av ett uttryck, konverterar det till en typ String(text) och buffrar det . Till exempel visar följande kod datum och tid för en given sidförfrågan: 

Aktuell  tid :  <%=  new  java . util . Datum ()  %> 
Ditt värdnamn  : <% = begäran . getRemoteHost () %>

Du måste vara uppmärksam på tre regler:

  • JSP-uttryck måste innehålla Java-uttryck;
  • varje JSP-uttryck måste endast innehålla ett Java-uttryck;
  • JSP-uttryck får inte sluta med semikolon ( ;), till skillnad från Java-deklarationer.

JSP-skript

JSP-skript låter dig infoga vilken kod som helst i en servletmetod som genereras när sidan renderas, vilket gör att du kan använda de flesta av Java-konstruktionerna. Skript har också tillgång till samma fördefinierade variabler som uttryck. Därför måste du till exempel använda en fördefinierad variabel för att visa ett värde på en sida out. 

<%  
String  queryData  =  begäran . getQueryString (); 
ut . println ( "Ytterligare frågedata: "  +  queryData );  
%>

Koden inuti scriptleten infogas som den skrevs. All statisk HTML (malltext) före eller efter skriptlet konverteras med hjälp av print. Till exempel innehåller följande JSP-kodavsnitt blandad mall- och skripttext: 

<%  if  ( Math . random ()  <  0.5 )  {  %> 
     < B > Ha en trevlig dag </ B >  ! <% } else { %> < B > Ha en dålig dag </ B > för dig ! <% } %>

Efter att ha konverterat scriptleten kommer koden att se ut så här: 

if  ( Math . random ( )  <  0,5 )  {  
     out . println ( "<B>Ha en trevlig</B> dag!" ); 
}  annat  {  
     ut . println ( "<B>Ha en dålig dag</B> för dig!" ); 
}

Detta innebär att scriptlets inte behöver innehålla kompletta Java-snuttar, och att block som lämnas öppna kan påverka statisk HTML utanför scriptleten.

JSP-direktiv

JSP-sidan kan skicka ett meddelande till lämplig behållare med instruktioner om vad som ska göras. Dessa meddelanden kallas direktiv. Alla direktiv börjar med <%@, följt av namnet på direktivet och ett eller flera attribut med värden och slutar med %>. Direktiven på JSP-sidan gör att behållaren skickar en begäran om att exekvera en specifik tjänst som inte deklareras i det genererade dokumentet. Formen av direktiv kan representeras enligt följande: 

<% @  direktivattribut  = "värde" % >

Du kan också kombinera att ställa in flera attribut på ett enda direktiv: 

<% @  direktiv  attribut1 = "värde1"  
              attribut2 = "värde2" 
              ... attributN 
              = " värdeN " %>

Det finns tre huvudtyper av direktiv: page , som låter dig göra saker som att importera klasser, ändra en servlets superklass och så vidare; include , som låter dig infoga en fil i en servletklass när du översätter en JSP-fil till en servlet; och taglib , som låter dig utöka många taggar med dina egna, vilket JSP-behållaren kan tolka.

JSP siddirektiv

Som namnet antyder tillhandahåller detta direktiv attribut för JSP-sidan. Attributen som definieras i detta direktiv är inbäddade i den givna JSP-sidan och alla dess kapslade statiska element, oavsett om de infogades med direktivet includeeller med åtgärden jsp:include. Utformningen av direktivet är pageföljande: 

<% @  page  attribute = " värde "  %>

Låt oss ta följande post som ett exempel: 

<% @  page  import = ” java . util . * ,  com . mina klasser . * ”  buffert = ” 15 kb ”  %>

Detta direktiv anger att JSP-sidan kommer att importera klasser från två Java-paket java.utiloch com.myclassesanger sedan storleken på buffertminnet som ska användas för att bearbeta den givna JSP-sidan.

Tänk sedan på direktivets attribut page:

  • import="пакет.class1, пакет.class2, ..., пакет.classN".Låter dig ange vilka paket som ska importeras. Detta är det enda attributet som kan användas flera gånger i samma direktiv. Listan bör inkludera alla Java-klasser som du vill använda som inte är en del av den ursprungliga uppsättningen av importerade klasser. Källuppsättningen innehåller: java.lang.*, javax.servlet.*, javax.servlet.jsp.* и javax.servlet.http.*.Ett exempel på användning av attributet import:
<% @  page  import = "java.util.Date, javax.text.SimpleDateFormat, com.myclasses.*"  %>
  • language="java".Detta attribut är avsett att ställa in vilket programmeringsspråk som används . Standardvärdet är "java". Det här attributet är valfritt, men problemet kan fortfarande uppstå om behållarens JSP-leverantör använder andra språk (som JavaScript ). Ett exempel på posten för detta attribut är följande:
<% @  page  language = " java "  %>
  • extends="пакет.class".Anger superklassen (förälderklass) för den genererade servleten. Vanligtvis är en servlet en förlängning av den ursprungliga klassen. Erfarna programmerare kan använda detta attribut för att skapa sina egna superklasser. Ett exempel på hur det här attributet används kan se ut så här:
<% @  page  extends = ” myPackage . HttpExample "  %>
  • session="true|false".Det här attributet kan ställas in på sant eller falskt , vilket avgör om JSP-sidan deltar i HTTP- översättningen . Värdet true(“true”, standard) signalerar att den fördefinierade variabeln session(typ HttpSession) ska bindas till en befintlig session, om det finns en, annars skapas och binds en ny session till. Värdet false("false") anger att sessioner inte kommer att användas, och försök att komma åt variabeln sessionkommer att resultera i ett fel när JSP-sidan översätts till servleten. Ett exempel på hur det här attributet används kan se ut så här:
<% @  page  session = " false "  %>
  • buffer="размерkb|none".Det här attributet anger mängden buffertminne som krävs för JspWriter- objektet som refereras till av den fördefinierade variabeln out. Standardvärdet beror på serverinställningarna, men bör vara större än 8kb. Värdet ges antingen i formen "sizekb" eller "ingen". Om du ställer in buffertminnesvärdet till none, kommer servleten inte att lagra något i buffertminnet och skickar resultatet som skrivits före variabeln outdirekt till objektet PrintWritersom tillhandahålls med objektet ServletResponse.. Om du ställer in buffertminnesvärdet till ett specifikt värde, kommer den JspWriteratt lagra data i detta minne, vilket resulterar i en ökad prestanda. Till skillnad från ett objekt kan PrintWriterett objekt JspWriterskapa undantag IOExceptions. Det initiala värdet för buffertminnet är 8kB. En exempelpost för detta attribut kan se ut så här:
<% @  pagebuffer  = ” 12 kb ” % >
  • autoflush="true|false".Detta attribut kan vara antingen sant eller falskt . Värdet true("true" som standard) anger att om buffertminnet svämmar över, kommer det att rensas automatiskt. Ett värde false("false"), som sällan används, anger att ett buffertspill ska resultera i ett undantag ( IOExceptions). Vanligtvis sätts attributen och buffersamman autoflushi ett direktiv. När du ställer in ett attributvärde är buffer="none"inställningen av ett värde falseför ett attribut autoflushogiltigt. Ett exempel kan se ut så här:
<% @  page  buffer = ” 16 kb ”  autoflush = ” sant ”  %>
  • isThreadSafe="true|false".Detta attribut kan vara antingen sant eller falskt . Värdet true("true", standard) anger det normala servletexekveringsläget, när flera förfrågningar behandlas samtidigt med en enda servletinstans, baserat på antagandet att författaren har synkroniserad åtkomst till variabler i denna instans. Värdet false("false") signalerar att servleten ska ärva SingleThreadModel(entrådig modell) där sekventiella eller samtidiga förfrågningar hanteras av separata servletinstanser. Med andra ord kommer värdet trueatt få behållaren att skicka flera förfrågningar till servleten på en gång, medan värdet gör att falsebehållaren skickar förfrågningar en i taget. Ett exempel på användning ser ut så här:
<% @  page  isThreadSafe = ” false ”  %>
  • info="информация".Anger en sträng som kan hämtas när metoden används Servlet.getServletInfo().. Vanligtvis returnerar denna metod information om servleten (som författare, version och upphovsrätt). En exempelpost för detta attribut kan se ut så här:
<% @  page  info = ” Författare :  Petr  Ivanovich ;  version : 1.0 "  %>
  • errorPage="url".Anger en JSP-sida som anropas när händelser inträffar Throwablessom inte hanteras av den här sidan. Om ett undantag inträffar på en JSP-sida och JSP-sidan inte har sin egen kod för att lösa undantaget, kommer behållaren automatiskt att överföra kontrollen till den URL som du angav som värdet för attributet errorPage. Ett exempelinlägg ser ut så här:
<% @  page  errorPage = " / myweb / errors / myerror . jsp "  %>
  • isErrorPage="true|false".Detta attribut kan vara antingen sant eller falskt . Signalerar om denna sida kan användas för felhantering för andra JSP-sidor eller inte. Standardvärdet är false"false". Ett exempel på hur det här attributet används kan se ut så här:
<% @  page  isErrorPage = ” true ”  %>
  • contentType="MIME-Тип".Det här attributet ställer in MIMEutdatatypen och valfritt kan du ställa in teckenkodningen i svaret ( HTML- svar). Standardvärdet MIMEär text/html. För tydlighetens skull kan vi använda följande exempel:
<% @  page  contentType = "text/vanlig"  %>

Du kan uppnå samma resultat med ett scriptlet: 

<%  svar . setContentType ( "text/plain" );  %>

JSP inkluderar direktiv

Detta direktiv låter dig inkludera filer i en servlet när du översätter en JSP-sida. Att använda direktivet ser ut så här: 

<% @  include  file = "relativ url"  %>

Den givna URL :en tolkas vanligtvis i förhållande till JSP för sidan där länken finns, men som med alla andra relativa URL :er kan du berätta för systemet var resursen du är intresserad av i förhållande till webbserverns hemkatalogen genom att prefixet URL :en med en " / " symbol . Innehållet i en include-fil behandlas som vanlig JSP-text och kan därför inkludera element som statisk HTML , skriptelement, direktiv och åtgärder. Till exempel använder många webbplatser ett litet navigeringsfält på varje sida. På grund av problemen med att använda HTML- ramar löses denna uppgift ofta genom att placera en liten tabell överst eller i den vänstra halvan av sidan, vars HTML -kod upprepas många gånger för varje sida på webbplatsen. Direktivet includeär det mest naturliga sättet att utföra denna uppgift, och räddar utvecklaren från mardrömmen att kopiera HTML till varje enskild fil. Det händer så här: 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.0 Transitional//EN" > 
< html > 
< head > 
  < title > Testsida  < / title > 
</ head > 
< body > 
  <% @  include  file = "/navbar .html"  %>

  <!--  Ett specifikt  fragment av  denna  sida  ...  -->

</ body > 
</ html >

Observera att eftersom direktivet includeinkluderar filer under sidöversättning, efter att ha gjort ändringar i navigeringsfältet, måste du översätta alla JSP-sidor på nytt med det. Vilket i det här fallet är en bra kompromiss, eftersom navigeringsfältet som regel ändras ganska sällan och anslutningsprocessen inte förlorar sin effektivitet. Om de inkluderade filerna ändras ganska ofta kan du använda åtgärden istället jsp:include. Den här åtgärden inkluderar filen vid åtkomst till JSP.

JSP taglib direktiv

Som du redan vet, på JSP-sidor skrivs element med taggar (konventionella skyltar, etiketter, varumärken). Uppsättningen taggar som en JSP-container kan tolka kan utökas med så kallade taggbibliotek. Du kan också bifoga åtgärder till en utökad uppsättning taggar, vilket resulterar i en förlängning av själva JSP-språket. Taggar kan delas in i standardtaggar och anpassade taggar. Ett generaliserat sätt att skriva kan se ut så här: 

<% @  taglib  uri = " URI  för att  tagga biblioteket  " prefix = " teckenprefix " % >

Taggbiblioteket måste identifieras av en URI- adress (en unik resursidentifierare). URI kan vara antingen absolut eller relativ. Den unika resursidentifieraren identifierar platsen för ett taggbibliotek ( TLD ) som definierar det bibliotekets egna taggar. Ett exempel på en direktivpost: 

<% @  taglib  uri = " http://www.moywebserver.ru/naydiznaki.tld " prefix = "iskat" %>

En JSP-sida kan innehålla ett oändligt antal direktiv taglib, men varje direktiv måste ges ett annat prefix som definierar innehållet i biblioteket på sidan. Som prefix kan du använda vilken text, vilket ord som helst. Medan ett direktiv taglibkan användas var som helst på en JSP-sida, måste alla inbyggda taggar som dessa direktiv använder användas bakom dem.

Åtgärder

JSP-åtgärder använder XML -syntaxkonstruktioner för att styra driften av servletmotorn. Du kan dynamiskt inkludera en fil, återanvända JavaBeans , dirigera användaren till en annan sida eller generera HTML för ett Java-plugin . Alla dessa åtgärder diskuteras i detalj nedan. Kom ihåg att, som med all XML , är element- och attributnamn skiftlägeskänsliga. Åtgärder kan delas in i två grupper: standard och skapad (egna, som programmeraren skapar). Följande standardåtgärder är tillåtna:

  • jsp:declaration  — Deklaration, liknande <%-tagg! … %>;
  • jsp:scriptlet  - Scriptlet, liknande taggen <% ... %>;
  • jsp:expression  - Uttryck, liknande taggen <%= ... %>;
  • jsp:text  - Textutdata;
  • jsp:useBean  - Hitta eller skapa en ny JavaBean-instans;
  • jsp:setProperty  - Ställ in JavaBean-egenskaper;
  • jsp:getProperty  - Infoga en JavaBean-egenskap i utdataströmmen;
  • jsp:include  - Inkluderar filen vid tidpunkten för sidförfrågan;
  • jsp:forward  - Omdirigerar begäran till en annan sida;
  • jsp:param  - Lägger till parametrar till förfrågningsobjektet, såsom forward, include, plugin.;
  • jsp:plugin  - Genererar kod (beroende på vilken typ av webbläsare som används) som skapar en taggOBJECTellerEMBEDför ett Java-plugin;
  • jsp:params  - Grupperar parametrar inom jsp:plugin-taggen;
  • jsp:fallback  - Anger innehållet som ska användas av klientwebbläsaren om plugin-programmet inte startar. Används inuti plugin-elementet.

jsp:useBean action

Denna åtgärd låter dig ladda en JavaBean för senare användning på en JSP-sida. Den här funktionen låter dig återanvända Java-klasser utan att offra fördelarna med JSP-servlets. Dessutom är detta ett sätt att ta bort mycket av Java-bearbetningen från JSP-sidan. Om du överför Java-bearbetning från en JSP-sida till en JavaBean, kan dessa funktioner sedan användas på andra JSP-sidor. Den enklaste syntaxen för att specificera bönan som ska användas är: 

< jsp : useBean  id = "name"  class = "package.class"  />

Vanligtvis betyder detta att "skapa en ny instans av ett objekt av den klass som specificeras av klassen och associera det med en variabel som heter id ". Du kan dock ställa in scope- attributet (tar värdena page|request|session|application, pageför sidan, requestför förfrågningar, sessionför sessioner eller dialoger, applicationför applikationen), som beaninte bara är associerad med den aktuella sidan. I det här fallet är det användbart att få referenser till befintliga beans, och åtgärden jsp:useBeaninstansierar bara ett nytt objekt om inget objekt finns med samma id och scope- värden . Nu när du har en bean, kan du ändra dess egenskaper med en åtgärd jsp:setProperty, eller genom att använda ett skript för att göra det och explicit anropa objektets metod med variabelnamnet som specificerats tidigare via id- attributet . Kom ihåg att med bönor , när du säger "den här bönan har en egenskap av typ X med namnet foo" menar du verkligen "den här klassen har en metod getFoosom returnerar data av typ X och en annan metod som tar X setFoosom en parameter." Åtgärden jsp:setPropertybehandlas mer i detalj i nästa avsnitt, men för närvarande bör du komma ihåg att du antingen explicit kan ställa in värde genom att ställa in param- attributet för att få värdet från motsvarande frågeparameter, eller helt enkelt räkna upp egenskaper för att få värden från frågeparametrar med samma namn som egenskaper. Du kan få värdena för befintliga egenskaper med hjälp av JSP-uttryck eller scriptlets genom att anropa lämplig metod getXxx, eller (oftast) genom att använda en åtgärd jsp:getProperty.

Klassen som ges till bönan måste finnas i serverns normala klasskatalog, inte i den del som är reserverad för klasser som automatiskt laddas om efter redigering. Till exempel för Java Web Server måste alla klasser som används placeras i en katalog classeseller .jar -fil i katalogen lib, inte i katalogen servlets. Nedan är ett enkelt exempel som laddar beanoch ställer in/får en enkel strängparameter.

BeanTest.jsp 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.0 Transitional//EN" > < 
html > < 
head > < 
  title > Återanvända JavaBeans  i JSP < / title > < / head > < body > < h1 > Återanvända  JavaBeans i JSP </ h1 > < jsp : useBean id = "test" class = "hall.SimpleBean" /> < jsp : setProperty name = "test" egenskap = "meddelande" värde = "Hej WWW" /> < p > Meddelande : < jsp : getProperty name = "test" egenskap = "meddelande" /> </ p > </ body > </ html >

SimpleBean.java 

pakethall  ; _

public  class  SimpleBean  { 
  private  String  message  =  "Meddelandetext ej angiven" ;

  public  String  getMessage ()  { 
    return ( meddelande ); 
  } 
  public  void  setMessage ( String  message )  { 
    this . meddelande  =  meddelande _ 
  } 
}

Lite mer information om hur du använder jsp:useBean. Det enklaste sättet att använda bean det är att använda konstruktionen: 

   < jsp : useBean  id = "name"  class = "package.class"  />

att ladda beanoch sedan använda jsp:setPropertyoch jsp:getPropertyför att ändra och få dess egenskaper (parametrar). Det finns dock två andra sätt. Först kan du använda behållarformatet, nämligen: 

  < jsp : useBean  ... >  
    Kropp  
  </ jsp : useBean >

för att säkerställa att kroppen endast exekveras när en instans beanskapas för första gången, och inte när en befintlig hittas och används bean. Som diskuteras nedan, beanskan delas, så inte alla uttryck jsp:useBeanresulterar i en ny instans av bean. För det andra, förutom id och class , finns det tre andra attribut du kan använda: scope , type och beanName . Dessa attribut beskrivs nedan:

  • id  - Ger namnet på variabeln som refererar tillbean. Om det kan hittasbeanmed samma värden föridochscope, används det tidigare skapade objektet istället för att skapa en ny instans;
  • class  - anger paketets fullständiga namnbean;
  • scope  - anger i vilken omfattning denbeanska vara tillgänglig. Det kan ta fyra giltiga värden: sida , begäran , session och applikation . Den har som standard sida , vilket betyder att denbeanbara är tillgänglig på den aktuella sidan (värd på denPageContextaktuella sidan). Begäranvärdetbetyder att detendast är tillgängligt för den aktuella klientbegäran (värd i objektet ) . Sessionsvärdet innebär att objektet är tillgängligt för alla sidor under den aktuella livslängden. Och slutligen betyder värdeapplikationen att den är tillgänglig för alla sidor som använder samma. Anledningen till att detta attribut behövs är att detgör att en ny instans av objektet skapas om det inte finns något befintligt objekt med sammaoch. Annars används ett redan existerande objekt, och alla elementeller några mellan taggarnaignoreras.beanServletRequestHttpSessionServletContextjsp:useBeanidscopejsp:setParameterjsp:useBean
  • typ  - anger typen av variabeln som refererar till objektet. Måste matcha namnet på klassen, superklassen eller gränssnittet som implementeras. Variabelnamnet anges genom attributetid.
  • beanName  - ger namnetbeansom kommer att användas av metodeninstantiate. Du kan angetypeochbeanNameoch utelämna attributetclass.

action jsp:setProperty

Du kan använda jsp:setPropertyden tidigare beskrivna beans. Du kan göra detta på två sätt. Först kan du använda jsp:setPropertyefter men utanför elementet jsp:useBean, som visas i exemplet: 

< jsp : useBean  id = "myName"  ...  /> 
... 
< jsp : setProperty  name = "myName"  
                 property = "someProperty"  ...  />

I det här fallet jsp:setPropertykörs den oavsett om en befintlig instans hittades beaneller om en ny instans skapades. Ett annat alternativ är att placera jsp:setPropertyi elementets brödtext jsp:useBean, som visas i ett annat exempel: 

< jsp : useBean  id = "myName"  ...  > 
  ... 
  < jsp : setProperty  name = "myName"  
                   property = "someProperty"  ...  /> 
</ jsp : useBean >

Detta jsp:setPropertygörs endast om en ny instans av objektet har skapats, och inte när en befintlig hittas. En åtgärd jsp:setPropertyaccepterar följande fyra attribut:

  • namn  - Detta obligatoriska attribut används för att ställabeanin egenskaperna som kommer att ställas in. Elementetjsp:useBeanmåste föregå användningen av elementetjsp:setProperty.
  • egenskap  – Detta obligatoriska attribut ställer in egenskapen du vill ställa in. Det finns dock ett specialfall: värdet " * " betyder att alla frågeparametrar vars namn matchar egenskapsnamnenbeankommer att skickas till motsvarande egenskapsinställningsmetod.
  • värde  – Det här valfria attributet anger värdet på egenskapen. Strängvärden konverteras automatiskt till numeriska, booleska , booleska , byte , byte , tecken och tecken med standardmetoden förvalueOfmotsvarande klass. Till exempel kommer värdet"true"för fastighetenbooleanellerBooleanatt konverteras med metodenBoolean.valueOfoch värdet "42" för fastighetenintellerIntegerkommer att konverteras med metodenInteger.valueOf. Du kan inte använda värde- och param- attributen samtidigt , men du kan välja att inte använda dem alls. Se beskrivningen av param- attributet nedan.
  • param  - Detta valfria attribut ställer in frågeparametern som används för att hämta egenskapen. Om denna parameter saknas i den aktuella begäran sker ingen åtgärd: systemet skickar inte värdetnulltill metoden som anger egenskaperna. Det är således acceptabelt att användabeanstandardegenskaperna, och åsidosätta dem endast om det krävs av förfrågningsparametrarna. Till exempel betyder följande fragment följande: "ställ in egenskapennumberOfItemsenligt värdet på begäranparameternnumItems, och om det inte finns någon sådan parameter i begäran vidtas ingen åtgärd."
< jsp : setProperty  name = "orderBean" 
                 egenskap = "numberOfItems" 
                 param = "numItems"  />

Om du inte använder varken valueeller paramär det samma sak som om du hade gett ett namn som parammatchar namnet property. Du kan tillämpa den här principen att automatiskt använda förfrågningsegenskaper vars namn matchar egenskapsnamnen och gå längre genom att ställa in egenskapsnamnet till " * " och utelämna parametrarna värde och param . I det här fallet kommer servern att bearbeta de giltiga egenskaperna och frågeparametrarna för att matcha identiska namn. Följande är ett exempel som används beanför att skapa en tabell med primtal. Om en parameter finns numDigitsi begärandedata skickas den till bean numDigits. Likadant för numPrimes. JspPrimes.jsp 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.0 Transitional//EN" > < 
html > < 
head > < 
  title > Återanvända JavaBeans  i JSP < / title > < / head > < body > < h1 > Återanvända  JavaBeans i JSP </ h1 >  


      

  < jsp : useBean  id = "primeTable"  class = "hall.NumberedPrimes"  /> 
  < jsp : setProperty  name = "primeTable"  egenskap = "numDigits"  /> 
  < jsp : setProperty  name = "primeTable"  egenskap = "numPrimes"  />

  < p > 
    Flera  teckenprimtal < jsp : getProperty  name = " primeTable "  property = "numDigits"  />  
    : < jsp : getProperty name = "primeTable" property = " numberedList" /> </ p > </ body > </ html >

jsp:getProperty action

Detta element bestämmer värdet på egenskapen bean, konverterar den till en sträng och skickar den till utgångsströmmen. För att utföra en åtgärd måste två attribut ställas in: namnet bean, som är förinställt i åtgärden jsp:useBean, och namnet på egenskapen vars värde måste bestämmas. Följande är ett exempel på hur du använder den här åtgärden: 

< jsp : useBean  id = "itemBean"  ...  /> 
... 
< UL > 
  < LI > Antal  artiklar :  
      < jsp : getProperty  name = "itemBean"  property = "numItems  " / 
  > < LI > Enhetspris  :  < jsp : getProperty name = "itemBean" property = "unitCost" /> </ UL >

jsp:include action

Den här åtgärden låter dig infoga innehållet i filerna på den skapade sidan. Åtgärdssyntax: 

< jsp : include  page = "relativ URL"  flush = "true"  />

Till skillnad från direktivet include, som infogar en fil under JSP-översättningsstadiet av sidan, infogar denna åtgärd filen när sidan efterfrågas. Detta resulterar i en viss förlust av effektivitet och eliminerar möjligheten för JSP-kod i den inklistrade filen, men det ger en betydande fördel i flexibilitet.

Ett exempel på att infoga innehållet i fyra filer på en JSP-sida: 

<! DOCTYPE  HTML  PUBLIC  "-//W3C//DTD HTML 4.01//EN"  "http://www.w3.org/TR/html4/strict.dtd" > 
< html > 
< head > 
  < title > Nyheter </ title > 
</ head > 
< body > 
  < h1 > Nyheter </ h1 > 
  < p > Här är  utdrag från  våra  fyra  mest  populära  artiklar : </ p > 
  < ol > 
    < li >< jsp : include  page = "news/Item1. html"  flush = "true" /></ li > 
    < li >< jsp : include  page = "news/Item2.html"  flush = "true" /></ li > 
    < li >< jsp : include  page = " news/ Item3.html"  flush = "true" /></ li > 
    < li >< jsp : include  page = "news/Item4.html"  flush = "true" /></ li > 
  </ ol > 
</ body > 
</ html >

jsp:forward action

Den här åtgärden låter dig skicka begäran till en annan statisk HTML-sida, servlet eller JSP-sida. Till skillnad från en åtgärd jsp:includeavslutas behandlingen av den aktuella sidan. Den använder ett attribut page, som måste innehålla en relativ URL , baserat på vilken objektet är beställt request. jsp:paramDu kan lägga till andra parametrar till de ursprungliga frågeparametrarna som skickats till en annan sida med hjälp av en åtgärd . Attributvärdet pagekan antingen vara ett statiskt värde eller ett värde som beräknas under begäran, som visas i följande två exempel: 

< jsp : forward  page = "/utils/errorReporter.jsp"  /> 
< jsp : forward  page = "<%= someJavaExpression %>"  />

Med hjälp av en åtgärd jsp:forwardkan du också överföra kontrollen till en annan sida, men med villkoret att innan du anropade den här åtgärden skrevs ingenting till det utgående buffertminnet (annars kommer ett undantag att kastas IllegalStateException).

jsp:param-åtgärden och jsp:params-åtgärden

Den här åtgärden ger information om namn/värdetyp. Denna åtgärd används huvudsakligen tillsammans med de redan bekanta åtgärderna jsp:includeoch jsp:forward. Dessutom kan den också användas tillsammans med åtgärden jsp:plugin. I andra fall spelar användningen av denna åtgärd ingen roll. Används jsp:parammed åtgärder jsp:includeoch jsp:forwardskickar det ursprungliga objektet till nya sidor request, som kommer att utökas med de nya parametrarna. Om du anger nya värden för redan befintliga parametrar, är det de nya värdena som kommer att ha företräde. Med hjälp av en åtgärd jsp:paramskan du ställa in flera parametrar samtidigt

jsp:plugin-åtgärd

Denna åtgärd låter dig infoga elementet OBJECT eller EMBED (beroende på vilken typ av webbläsare du använder) som krävs för att köra appletar som använder Java-plugin. Med andra ord tjänar den här åtgärden till att generera HTML för att bädda in Java API på JSP-sidan. På samma sätt kan du klistra in URL:en för att ladda ner moduler för Java API från JavaSoft, som ger möjlighet att köra appletar i webbläsaren. Anmälningsformuläret för denna åtgärd ser ut så här: 

< jsp : plugin 
   -typ = "bean|applet" 
   code = "klassfil" 
   codebase = "CodeBase-objekt" 
   align = "plats" 
   archive = "arkivlista" 
   höjd = "höjd" 
   hspace = "horisontellt utrymme" 
   jreversion = "version" 
   name = "komponentnamn" 
   vspace = "vertical space" 
   width = "width" 
   nspluginurl = "url" 
   iepluginurl = "url" > 
   < jsp : params > 
      < jsp : param  name = "name1"  value = "value1"  /> 
      < jsp : param  name = "name2"  value = "value2"  /> 
      ... 
      < jsp : param  name = "nameN"  value = "valueN"  /> 
   </ jsp : params > 
   < jsp : fallback >  </ jsp : fallback > 
</ jsp : plugin >

Låt oss titta på ett exempel på hur den här åtgärden används i appletkoden: 

< jsp : plugin  type = "applet"  code = "Blink.class"  width = 300  höjd = 100 > 
   < jsp : params > 
      < jsp : param  name = lbl  value = "Ja, det är godare än bara skivat bröd! "  /> 
      < jsp : param  name = speed  value = "4"  /> 
   < jsp : params > 
   < jsp : fallback > Din  webbläsare kan  av  någon okänd  anledning  inte  köra denna applet </ fallback > </ jsp : plugin >

Ett exempel på en JSP-sida som använder XML-syntax 

<? xml  version = "1.0"  encoding = "UTF-8" ?> 
< jsp : root  xmlns : jsp = "http://java.sun.com/JSP/Page"  version = "2.0" > 
    < jsp : direktiv . page  contentType = "application/xhtml+xml; charset=UTF-8" /> 
    < jsp : output  doctype - root - element = "html"  doctype - public = "-//W3C//DTD XHTML 1.1//EN" 
        doctype - system = "http://www.w3.org/TR/xhtml11/DTD/xhtml11.dtd"  utelämna - xml - deklaration = "true" /> 
    < html  xmlns = "http://www.w3.org/ 1999/xhtml" > 
    < head > 
    < meta  http - equiv = "Content-Type"  content = "text/html; charset=UTF-8" /> 
    < title > Sidrubrik  < / title > </ head > < body > < h1 > Rubrik </ h1 > < p > Text </ p > < jsp : scriptlet > ut . print ( Calendar . getInstance ( request . getLocale ()). getFirstDayOfWeek () == Kalender . SUNDAY ? "I ditt land börjar veckan på söndag" : "I ditt land börjar veckan inte på söndag" ); </ jsp : scriptlet > </ body > </ html > </ jsp : root >

Se även

Länkar

Källa - https://ru.wikipedia.org/w/index.php?title=JavaServer_Pages&oldid=125787257