JSP-levenscyclus: Fasen en diagram uitgelegd

Wat is de JSP-levenscyclus?

JSP-levenscyclus Een servlet wordt gedefinieerd als de vertaling van een JSP-pagina naar een servlet, omdat een JSP-pagina moet worden omgezet in een servlet voordat deze serviceaanvragen kan verwerken. De levenscyclus begint met het aanmaken van de JSP en eindigt met het vernietigen van de daaruit gegenereerde servlet-instantie.

Omdat de gegenereerde klasse een gewone servlet is, is alles wat je al weet over servlets van toepassing.tract is nog steeds van toepassing. De Java De code die de container schrijft, is wat daadwerkelijk wordt uitgevoerd; het JSP-bestand is slechts de broncode die u onderhoudt.

Verschillende fasen van de JSP-levenscyclus

Wanneer de browser een JSP opvraagt, controleert de JSP-engine eerst of de pagina gecompileerd moet worden. Als de JSP nog nooit gecompileerd is, of als deze sinds de laatste compilatie is gewijzigd, compileert de JSP-engine de pagina.

Het compilatieproces van een JSP-pagina omvat drie stappen:

• Parseren van JSP
• JSP omzetten in servlet
• Het compileren van de servlet

JSP-levenscyclusdiagram

De levenscyclus van een JSP wordt weergegeven in het onderstaande diagram, dat traces een enkele pagina van bronbestand tot aan de klasse die de container uitvoert.

De volgende stappen leggen de levenscyclus van JSP uit:

1. Vertaling van JSP-pagina
2. Compilatie van de JSP-pagina (compilatie van de JSP-pagina naar _jsp.java)
3. Classloading (_jsp.java wordt geconverteerd naar het klassebestand _jsp.class)
4. Instantiëring (er wordt een object van de gegenereerde servlet aangemaakt)
5. Initialisatie (de jspInit()-methode wordt aangeroepen door de container)
6. Verzoekverwerking (de methode _jspService() wordt aangeroepen door de container)
7. Vernietigen (de jspDestroy()-methode wordt aangeroepen door de container)

Fasen van de JSP-levenscyclus uitgelegd

Laten we elk van de bovenstaande punten eens nader bekijken.

1) Vertaling van de JSP-pagina:

A Java Een servletbestand wordt gegenereerd vanuit een JSP-bronbestand. Dit is de eerste stap in de levenscyclus van een JSP. In de vertaalfase valideert de container de syntactische correctheid van de JSP-pagina en de tagbestanden.

• De JSP-container interpreteert de standaardrichtlijnen en -acties, en de aangepaste acties die verwijzen naar tagbibliotheken (deze maken allemaal deel uit van de JSP-pagina en worden behandeld in de documentatie). JSP-elementen (handleiding) gebruikt op deze JSP-pagina.
• In de bovenstaande afbeelding wordt demo.jsp in de eerste stap vertaald naar demo_jsp.java.

Laten we een voorbeeld nemen van “demo.jsp”, zoals hieronder weergegeven:

Demo.jsp

<html>
<head>
<title>Demo JSP</title>
</head>
<%
int demvar=0;%>
<body>
Count is:
<% Out.println(demovar++); %>
<body>
</html>

Opmerking bij bovenstaande lijst: Het is exact overgenomen zoals gepubliceerd, zodat het overeenkomt met de gegenereerde servlet-screenshot die volgt. Twee spelfouten erin zorgen ervoor dat het niet compileert als het letterlijk wordt overgenomen — de variabele is gedeclareerd als demvar maar afgedrukt als demovaren het impliciete uitvoerobject is out in kleine letters, niet OutCorrigeer beide voordat je de pagina zelf uitvoert.

Code Uitleg voor Demo.jsp

Code Regel 1: html starttag

Code Regel 2: Koplabel

Code Regel 3 – 4: Titel-tag, bijvoorbeeld Demo JSP, en afsluitende head-tag

Code Regel 5 – 6: Scriptlet-tag waarin de variabele demo wordt geïnitialiseerd

Code Regel 7 – 8: In de body-tag, een tekst die in de uitvoer moet worden afgedrukt (Aantal is: )

Code Regel 9: Scriptlet-tag waarin we proberen de variabele demovar af te drukken met de verhoogde waarde.

Code Regel 10 – 11: Body en HTML-tags gesloten

De demo-JSP-pagina wordt omgezet in de demo_jsp-servlet, zoals weergegeven in de onderstaande code.

Code uitleg voor Demo_jsp.java

Code Regel 1: De Servlet-klasse demo_jsp erft van de ouderklasse HttpServlet.

Code Regel 2-3: De servicemethode van de JSP, oftewel _jspService, overschrijven. Deze methode heeft HttpServletRequest- en HttpServletResponse-objecten als parameters.

Code Regel 4: Openingsmethode

Code Regel 5: De methode get aanroepenWriter() van het responsobject om een ​​afdruk te krijgenWriter object (print een geformatteerde weergave van objecten naar een tekstuitvoerstroom)

Code Regel 6: De methode `setContentType` van het `response`-object aanroepen om het inhoudstype in te stellen.

Code Regel 7: Gebruikmakend van de write()-methode van PrintWriter object om HTML te parsen

Code Regel 8: De variabele demovar wordt geïnitialiseerd naar 0.

Code Regel 9: De write()-methode van Print aanroepenWriter object om de tekst te parseren

Code Regel 10: De print()-methode van de Print aanroepenWriter Het doel is om de variabele demovar te verhogen van 0 + 1 = 1. De uitvoer zal dus 1 zijn.

Code Regel 11: Gebruikmakend van de write()-methode van PrintWriter object om HTML te parsen

Output:

De browser geeft vervolgens de teller weer, zoals de onderstaande schermafbeelding laat zien.

• Zoals je in de schermafbeelding kunt zien, is de uitvoer 1, omdat demvar wordt geïnitialiseerd op 0 en vervolgens wordt verhoogd naar 0 + 1 = 1.

In het bovenstaande voorbeeld,

• demo.jsp is een JSP-pagina waarin één variabele wordt geïnitialiseerd en verhoogd. Deze JSP-pagina wordt omgezet naar een servlet (demo_jsp.class), waarna de JSP-engine de JSP-pagina laadt en omzet naar servletinhoud.
• Tijdens de conversie wordt alle sjabloontekst omgezet in println()-instructies en worden alle JSP-elementen omgezet naar Java code.

Dit is hoe een eenvoudige JSP-pagina wordt vertaald in een servletklasse.

2) Compilatie van de JSP-pagina

• De gegenereerde Java Het servletbestand wordt gecompileerd tot een Java servlet-klasse
• De vertaling van de Java De conversie van de bronpagina naar de implementatieklasse kan op elk moment plaatsvinden tussen het moment dat de JSP-pagina in de container wordt geplaatst en het moment dat de JSP-pagina wordt verwerkt.
• In de bovenstaande afbeelding wordt demo_jsp.java gecompileerd naar een klassebestand demo_jsp.class.
• Op Apache Tomcat worden beide artefacten in de werkmap van de server geschreven, in work/Catalina/localhost/<app>/org/apache/jspDat is de eerste plek waar je moet kijken als er een vertaalfout moet worden vastgesteld.

3) Klassenladen

• De servletklasse die is gegenereerd vanuit de JSP-broncode is nu in de container geladen.

4) Instantiatie

• In deze stap wordt het object, oftewel de instantie van de klasse, gegenereerd.
• De container beheert een of meer instanties van deze klasse als reactie op verzoeken en andere gebeurtenissen. Een JSP-container wordt doorgaans gebouwd met behulp van een servlet-container. Een JSP-container is een uitbreiding van een servlet-container, aangezien beide containers JSP en servlets ondersteunen.
• De JspPage-interface, die door de container wordt geleverd, declareert de methoden jspInit() en jspDestroy().
• Er is een interface HttpJspPage die HTTP-verzoeken afhandelt en die ook de service-methode bevat. De signatuur van deze methode is afhankelijk van het protocol, waardoor de container deze methode genereert in plaats van de pagina-auteur te vragen deze te declareren.

5) Initialisatie

public void jspInit()
{
	//initializing the code
}

• De jspInit()-methode initialiseert het servlet-exemplaar dat is gegenereerd vanuit de JSP en wordt in deze fase door de container aangeroepen.
• Zodra het instantieobject is aangemaakt, wordt de init-methode direct daarna aangeroepen.
• Deze methode wordt slechts één keer aangeroepen tijdens de levenscyclus van een JSP-pagina, en de initialisatiemethode wordt gedeclareerd zoals hierboven weergegeven.

6) Verzoekverwerking

void _jspservice(HttpServletRequest request HttpServletResponse response)
{
	//handling all request and responses
}

• De methode _jspService() wordt door de container aangeroepen voor alle verzoeken die de JSP-pagina tijdens zijn levenscyclus genereert.
• Voor deze fase moet de pagina alle bovenstaande fasen doorlopen, en pas daarna kan de servicemethode worden aangeroepen.
• Het geeft de aanvraag- en antwoordobjecten door.
• Deze methode kan niet worden overschreven, omdat de container deze tijdens de vertaling schrijft.
• De methode wordt hierboven weergegeven. Deze is verantwoordelijk voor het afhandelen van alle HTTP-methoden, zoals GET, POST en de rest.

7) Vernietig

public void _jspdestroy()
{
            //all clean up code
}

• De jspDestroy()-methode wordt ook door de container aangeroepen.
• Deze methode wordt aangeroepen wanneer de container besluit dat de servlet-instantie niet langer nodig is om verzoeken af ​​te handelen.
• Zodra de `destroy`-methode is aangeroepen, is de servlet klaar voor garbage collection.
• Dit is het einde van de levenscyclus.
• We kunnen jspDestroy() overschrijven wanneer we opschoonacties uitvoeren, zoals het vrijgeven van databaseverbindingen of het sluiten van geopende bestanden.

Een belangrijke opmerking over de naamgeving: vanaf Jakarta EE 9 bevinden deze types zich in de jakarta.servlet.jsp verpakking in plaats van javax.servlet.jspDaarom moeten oudere imports worden bijgewerkt wanneer een applicatie naar een andere server wordt verplaatst.

Veelgestelde vragen