JSP-levenscyclus: introductie, fasen, methoden

Wat is JSP-levenscyclus?

JSP-levenscyclus wordt gedefinieerd als de vertaling van een JSP-pagina naar een servlet, aangezien een JSP-pagina eerst moet worden omgezet in een servlet om de serviceaanvragen te kunnen verwerken. De levenscyclus begint met de oprichting van JSP en eindigt met de desintegratie daarvan.

Laten we verschillende fasen van de JSP-levenscyclus leren

Wanneer de browser om een ​​JSP vraagt, controleert de JSP-engine eerst of de pagina moet worden gecompileerd. Als de JSP voor het laatst is gecompileerd of als de recente wijziging in JSP is aangebracht, compileert de JSP-engine de pagina.

Het compilatieproces van de JSP-pagina omvat drie stappen:

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

De JSP-levenscyclus wordt weergegeven in het onderstaande diagram.

JSP-levenscyclus

Following stappen verklaren de JSP-levenscyclus:

  1. Vertaling van JSP-pagina
  2. Compilatie van JSP-pagina (compilatie van JSP-pagina in _jsp.java)
  3. Classloading (_jsp.java wordt geconverteerd naar klassenbestand _jsp.class)
  4. Instantiatie (object van gegenereerde servlet is gemaakt)
  5. Initialisatie(_jspinit() methode wordt aangeroepen door container)
  6. Request Processing(_jspservice() methode wordt aangeroepen door de container)
  7. Destroy (_jspDestroy() methode aangeroepen door de container)

Laten we een meer gedetailleerd overzicht krijgen van de bovenstaande punten:

  1. Vertaling van de JSP-pagina:

A Java servlet-bestand wordt gegenereerd op basis van een JSP-bronbestand. Dit is de eerste stap van de JSP-levenscyclus. In de vertaalfase valideert de container de syntactische correctheid van JSP-pagina- en tagbestanden.

  • De JSP-container interpreteert de standaardrichtlijnen en -acties, en de aangepaste acties die verwijzen naar tagbibliotheken (ze maken allemaal deel uit van de JSP-pagina en worden besproken in de later sectie) gebruikt op deze JSP-pagina.
  • In de bovenstaande afbeeldingsbeschrijving 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>

Codeverklaring voor Demo.jsp

Coderegel 1: html-starttag

Coderegel 2: Hoofdtag

Coderegel 3 – 4: Titeltag, dwz demo-JSP en afsluitende head-tag

Coderegel 5,6: Scriptlet-tag waarin de variabele demo wordt geïnitialiseerd

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

Coderegel 9: Scriplet-tag waarbij wordt geprobeerd de variabele demovar met verhoogde waarde af te drukken

Coderegel 10-11: Body- en HTML-tags gesloten

Demo JSP-pagina wordt in de onderstaande code omgezet in demo_jsp-servlet.

JSP-levenscyclus

Code-uitleg voor Demo_jsp.java

Coderegel 1: Servlet-klasse demo_jsp breidt de bovenliggende klasse HttpServlet uit

Coderegel 2,3: Overschrijven van de servicemethode van jsp, dwz _jspservice die HttpServletRequest- en HttpServletResponse-objecten als parameters heeft

Coderegel 4: Openingsmethode

Coderegel 5: Aanroepen van de methode getWriter() van het responsobject om PrintWriterobject op te halen (drukt een opgemaakte representatie van objecten af ​​naar de tekstuitvoerstroom)

Coderegel 6: Roep de setContentType-methode van het antwoordobject aan om het inhoudstype in te stellen

Coderegel 7: Met behulp van de schrijfmethode () van het PrintWriter-object probeert HTML te parseren

Coderegel 8: Initialisatie van de demovar-variabele naar 0

Coderegel 9: Aanroepen van de write()-methode van het PrintWriter-object om de tekst te parseren

Coderegel 10: Aanroepen van de print()-methode van het PrintWriter-object om de variabele demovar te verhogen van 0+1=1. Daarom is de uitvoer 1

Coderegel 11: Met behulp van de write()-methode van het PrintWriter-object probeert HTML te parseren

Output:

JSP-levenscyclus

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

In het bovenstaande voorbeeld,

  • demo.jsp, is een JSP waarbij één variabele wordt geïnitialiseerd en verhoogd. Deze JSP wordt geconverteerd naar de servlet (demo_jsp.class ) waarin de JSP-engine de JSP-pagina laadt en converteert naar servlet-inhoud.
  • Wanneer de conversie plaatsvindt, wordt alle sjabloontekst geconverteerd naar println()-instructies en zo JSP-elementen worden omgezet naar Java-code.

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

  1. Compilatie van de JSP-pagina
  • Het gegenereerde Java-servletbestand wordt gecompileerd in de Java-servletklasse
  • De vertaling van de Java-bronpagina naar de implementatieklasse ervan kan op elk moment plaatsvinden tussen de implementatie van de JSP-pagina in de container en de verwerking van de JSP-pagina.
  • In de bovenstaande afbeeldingsbeschrijving is demo_jsp.java gecompileerd naar een klassenbestand demo_jsp.class
  1. Klassen laden
  • De servletklasse die vanuit de JSP-bron is geladen, wordt nu in de container geladen
  1. Instantie
  • In deze stap wordt het object, dwz de instantie van de klasse, gegenereerd.
  • De container beheert een of meer exemplaren van deze klasse in het antwoord op verzoeken en andere gebeurtenissen. Normaal gesproken wordt een JSP-container gebouwd met behulp van een servletcontainer. Een JSP-container is een uitbreiding van de servlet-container, aangezien zowel de container JSP als servlet ondersteunt.
  • Een JSPPage-interface die door een container wordt geleverd, biedt de methoden init() en destroy ().
  • Er is een interface HttpJSPPage die HTTP-verzoeken verwerkt, en deze bevat ook de servicemethode.
  1. initialisatie
    public void jspInit()
    {
    	//initializing the code
    }
  • De methode _jspinit() initieert de servletinstantie die is gegenereerd vanuit JSP en die in deze fase door de container zal worden aangeroepen.
  • Zodra de instantie is gemaakt, wordt de methode init onmiddellijk daarna aangeroepen
  • Het wordt slechts één keer aangeroepen tijdens een JSP-levenscyclus; de initialisatiemethode wordt gedeclareerd zoals hierboven weergegeven
  1. Verzoekverwerking
    void _jspservice(HttpServletRequest request HttpServletResponse response)
    {
    	//handling all request and responses
    }
  • De methode _jspservice() wordt door de container aangeroepen voor alle verzoeken die door de JSP-pagina worden ingediend tijdens de levenscyclus ervan
  • Voor deze fase moet het alle bovenstaande fasen doorlopen en dan kan alleen de servicemethode worden aangeroepen.
  • Het geeft verzoek- en antwoordobjecten door
  • Deze methode kan niet worden overschreven
  • De methode wordt hierboven weergegeven: deze is verantwoordelijk voor het genereren van alle HTTP-methoden, d.w.z. eGET, POST, enz.
  1. Vernietigen
    public void _jspdestroy()
    {
                //all clean up code
    }
  • De methode _jspdestroy() wordt ook aangeroepen door de container
  • Deze methode wordt aangeroepen wanneer de container besluit dat hij de servletinstantie niet langer nodig heeft om verzoeken af ​​te handelen.
  • Wanneer vervolgens de aanroep van de destroy-methode wordt gedaan, is de servlet klaar voor een garbagecollection
  • Dit is het einde van de levenscyclus.
  • We kunnen de methode jspdestroy() overschrijven wanneer we opschoningen uitvoeren, zoals het vrijgeven van databaseverbindingen of het sluiten van geopende bestanden.