Životní cyklus JSP: Vysvětlení fází a diagramu

⚡ Chytré shrnutí

Životní cyklus JSP popisuje, jak kontejner převede stránku do servletu, zkompiluje ji, načte třídu, vytvoří instanci, inicializuje ji, obslouží každý požadavek prostřednictvím vygenerované metody služby a nakonec ji zničí.

🔄 Sedm fází: Překlad, kompilace, načítání tříd, vytváření instancí, inicializace, zpracování požadavků a skartace probíhají v tomto pevně stanoveném pořadí.
📄 Překlad: Kontejner ověří stránku a poté zapíše Java zdrojový soubor, takže demo.js se před spuštěním čehokoli změní na demo_jsp.java.
⚙️ Sestavení: Takto vygenerovaný zdrojový kód se zkompiluje do souboru demo_jsp.class, který Tomcat uchovává ve svém pracovním adresáři vedle souboru .java.
???? Tři metody: jspInit() připraví stránku jednou, _jspService() odpoví na každý požadavek a jspDestroy() uvolní zdroje na konci.
🚫 Jedno pravidlo: Funkce _jspService() je generována kontejnerem a autor stránky ji nikdy nesmí zapsat ani přepsat.
🗃️ Čisticí hák: Přepsání jspDestroy() je správné místo pro uzavření databázových připojení a otevření souborů.

Přečíst více

Co je životní cyklus JSP?

Životní cyklus JSP je definován jako překlad JSP stránky do servletu, protože JSP stránka musí být převedena na servlet, než může zpracovávat požadavky na služby. Životní cyklus začíná vytvořením JSP a končí zničením instance servletu, která z něj byla vygenerována.

Protože vygenerovaná třída je obyčejný servlet, vše, co o servletu již víte, může...tracStále platí. Java Kód, který kontejner zapisuje, je to, co se skutečně spustí; soubor JSP je pouze zdrojový kód, který udržujete.

Různé fáze životního cyklu JSP

Když prohlížeč požádá o JSP, JSP engine nejprve zkontroluje, zda je potřeba stránku zkompilovat. Pokud JSP nebyl nikdy zkompilován nebo pokud byl od poslední kompilace upraven, pak JSP engine stránku zkompiluje.

Proces kompilace JSP stránky zahrnuje tři kroky:

Analýza JSP
Přeměna JSP na servlet
Kompilace servletu

Diagram životního cyklu JSP

Životní cyklus JSP je znázorněn na níže uvedeném diagramu, který traces jednu stránku ze zdrojového souboru až po třídu, kterou kontejner spouští.

Následující kroky vysvětlují životní cyklus JSP:

Překlad stránky JSP
Kompilace JSP stránky (kompilace JSP stránky do _jsp.java)
Načítání tříd (soubor _jsp.java se převede na soubor třídy _jsp.class)
Instance (vytvoří se objekt vygenerovaného servletu)
Inicializace (kontejner volá metodu jspInit())
Zpracování požadavku (kontejner volá metodu _jspService())
Zničit (kontejner volá metodu jspDestroy())

Vysvětlení fází životního cyklu JSP

Pojďme se na každý z výše uvedených bodů podívat podrobněji.

1) Překlad stránky JSP:

A Java Soubor servletu je generován ze zdrojového souboru JSP. Toto je první krok životního cyklu JSP. Ve fázi překladu kontejner ověřuje syntaktickou správnost souborů stránek a tagů JSP.

Kontejner JSP interpretuje standardní direktivy a akce a vlastní akce odkazující na knihovny tagů (všechny jsou součástí stránky JSP a jsou popsány v prvky JSP tutoriál) použitý na této stránce JSP.
Ve výše uvedeném obrazovém popisu je v prvním kroku soubor demo.jsp přeložen na soubor demo_jsp.java.

Vezměme si příklad „demo.jsp“, jak je znázorněno níže:

Demo.jsp

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

Poznámka k výše uvedenému seznamu: Je reprodukován přesně tak, jak je publikován, aby odpovídal následujícímu vygenerovanému snímku obrazovky servletu. Dva pravopisy v něm se při doslovném zkopírování nezkompilují – proměnná je deklarována jako demvar ale vytištěno jako demovara implicitní výstupní objekt je out malými písmeny, ne OutPřed vlastním spuštěním stránky opravte obojí.

Code Vysvětlení pro Demo.js

Code Řádek 1: počáteční tag html

Code Řádek 2: Štítek záhlaví

Code Řádek 3 – 4: Tag Title, např. Demo JSP, a uzavírací tag head

Code Řádek 5 – 6: Tag skriptletu, ve kterém je inicializována proměnná demo

Code Řádek 7 – 8: V tagu body text, který se má vypsat na výstupu (počet je: )

Code Řádek 9: Tag skriptletu, kde se pokoušíme vypsat proměnnou demovar s její zvýšenou hodnotou

Code Řádek 10 – 11: Tělo a HTML tagy uzavřeny

Demo JSP stránka je převedena na servlet demo_jsp, jak je znázorněno v níže uvedeném kódu.

Code vysvětlení pro Demo_jsp.java

Code Řádek 1: Třída servletu demo_jsp rozšiřuje nadřazenou třídu HttpServlet.

Code Řádek 2 – 3: Přepsání metody služby JSP, tj. _jspService, která má jako parametry objekty HttpServletRequest a HttpServletResponse

Code Řádek 4: Způsob otevírání

Code Řádek 5: Volání metody getWriter() objektu response pro získání PrintWriter objekt (vypíše formátovanou reprezentaci objektů do textového výstupního proudu)

Code Řádek 6: Volání metody setContentType objektu response pro nastavení typu obsahu

Code Řádek 7: Použití metody write() funkce PrintWriter objekt pro analýzu html

Code Řádek 8: Inicializace proměnné demovar na 0

Code Řádek 9: Volání metody write() metody PrintWriter objekt pro analýzu textu

Code Řádek 10: Volání metody print() metody PrintWriter objekt pro inkrementaci proměnné demovar od 0 + 1 = 1. Výstup tedy bude 1

Code Řádek 11: Použití metody write() funkce PrintWriter objekt pro analýzu html

Výstup:

Prohlížeč poté vykreslí počítadlo, jak ukazuje snímek obrazovky níže.

Zde vidíte, že na snímku obrazovky je výstup 1, protože demvar je inicializován na 0 a poté inkrementován na 0 + 1 = 1.

Ve výše uvedeném příkladu

demo.jsp je JSP, kde je jedna proměnná inicializována a inkrementována. Tato JSP je převedena na servlet (demo_jsp.class), kde JSP engine načte stránku JSP a převede ji na obsah servletu.
Když dojde k převodu, veškerý text šablony se převede na příkazy println() a všechny prvky JSP se převedou na Java kód.

Takto je jednoduchá stránka JSP přeložena do třídy servletů.

2) Sestavení stránky JSP

Vygenerované Java servletový soubor je zkompilován do Java třída servletu
Překlad Java K převodu zdrojové stránky do její implementační třídy může dojít kdykoli mezi nasazením JSP stránky do kontejneru a zpracováním JSP stránky.
V obrazovém popisu výše je soubor demo_jsp.java zkompilován do souboru třídy demo_jsp.class.
Na Apache Tomcat jsou oba artefakty zapsány v pracovním adresáři serveru, tj. work/Catalina/localhost/<app>/org/apache/jsp, což je první místo, kam se obrátit, když je třeba diagnostikovat chybu v překladu

3) Načítání třídy

Třída servletu, která byla vygenerována ze zdrojového kódu JSP, je nyní načtena do kontejneru.

4) Instanciace

V tomto kroku se vygeneruje objekt, tj. instance třídy.
Kontejner spravuje jednu nebo více instancí této třídy v reakci na požadavky a další události. JSP kontejner je obvykle sestaven pomocí servletového kontejneru. JSP kontejner je rozšířením servletového kontejneru, protože oba kontejnery podporují JSP i servlety.
Rozhraní JspPage, které je poskytováno kontejnerem, deklaruje metody jspInit() a jspDestroy().
Existuje rozhraní HttpJspPage, které obsluhuje HTTP požadavky a obsahuje také metodu service. Jeho signatura závisí na protokolu, a proto kontejner tuto metodu generuje, místo aby žádal autora stránky o její deklaraci.

5) Inicializace

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

Metoda jspInit() inicializuje instanci servletu, která byla vygenerována z JSP, a v této fázi je vyvolána kontejnerem.
Jakmile je instance vytvořena, ihned po ní se vyvolá metoda init.
Volá se pouze jednou během životního cyklu JSP a metoda inicializace je deklarována, jak je uvedeno výše.

6) Zpracování žádosti

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

Metoda _jspService() je volána kontejnerem pro všechny požadavky vyvolané stránkou JSP během jejího životního cyklu.
V této fázi musí stránka projít všemi výše uvedenými fázemi a teprve poté lze vyvolat metodu služby.
Předává objekty požadavku a odpovědi.
Tuto metodu nelze přepsat, protože kontejner ji zapisuje během překladu.
Metoda je uvedena výše. Je zodpovědná za zpracování všech HTTP metod, tj. GET, POST a ostatních.

7) Zničit

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

Metoda jspDestroy() je také volána kontejnerem.
Tato metoda se volá, když kontejner rozhodne, že již nepotřebuje instanci servletu k obsluze požadavků.
Jakmile je provedeno volání metody destroy, servlet je připraven k uvolňování paměti.
Toto je konec životního cyklu.
Funkce jspDestroy() může být přepsána při jakémkoli čištění, například při uvolnění databázových připojení nebo zavření otevřených souborů.

Jedna poznámka k názvu, kterou stojí za to přenést: od Jakarty EE 9 tyto typy žijí v jakarta.servlet.jsp balíček spíše než javax.servlet.jsp, takže starší importy je nutné aktualizovat, když je aplikace přesunuta na aktuální server.

Nejčastější dotazy

Po překladu mají stejný životní cyklus. JSP přidává dvě fáze, překlad a kompilaci, které přemění stránku na zdrojový soubor servletu a třídu. Od načtení třídy dále servlet...tract platí beze změny.

V pracovním adresáři serveru, v adresáři work/Catalina/localhost/ /org/apache/jsp. Tam se uloží jak vygenerovaný zdrojový kód .java, tak i kompilovaný soubor .class, takže se z home.js stane home_jsp.java a home_jsp.class.

Kontejner jej generuje z těla stránky během překladu. Jeho signatura závisí na protokolu požadavku, takže specifikace jej vynechává z rozhraní JspPage a zakazuje autorům stránek, aby jej sami deklarovali.

Vygenerovaný servlet již implementuje init() pro uložení svého ServletConfig a poté volá jspInit(). Autoři stránek přepíší jspInit(), aby se nastavení kontejneru nikdy nepřeskočilo, což je přesně to, co ručně psané přepsání init() riskuje.

Předkompilace překládá a kompiluje každou stránku v době sestavení nebo nasazení, nikoli při prvním požadavku. Odstraňuje zpoždění při prvním zásahu, odhaluje chyby překladu před vydáním a umožňuje nasazení bez kompilátoru na serveru.

Zůstává podporován jako Jakarta Server Pages. Hlavní změnou je jmenný prostor balíčků: z Jakarta EE 9 se API přesunulo z javax.servlet.jsp na jakarta.servlet.jsp, takže starší importy je nutné před spuštěním na aktuálním serveru přepsat.

Asistenti umělé inteligence čtou vygenerovaný stack _jsp.java trace a namapují chybu kompilace zpět na řádek skriptletu, který jej způsobil, což je nejtěžší část chyb překladu. Také označují skriptlety, které patří do souboru tagů nebo servletu.

Ano. Copilot vytváří scaffoldy, bloky JSTL, zpracování formulářů a porovnávání tříd servletů z komentáře. RevZobrazit výstup pro jmenný prostor balíčku Jakarta a pro skriptlety, které by měly být výrazovým jazykem, protože návrhy často vycházejí ze starších tutoriálů.