Ciclo di vita di JSP

Cos'è il ciclo di vita JSP?

Il ciclo di vita JSP è definito come la traduzione della pagina JSP in servlet poiché una pagina JSP deve essere prima convertita in servlet per elaborare le richieste di servizio. Il ciclo di vita inizia con la creazione di JSP e termina con la sua disintegrazione.

Diverse fasi del ciclo di vita di JSP

Quando il browser richiede una JSP, il motore JSP controlla innanzitutto se è necessario compilare la pagina. Se il JSP viene compilato per ultimo o la modifica recente viene eseguita in JSP, il motore JSP compila la pagina.

Il processo di compilazione della pagina JSP prevede tre passaggi:

Analisi di JSP
Trasformare JSP in servlet
Compilazione della servlet

Diagramma del ciclo di vita di JSP

Il ciclo di vita di JSP è illustrato nel diagramma seguente.

I seguenti passaggi spiegano il ciclo di vita di JSP:

Traduzione della pagina JSP
Compilazione della pagina JSP (Compilazione della pagina JSP in _jsp.java)
Caricamento della classe (_jsp.java viene convertito nel file di classe _jsp.class)
Istanziazione (viene creato l'oggetto del servlet generato)
Inizializzazione(_jspinit() il metodo viene richiamato dal contenitore)
Elaborazione della richiesta (_jspservice() metodo viene richiamato dal contenitore)
Distruggi (_jspDestroy() metodo invocato dal contenitore)

Cerchiamo di avere un riepilogo più dettagliato sui punti di cui sopra:

1) Traduzione della pagina JSP:

A Java il file servlet viene generato da un file sorgente JSP. Questo è il primo passo del ciclo di vita di JSP. Nella fase di traduzione, il contenitore convalida la correttezza sintattica della pagina JSP e dei file di tag.

Il contenitore JSP interpreta le direttive e le azioni standard, nonché le azioni personalizzate che fanno riferimento alle librerie di tag (fanno tutte parte della pagina JSP e saranno trattate nella sezione successiva) utilizzate in questa pagina JSP.
Nella descrizione pittorica sopra, demo.jsp viene tradotto in demo_jsp.java nel primo passaggio
Prendiamo un esempio di "demo.jsp" come mostrato di seguito:

Demo.jsp

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

Spiegazione del codice per Demo.jsp

Linea di codice 1: tag iniziale html

Linea di codice 2: Etichetta di testa

Riga di codice 3 – 4: Tag del titolo, ad esempio JSP demo e tag head di chiusura

Riga di codice 5 – 6: tag scriptlet in cui inizializza la variabile demo

Riga di codice 7 – 8: Nel tag body, un testo da stampare nell'output (il conteggio è: )

Riga di codice 9: Tag scriptlet in cui si tenta di stampare la variabile demovar con valore incrementato

Riga di codice 10 – 11: Tag corpo e HTML chiusi

La pagina JSP demo viene convertita nel servlet demo_jsp nel codice seguente.

Spiegazione del codice per Demo_jsp.java

Linea di codice 1: La classe servlet demo_jsp sta estendendo la classe genitore HttpServlet

Riga di codice 2 – 3: Sovrascrive il metodo di servizio di jsp, ad esempio _jspservice che ha gli oggetti HttpServletRequest e HttpServletResponse come parametri

Linea di codice 4: Metodo di apertura

Linea di codice 5: Chiamata del metodo getWriter() dell'oggetto risposta per ottenere PrintWriterobject (stampa la rappresentazione formattata degli oggetti nel flusso di output del testo)

Linea di codice 6: chiamata al metodo setContentType dell'oggetto risposta per impostare il tipo di contenuto

Linea di codice 7: Utilizzando write() metodo dell'oggetto PrintWriter che tenta di analizzare html

Linea di codice 8: Inizializzazione della variabile demovar su 0

Linea di codice 9: Chiamata write() metodo dell'oggetto PrintWriter per analizzare il testo

Linea di codice 10: Chiamata print() metodo dell'oggetto PrintWriter per incrementare la variabile demovar da 0+1=1. Quindi, l'output sarà 1

Linea di codice 11: Utilizzando write() metodo dell'oggetto PrintWriter che tenta di analizzare html

Produzione:

Qui puoi vedere che nello screenshot theOutput è 1 perché demvar è inizializzato a 0 e quindi incrementato a 0+1=1

Nell'esempio sopra,

demo.jsp, è un JSP in cui una variabile viene inizializzata e incrementata. Questo JSP viene convertito nel servlet (demo_jsp.class) in cui il motore JSP carica la pagina JSP e la converte in contenuto servlet.
Quando avviene la conversione, viene convertito tutto il testo del modello println() dichiarazioni e tutto il resto Elementi JSP vengono convertiti in Java codice.

Ecco come una semplice pagina JSP viene tradotta in una classe servlet.

2) Compilazione della Pagina JSP

Il file servlet Java generato viene compilato nella classe servlet Java
La traduzione della pagina sorgente Java nella sua classe di implementazione può avvenire in qualsiasi momento tra la distribuzione della pagina JSP nel contenitore e l'elaborazione della pagina JSP.
Nella descrizione pittorica sopra demo_jsp.java è compilato in un file di classe demo_jsp.class

3) Caricamento delle classi

La classe servlet che è stata caricata dall'origine JSP viene ora caricata nel contenitore

4) Istanziazione

In questo passaggio viene generato l'oggetto, ovvero l'istanza della classe.
Il contenitore gestisce una o più istanze di questa classe nella risposta a richieste e altri eventi. In genere, un contenitore JSP viene creato utilizzando un contenitore servlet. Un contenitore JSP è un'estensione del contenitore servlet poiché sia il contenitore supporta JSP che il servlet.
Fornisce un'interfaccia JSPPage fornita dal contenitore init() e di destroy() metodi.
Esiste un'interfaccia HttpJSPPage che serve le richieste HTTP e contiene anche il metodo del servizio.

5) Inizializzazione

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

_jspinit() Il metodo avvierà l'istanza del servlet che è stata generata da JSP e verrà richiamato dal contenitore in questa fase.
Una volta creata l'istanza, il metodo init verrà richiamato immediatamente
Viene chiamato solo una volta durante il ciclo di vita della JSP, il metodo per l'inizializzazione è dichiarato come mostrato sopra

6) Elaborazione della richiesta

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

_jspservice() Il metodo viene invocato dal contenitore per tutte le richieste sollevate dalla pagina JSP durante il suo ciclo di vita
Per questa fase, è necessario passare attraverso tutte le fasi precedenti e quindi è possibile richiamare solo il metodo di servizio.
Passa oggetti di richiesta e risposta
Questo metodo non può essere sovrascritto
Il metodo è mostrato sopra: è responsabile della generazione di tutti i metodi HTTP, ad esempio GET, POST, ecc.

7) Distruggi

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

_jspdestroy() Il metodo viene richiamato anche dal contenitore
Questo metodo viene chiamato quando il contenitore decide di non aver più bisogno dell'istanza del servlet per soddisfare le richieste.
Quando viene effettuata la chiamata al metodo destroy, la servlet è pronta per la garbage collection
Questa è la fine del ciclo di vita.
Possiamo sovrascrivere jspdestroy() metodo quando eseguiamo qualsiasi pulizia come il rilascio delle connessioni al database o la chiusura dei file aperti.

Potrebbe piacerti: