Ciclo de vida JSP

¿Qué es el ciclo de vida de JSP?

El ciclo de vida de JSP se define como la traducción de una página JSP a un servlet, ya que una página JSP debe convertirse primero en un servlet para poder procesar las solicitudes de servicio. El ciclo de vida comienza con la creación de JSP y termina con su desintegración.

Diferentes fases del ciclo de vida de JSP

Cuando el navegador solicita un JSP, el motor JSP primero verifica si necesita compilar la página. Si el JSP se compila por última vez o la modificación reciente se realiza en JSP, entonces el motor JSP compila la página.

El proceso de compilación de una página JSP implica tres pasos:

Análisis de JSP
Convertir JSP en servlet
Compilando el servlet

Diagrama del ciclo de vida JSP

El ciclo de vida de JSP se muestra en el siguiente diagrama.

Los siguientes pasos explican el ciclo de vida de JSP:

Traducción de página JSP
Compilación de la página JSP (Compilación de la página JSP en _jsp.java)
Carga de clases (_jsp.java se convierte en un archivo de clase _jsp.class)
Creación de instancias (se crea el objeto del servlet generado)
Inicialización(_jspinit() el método es invocado por el contenedor)
Procesamiento de solicitudes (_jspservice() El contenedor invoca el método)
Destruir (_jspDestroy() método invocado por el contenedor)

Hagamos un resumen más detallado de los puntos anteriores:

1) Traducción de la página JSP:

A Java El archivo servlet se genera a partir de un archivo fuente JSP. Este es el primer paso del ciclo de vida de JSP. En la fase de traducción, el contenedor valida la corrección sintáctica de la página JSP y los archivos de etiquetas.

El contenedor JSP interpreta las directivas y acciones estándar y las acciones personalizadas que hacen referencia a las bibliotecas de etiquetas (todas son parte de la página JSP y se analizarán en la sección posterior) utilizadas en esta página JSP.
En la descripción gráfica anterior, demo.jsp se traduce a demo_jsp.java en el primer paso.
Tomemos un ejemplo de "demo.jsp" como se muestra a continuación:

Demostración.jsp

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

Explicación del código para Demo.jsp

Línea de código 1: etiqueta de inicio html

Línea de código 2: Etiqueta de cabeza

Línea de código 3 – 4: Etiqueta de título, es decir, JSP de demostración y etiqueta principal de cierre

Línea de código 5 – 6: Etiqueta de scriptlet en la que se inicializa la demostración de la variable

Línea de código 7 – 8: En la etiqueta del cuerpo, un texto que se imprimirá en la salida (el número es: )

Línea de código 9: Etiqueta Scriplet donde se intenta imprimir la variable demovar con valor incrementado

Línea de código 10 – 11: Etiquetas de cuerpo y HTML cerradas

La página JSP de demostración se convierte en el servlet demo_jsp en el siguiente código.

Explicación del código para Demo_jsp.java

Línea de código 1: La clase de servlet demo_jsp está ampliando la clase principal HttpServlet

Línea de código 2 – 3: Anulación del método de servicio de jsp, es decir, _jspservice que tiene objetos HttpServletRequest y HttpServletResponse como parámetros

Línea de código 4: Método de apertura

Línea de código 5: Llamando al método getWriter() del objeto de respuesta para obtener PrintWriteobject (imprime la representación formateada de los objetos en el flujo de salida de texto)

Línea de código 6: Llamar al método setContentType del objeto de respuesta para establecer el tipo de contenido

Línea de código 7: Utilizando write() método del objeto PrintWriter que intenta analizar html

Línea de código 8: Inicializando la variable demovar a 0

Línea de código 9: Llamando write() método del objeto PrintWriter para analizar el texto

Línea de código 10: Llamando print() método del objeto PrintWriter para incrementar la variable demovar de 0+1=1. Por lo tanto, la salida será 1

Línea de código 11: Utilizando write() método del objeto PrintWriter que intenta analizar html

Salida:

Aquí puedes ver que en la captura de pantalla la salida es 1 porque demvar se inicializa a 0 y luego se incrementa a 0+1=1.

En el ejemplo anterior,

demo.jsp, es un JSP donde se inicializa e incrementa una variable. Este JSP se convierte en el servlet (demo_jsp.class) donde el motor JSP carga la página JSP y la convierte en contenido de servlet.
Cuando ocurre la conversión, todo el texto de la plantilla se convierte a println() declaraciones y todo elementos JSP se convierten a Java código.

Así es como se traduce una página JSP simple en una clase de servlet.

2) Compilación de la página JSP

El archivo de servlet java generado se compila en la clase de servlet java
La traducción de la página fuente de Java a su clase de implementación puede ocurrir en cualquier momento entre la implementación de la página JSP en el contenedor y el procesamiento de la página JSP.
En la descripción gráfica anterior, demo_jsp.java se compila en un archivo de clase demo_jsp.class

3) Carga de clases

La clase de servlet que se ha cargado desde la fuente JSP ahora está cargada en el contenedor

4) Creación de instancias

En este paso se genera el objeto, es decir, la instancia de la clase.
El contenedor gestiona una o más instancias de esta clase en respuesta a solicitudes y otros eventos. Normalmente, un contenedor JSP se construye utilizando un contenedor de servlets. Un contenedor JSP es una extensión del contenedor de servlet, ya que tanto el contenedor admite JSP como servlet.
Una interfaz JSPPage proporcionada por el contenedor proporciona init() y destroy() métodos.
Hay una interfaz HttpJSPPage que atiende solicitudes HTTP y también contiene el método de servicio.

5) Inicialización

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

_jspinit() El método iniciará la instancia de servlet que se generó a partir de JSP y será invocada por el contenedor en esta fase.
Una vez que se crea la instancia, el método init se invocará inmediatamente después de eso.
Solo se llama una vez durante el ciclo de vida de JSP, el método de inicialización se declara como se muestra arriba

6) Procesamiento de solicitudes

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

_jspservice() El contenedor invoca el método para todas las solicitudes generadas por la página JSP durante su ciclo de vida.
Para esta fase, debe pasar por todas las fases anteriores y luego solo se podrá invocar el método de servicio.
Pasa objetos de solicitud y respuesta.
Este método no se puede anular.
El método se muestra arriba: es responsable de generar todos los métodos HTTP, es decir, GET, POST, etc.

7) Destruir

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

_jspdestroy() El método también es invocado por el contenedor.
Este método se llama cuando el contenedor decide que ya no necesita la instancia de servlet para atender las solicitudes.
Cuando se realiza la llamada al método de destrucción, el servlet está listo para una recolección de basura.
Este es el final del ciclo de vida.
Podemos anular jspdestroy() método cuando realizamos cualquier limpieza, como liberar conexiones de bases de datos o cerrar archivos abiertos.

Te podría gustar: