Gids voor JavaServer Pages (JSP)

Inhoudsopgave

  • 1. Overzicht
  • 2. JavaServer-pagina's
  • 2.1. JSP-syntaxis
  • 2.2. Statische en dynamische inhoud
  • 2.3. Impliciete objecten
  • 2.4. Andere impliciete objecten
  • 2.5. Richtlijnen
  • 2.6. Paginarichtlijnen
  • 3.0. Drie voorbeelden
  • 3.1. HTML weergegeven in Servlet
  • 3.2. Java in een JSP statische inhoud
  • 3.3. JSP met doorsturen
  • 3.4. Probeer het!
  • 4. Conclusie

1. Overzicht

JavaServer Pages (JSP) staat toe dynamisch inhoud injectie in statisch inhoud met behulp van Java en Java Servlets. We kunnen verzoeken doen aan een Java-servlet, voer relevante logica uit en geef een specifieke weergave aan de serverzijde om aan de clientzijde te worden gebruikt. Dit artikel geeft een grondig overzicht van JavaServer Pages met Java 8 en Jave 7 EE.

We beginnen met het onderzoeken van enkele sleutelconcepten die relevant zijn voor JSP: namelijk het verschil tussen dynamisch en statisch inhoud, de JSP-levenscyclus en JSP-syntaxis, evenals richtlijnen en de impliciete objecten die bij compilatie zijn gemaakt!

2. JavaServer-pagina's

Met JavaServer Pages (JSP) konden Java-specifieke gegevens worden doorgegeven aan of geplaatst in een .jsp-weergave en verbruikte client-side.

JSP-bestanden zijn in wezen .html-bestanden met wat extra syntaxis, en een paar kleine initiële verschillen:

  1. de .html achtervoegsel wordt vervangen door .jsp (het wordt beschouwd als een .jsp-bestandstype) en
  2. de volgende tag wordt toegevoegd aan de bovenkant van de .html-opmaakelementen:

Laten we enkele van de belangrijkste concepten in JSP eens bekijken.

2.1. JSP-syntaxis

Er zijn twee manieren om Java-code toe te voegen aan een .jsp. Ten eerste kunnen we de standaard Java Scriptlet-syntaxis gebruiken, wat inhoudt dat we Java-codeblokken binnen twee Scriptlet-tags plaatsen:

<% Java code here %>

De tweede methode is specifiek voor XML:

 Java-code hier 

Belangrijk is dat men voorwaardelijke logica clientside met JSP kan gebruiken door gebruik te maken van als, dan, en anders clausules en vervolgens de relevante blokken met markeringen omwikkelen met die haakjes.

 Doodad! 

Hallo!

Als doodad is waar, we zouden de eerste weergeven, div element anders zouden we de tweede weergeven, p element!

2.2. Statisch en Dynamisch Inhoud

Statisch webinhoud zijn vaste activa die onafhankelijk van RESTful-, SOAP-, HTTP-, HTTPS-verzoeken of andere door de gebruiker ingediende informatie worden geconsumeerd.

Statisch inhoud staat echter vast en wordt niet gewijzigd door gebruikersinvoer. Dynamisch webinhoud zijn die activa die reageren op, worden gewijzigd door of veranderen in het licht van gebruikersacties of informatie!

JSP-technologie zorgt voor een zuivere scheiding van verantwoordelijkheden tussen dynamisch en statisch inhoud.

De server (servlet) beheert het dynamisch inhoud en de client (de eigenlijke .jsp-pagina) is de statisch context waarin dynamische inhoud wordt geïnjecteerd.

Laten we eens kijken naar de impliciete objecten die zijn gemaakt door JSP en waarmee u toegang hebt tot JSP-relevante gegevens server-side!

2.3. Impliciete objecten

Impliciete objecten worden automatisch gegenereerd door de JSP-engine tijdens compilatie.

Impliciete objecten omvatten de HttpRequest en HttpResponse objecten en stellen verschillende serverfunctionaliteiten bloot voor gebruik in uw servlet en voor interactie met uw .jsp! Hier is de lijst met impliciete objecten die zijn gemaakt:

verzoek

verzoek behoort tot de klas javax.servlet.http.HttpServletRequest. De verzoek object stelt alle gegevens van gebruikersinvoer bloot en stelt deze beschikbaar op de server.

reactie

reactie behoort tot de klas javax.servlet.http.HttpServletResponse en bepaalt wat er aan de klant wordt doorgegeven na een verzoek is gemaakt.

Laten we de verzoek en reactie impliciete objecten, aangezien dit de belangrijkste en meest gebruikte objecten zijn.

Het onderstaande voorbeeld toont een zeer eenvoudige, onvolledige servlet-methode om GET-verzoeken af ​​te handelen. Ik heb de meeste details weggelaten, zodat we ons kunnen concentreren op het gebruik van de verzoek en reactie voorwerpen:

protected void doGet (HttpServletRequest-verzoek, HttpServletResponse-antwoord) gooit ServletException, IOException {String message = request.getParameter ("bericht"); response.setContentType ("text / html"); . . . }

Ten eerste zien we dat de verzoek en reactie objecten worden als parameters doorgegeven aan de methode waardoor ze beschikbaar zijn binnen de scope.

We hebben toegang tot verzoekparameters met behulp van de .getParameter () functie. Hierboven haken we de bericht parameter en initialiseer een stringvariabele zodat we deze kunnen gebruiken in onze server-side logica. We hebben ook toegang tot het reactie object dat bepaalt wat en hoe de gegevens die aan de weergave worden doorgegeven, zullen zijn.

Hierboven zetten we het inhoudstype erop. We hoeven het reactie object om zijn payload weer te geven op de JSP-pagina bij render!

uit

uit behoort tot de klas javax.servlet.jsp.JspWriter en wordt gebruikt om inhoud naar de klant te schrijven.

Er zijn minstens twee manieren om af te drukken naar uw JSP-pagina en het is de moeite waard om beide hier te bespreken. uit wordt automatisch gemaakt en stelt u in staat om naar het geheugen en vervolgens naar het reactie voorwerp:

out.print ("hallo"); out.println ("wereld");

Dat is het!

De tweede benadering kan performanter zijn omdat u hiermee rechtstreeks naar het reactie voorwerp! Hier gebruiken we PrintWriter:

PrintWriter uit = response.getWriter (); out.println ("Hallo wereld");

2.4. Andere impliciete objecten

Hier zijn er nog een paar Impliciete objecten die ook goed zijn om te weten!

sessie

sessie behoort tot de klas javax.servlet.http.HttpSession bewaart gebruikersgegevens voor de duur van de sessie.

toepassing

toepassing behoort tot de klas javax.servlet.ServletContext slaat applicatiebrede parameters op die bij initialisatie zijn ingesteld of die applicatiebreed moeten worden benaderd.

uitzondering

uitzondering behoort tot de klas javax.servlet.jsp.JspException wordt gebruikt om foutmeldingen weer te geven op JSP-pagina's die de tag hebben .

bladzijde

bladzijde behoort tot de klas java.lang.Object geeft toegang tot of verwijzing naar huidige servlet-informatie.

pageContext

pageContext behoort tot de klas javax.servlet.jsp.PageContext standaard ingesteld op bladzijde scope maar kan worden gebruikt voor toegang verzoek, toepassing, en sessie attributen.

config

config behoort tot de klas javax.servlet.ServletConfig is het servlet-configuratieobject waarmee de servlet-context, naam en configuratieparameters kunnen worden opgehaald.

Nu we de impliciete objecten geleverd door JSP, laten we kijken naar richtlijnen waarmee .jsp-pagina's (indirect) toegang hebben tot sommige van deze objecten.

2.5. Richtlijnen

JSP levert kant-en-klare richtlijnen die kunnen worden gebruikt om kernfunctionaliteiten voor onze JSP-bestanden te specificeren. JSP-richtlijnen bestaan ​​uit twee delen: (1) de richtlijn zelf en (2) het attribuut van die richtlijn waaraan een waarde wordt toegekend.

De drie soorten richtlijnen waarnaar kan worden verwezen met behulp van directietags zijn die afhankelijkheden en attributen van de JSP definieert, inclusief inhoudstype en taal, die een te gebruiken import of bestand specificeert, en die een tagbibliotheek specificeert die aangepaste acties definieert die door een pagina moeten worden gebruikt.

Dus als voorbeeld zou een pagina-instructie op de volgende manier worden gespecificeerd met behulp van JSP-tags:

En we kunnen dat als volgt doen met XML:

2.6. Attributen paginarichtlijn

Er zijn veel attributen die binnen een pagina-instructie kunnen worden gedeclareerd:

autoFlush

autoFlush regelt de bufferuitvoer en verwijdert deze wanneer de buffergrootte is bereikt. De standaardwaarde is waar.

buffer

buffer stelt de grootte van de buffer in die door onze JSP-pagina wordt gebruikt. De standaardwaarde is 8kb.

errorPage

errorPage specificeert een JSP-pagina als een foutpagina.

strekt zich uit

strekt zich uit specificeert de superklasse van de corresponderende servletcode.

info

info wordt gebruikt om een ​​op tekst gebaseerde beschrijving voor de JSP in te stellen.

wordt genegeerd

wordt genegeerd geeft aan of de pagina al dan niet negeert Expressie taal (EL) in JSP. EL stelt de presentatielaag in staat te communiceren met door Java beheerde bonen en doet dit met behulp van ${…} syntaxis en hoewel we hier niet zullen ingaan op de details van EL, zijn er hieronder verschillende voorbeelden te vinden die voldoende zijn om onze voorbeeld-JSP-app te bouwen! De standaardwaarde voor wordt genegeerd is false.

isErrorPage

isErrorPage geeft aan of een pagina al dan niet een foutpagina is. We moeten een foutpagina specificeren als we een fout-handler voor onze pagina binnen de applicatie maken.

isThreadSafe

isThreadSafe heeft een standaardwaarde van waar. isThreadSafe bepaalt of de JSP Servlet-multi-threading kan gebruiken. Over het algemeen zou je dat nooit willen

om die functionaliteit uit te schakelen.

taal

taal bepaalt welke scripttaal moet worden gebruikt in de JSP. De standaardwaarde is Java.

sessie

sessie bepaalt of de HTTP-sessie moet worden onderhouden. Het is standaard true en accepteert waarden van waar of false.

trimDirectiveWhitespaces

trimDirectiveWhitespaces strepen witruimtes in de JSP-pagina weg en verdicht de code in een compacter blok tijdens het compileren. Stel deze waarde in op waar kan helpen om de grootte van de JSP-code te verkleinen. De standaardwaarde is false.

3. Drie voorbeelden

Nu we de concepten hebben besproken die centraal staan ​​in JSP, gaan we die concepten toepassen op enkele basisvoorbeelden die u zullen helpen om uw eerste JSP-dienende servlet in gebruik te nemen!

Er zijn drie belangrijke manieren om Java in een .jsp te injecteren en we zullen elk van deze manieren hieronder onderzoeken met behulp van native functionaliteiten in Java 8 en Jakarta EE.

Eerst maken we onze markup server-side zodat deze client-side wordt weergegeven. Ten tweede zullen we bekijken hoe we Java-code rechtstreeks in ons .jsp-bestand kunnen toevoegen, onafhankelijk van javax.servlet.http‘S verzoek en reactie voorwerpen.

Ten derde laten we zien hoe u een HttpServletRequest naar een specifieke .jsp en bind aan de serverzijde verwerkte Java.

Laten we ons project opzetten in Eclipse met behulp van de Bestand / Nieuw / Project / Web / Dynamisch webproject / type om te worden gehost in Tomcat! U zou moeten zien na het maken van het project:

| -project | - WebContent | - META-INF | - MANIFEST.MF | - WEB-INF | - lib | - src

We gaan een paar bestanden aan de applicatiestructuur toevoegen, zodat we eindigen met:

| -project | - WebContent | - META-INF | - MANIFEST.MF | - WEB-INF | -lib * -web.xml | - ExampleTree.jsp | - ExampleTwo.jsp * - index.jsp | - src | - com | - baeldung * - ExampleOne.java * - ExampleThree.java

Laten we beginnen index.jsp die wordt weergegeven wanneer we toegang krijgen tot de URL-context in Tomcat 8:

   JSP-voorbeelden 

Roep HTML op die wordt weergegeven door Servlet: hier

Java op statische pagina: hier

Java geïnjecteerd door Servlet: hier

Er zijn er drie een, elk gekoppeld aan een van de voorbeelden die we hieronder in secties 4.1 tot en met 4.4 zullen bespreken.

We moeten er ook voor zorgen dat we de onze hebben web.xml opgericht:

 index.html index.htm index.jsp VoorbeeldEen com.baeldung.VoorbeeldEen VoorbeeldEen / VoorbeeldEen 

Een belangrijke opmerking hier is - hoe we elk van onze servlets correct kunnen toewijzen aan een bepaalde servlet-mapping. Door dit te doen, wordt elke servlet geassocieerd met een specifiek eindpunt waar het kan worden geconsumeerd! Nu gaan we door elk van de andere bestanden hieronder!

3.1. HTML weergegeven in Servlet

In dit voorbeeld slaan we het bouwen van een .jsp-bestand over!

In plaats daarvan maken we een tekenreeksweergave van onze opmaak en schrijven we deze vervolgens naar het GET-antwoord met PrintWriter nadat VoorbeeldOne Servlet een GET-verzoek ontvangt:

public class ExampleOne breidt HttpServlet {@Override protected void doGet (HttpServletRequest request, HttpServletResponse response) uit met ServletException, IOException {response.setContentType ("text / html"); PrintWriter uit = response.getWriter (); out.println ("" + "" + "" + "HTML weergegeven door Servlet" + "" + "" + "
" + "

Deze pagina is gemaakt door de ExampleOne Servlet!

" + "" + "" ); } }

Wat we hier doen, is onze markup rechtstreeks injecteren via onze servletverzoekafhandeling. In plaats van een JSP-tag genereren we onze HTML, samen met alle Java-specifieke gegevens die moeten worden ingevoegd, puur server-side zonder een statische JSP!

Eerder hebben we het uit object dat een kenmerk is van JspWriter.

Hierboven heb ik de PrintWriter object in plaats dat rechtstreeks naar het reactie voorwerp.

JspWriter buffert feitelijk de tekenreeks die in het geheugen moet worden geschreven, die vervolgens naar de reactie objecten nadat de buffer in het geheugen is leeggemaakt.

PrintWriter is al aan de reactie voorwerp. Ik heb liever rechtstreeks naar het reactie bezwaar maken in de voorbeelden hierboven en hieronder om die redenen.

3.2. Java in een JSP statische inhoud

Hier maken we een JSP-bestand met de naam VoorbeeldTwo.jsp met een JSP-tag. Zoals hierboven te zien is, kan Java hierdoor rechtstreeks aan onze opmaak worden toegevoegd. Hier drukken we willekeurig een element van een Draad[]:

   Java in statisch pagina-voorbeeld 

Hierboven ziet u die variabele declaratie binnen JSP-tagsobjecten: typevariabeleName en een initialisatie net als gewone Java.

Ik heb het bovenstaande voorbeeld toegevoegd om te demonstreren hoe u Java aan een statische pagina kunt toevoegen zonder een beroep te doen op een specifieke servlet. Hier wordt Java gewoon aan een pagina toegevoegd en de JSP-levenscyclus zorgt voor de rest.

3.3. JSP met doorsturen

Nu, voor ons laatste en meest betrokken voorbeeld! Hier gaan we de @WebServlet annotatie op ExampleThree waardoor de noodzaak voor servlet-toewijzingen in server.xml.

@WebServlet (name = "ExampleThree", description = "JSP Servlet With Annotations", urlPatterns = {"/ ExampleThree"}) openbare klasse ExampleThree breidt HttpServlet uit {@Override protected void doGet (HttpServletRequest-verzoek, HttpServletRespception {antwoord) gooit IO ServletException {antwoord) String message = request.getParameter ("bericht"); request.setAttribute ("tekst", bericht); request.getRequestDispatcher ("/ ExampleThree.jsp"). doorsturen (verzoek, antwoord); }}

VoorbeeldThree neemt een URL-parameter die is doorgegeven als bericht, bindt die parameter aan de verzoek object, en leidt dat vervolgens om verzoek bezwaar maken tegen VoorbeeldThree.jsp.

We hebben dus niet alleen een echt bereikt dynamisch web ervaring, maar we hebben dit ook gedaan binnen een applicatie die meerdere .jsp-bestanden bevat.

getRequestDispatcher (). vooruit () is een eenvoudige manier om ervoor te zorgen dat de juiste .jsp-pagina wordt weergegeven.

Alle gegevens die zijn gekoppeld aan het verzoek object dat op zijn (het .jsp-bestand) manier is verzonden, wordt dan weergegeven! Hier is hoe we omgaan met dat laatste deel:

   Voorbeeld van Java-binding 

Je zei: $ {text}

Let op de JSP-tag die aan de bovenkant van VoorbeeldThree.jsp. Je zult merken dat ik de JSP-tags hier heb verwisseld. Ik gebruik Expression Language (die ik eerder heb genoemd) om onze ingestelde parameter weer te geven (die gebonden is als $ {tekst})!

3.4. Probeer het!

Nu gaan we onze applicatie exporteren naar een .war om te worden gestart en gehost in Tomcat 8! Vind je server.xml en we zullen ons updaten Context naar:

Dat geeft ons toegang tot onze servlets en JSP's op localhost: 8080 / spring-mvc-xml / jsp / index.jsp! Haal een werkkopie op via: GitHub. Proficiat!

4. Conclusie

We hebben behoorlijk wat terrein afgelegd! We hebben geleerd wat JavaServer Pages is, wat ze zijn geïntroduceerd om te bereiken, hun levenscyclus, hoe ze te maken en tot slot een paar verschillende manieren om ze te implementeren!

Hiermee is de introductie van JSP afgerond! Wees gezond en codeer!