Ciclo de vida de un servlet

El ciclo de vida completo de un Servlet es administrado por el contenedor de Servlet que utiliza la interfaz javax.servlet.Servlet para comprender el objeto Servlet y administrarlo. Entonces, antes de crear un objeto Servlet, primero comprendamos el ciclo de vida del objeto Servlet, que en realidad es comprender cómo el contenedor Servlet administra el objeto Servlet.

Etapas del ciclo de vida del servlet : el ciclo de vida del servlet pasa principalmente por cuatro etapas,

  • Cargando un Servlet.
  • Inicializando el Servlet.
  • Manejo de requests.
  • Destruyendo el Servlet.

Veamos cada una de estas etapas en detalle:

  1. Cargando un Servlet : La primera etapa del ciclo de vida del Servlet consiste en cargar e inicializar el Servlet por el contenedor de Servlet. El contenedor web o contenedor de servlet puede cargar el servlet en cualquiera de las dos etapas siguientes:
    • Inicializando el contexto, al configurar el Servlet con valor cero o entero positivo.
    • Si el Servlet no está en la etapa anterior, puede retrasar el proceso de carga hasta que el contenedor Web determine que este Servlet es necesario para atender una solicitud.

    El contenedor Servlet realiza dos operaciones en esta etapa:

    • Cargando: Carga la clase Servlet.
    • Instanciación: Crea una instancia del Servlet. Para crear una nueva instancia del Servlet, el contenedor usa el constructor sin argumentos.

  2. Inicializar un Servlet : Después de que el Servlet se instancia con éxito, el contenedor de Servlet inicializa el objeto Servlet instanciado. El contenedor inicializa el objeto Servlet invocando el método Servlet.init(ServletConfig) que acepta la referencia del objeto ServletConfig como parámetro.

    El contenedor Servlet invoca el método Servlet.init(ServletConfig) solo una vez, inmediatamente después de que el objeto Servlet.init(ServletConfig) se instancia correctamente. Este método se utiliza para inicializar los recursos, como el origen de datos JDBC.

    Ahora, si el Servlet no se puede inicializar, informa al contenedor del Servlet lanzando la ServletException o la UnavailableException .

  3. Solicitud de manejo : después de la inicialización, la instancia de Servlet está lista para atender las requests del cliente. El contenedor de Servlet realiza las siguientes operaciones cuando la instancia de Servlet se encuentra para atender una solicitud:
    • Crea los objetos ServletRequest y ServletResponse . En este caso, si se trata de una solicitud HTTP, el contenedor web crea objetos HttpServletRequest y HttpServletResponse que son subtipos de los objetos ServletRequest y ServletResponse respectivamente.
    • Después de crear los objetos de solicitud y respuesta, invoca el método Servlet.service(ServletRequest, ServletResponse) pasando los objetos de solicitud y respuesta.

    El método service() mientras procesa la solicitud puede generar ServletException o UnavailableException o IOException .

  4. Destruyendo un Servlet : Cuando un contenedor de Servlet decide destruir el Servlet, realiza las siguientes operaciones,
    • Permite que todos los subprocesos que se ejecutan actualmente en el método de servicio de la instancia de Servlet completen sus trabajos y se liberen.
    • Después de que los subprocesos en ejecución hayan completado sus trabajos, el contenedor de Servlet llama al método destroy() en la instancia de Servlet.

    Después de ejecutar el método destroy() , el contenedor de Servlet libera todas las referencias de esta instancia de Servlet para que sea elegible para la recolección de basura.

Métodos del ciclo de vida del servlet

Hay tres métodos de ciclo de vida de un Servlet:

  • en eso()
  • Servicio()
  • destruir()

Veamos cada uno de estos métodos en detalle:

  1. Método init() : el contenedor de Servlet llama al método Servlet.init() para indicar que esta instancia de Servlet se ha creado correctamente y está a punto de ponerse en servicio.
    //init() method
    
    public class MyServlet implements Servlet{
       public void init(ServletConfig config) throws ServletException {
            //initialization code
       }
        //rest of code
    }
    
  2. Método service() : El método service() del Servlet se invoca para informar al Servlet sobre las requests del cliente.
    • Este método utiliza el objeto ServletRequest para recopilar los datos solicitados por el cliente.
    • Este método utiliza el objeto ServletResponse para generar el contenido de salida.
    // service() method
    
    public class MyServlet implements Servlet{
        public void service(ServletRequest res, ServletResponse res)
        throws ServletException, IOException {
                // request handling code
        }
        // rest of code
    }
    
  3. método destroy() : El método destroy() se ejecuta solo una vez durante la vida útil de un Servlet y señala el final de la instancia de Servlet.
    //destroy() method
    
    public void destroy()
    

    Tan pronto como se activa el método destroy() , el contenedor de Servlet libera la instancia de Servlet.

Ciclo
de vida del servlet: el ciclo de vida del servlet se puede definir como las etapas por las que pasa el servlet desde su creación hasta su destrucción.
El ciclo de vida del servlet consta de estas etapas:

  • Nace el servlet
  • Se inicializa el servlet
  • Servlet está listo para el servicio
  • Servlet está dando servicio
  • Servlet no está listo para el servicio
  • El servlet es destruido

Métodos de ciclo de vida: Los métodos
de ciclo de vida son aquellos métodos que se utilizan para controlar el ciclo de vida del servlet. Estos métodos se llaman en un orden específico durante todo el ciclo de vida de los servlets.
La clase Servlet proporciona los métodos para controlar y supervisar el ciclo de vida del servlet. Hay tres métodos de ciclo de vida en la interfaz Servlet. Hay los siguientes:

  • método init() :
    1. La vida de un servlet comienza aquí.
    2. Este método se llama solo una vez para cargar el servlet. Dado que se llama solo una vez en su vida, por lo tanto, el código de «arquitectura conectada» se escribe dentro de él porque solo queremos conectarnos una vez con la base de datos.
      Ahora surge la pregunta:
      P. ¿Por qué no podemos escribir código de arquitectura conectada dentro del constructor, ya que el constructor también se ejecuta solo una vez en toda su vida?
      Respuesta Supongamos que si la conexión no se establece, entonces podemos lanzar una excepción desde init() y el resto de los pasos dejan de ejecutarse. Pero en el constructor que no podemos usar, agregue su prototipo; de lo contrario, es un error.
    3. Este método recibe solo un parámetro, es decir, el objeto ServletConfig .
    4. Este método tiene la posibilidad de lanzar la ServletException.
    5. Una vez que se inicializa el servlet, está listo para manejar la solicitud del cliente.
    6. El prototipo del método init():
      public void init(ServletConfig con)throws ServletException{ }

      donde contra es el objeto ServletConfig

    7. NOTA: – En los programas de servlet, usamos una versión no parametrizada de init().

      Ahora, surge la pregunta:
      P. ¿Por qué se recomienda usar la versión no parametrizada de init() en lugar de la versión parametrizada como se ve arriba?
      Respuesta Para responder a esto, tenemos que entrar en detalles. Piense como desarrolladores, es decir, debe haber alguna razón válida para esto y la respuesta le dejará boquiabierto. Viniendo a responder:

      ENFOQUE 1
      Cada vez que el método del ciclo de vida de un servlet comienza a ejecutarse, es decir, cuando public void init (ServletConfig con) lanza ServletException recibe una llamada, entonces nuestra clase public void init (ServletConfig con) lanza ServletException recibe una llamada pero tenemos que ejecutar el código que inicializa la configuración del servlet objeto que está escrito dentro del método «HttpServlet» public void init (ServletConfig con) lanza ServletException, es decir:
      la codificación de la clase HttpServlet sería como:

      public void init(ServletConfig con) throws ServletException
      {
         //code to initialise ServletConfig object
      
      init();  //This HttpServlet has 2 init() one which is parameterized and the other one is non 
               //parameterized.But this non parameterized version of init() has a blank body. 
               //So this call is useless. 
      
      }
      

      Ahora vea la codificación de nuestra clase.

      public void init(ServletConfig con) throws ServletException
      {
      super.init(con);  //Since,our class init() will run first,but to run HttpServlet init() we
                       // have used super keyword.And Database connectivity code will be their
      }
      

      NOTA: – Como podemos ver, tenemos que hacer un total de 3 llamadas init(). Primero se llama a init() de nuestra clase, luego a la clase HttpServlet y luego a la versión no parametrizada de la clase HttpServlet.

      Pero ahora, lograremos lo mismo con menos número de llamadas:

      ENFOQUE 2
      La codificación de las versiones parametrizadas y no parametrizadas de HttpServlet de init() seguirá siendo la misma. Pero en nuestra clase, en lugar de anular la versión parametrizada de init(), anularemos la versión no parametrizada de init() .

      Veamos la codificación de nuestra clase versión no parametrizada de init():

      public void init() throws ServletException  
      {
         //database connectivity code
      }
      

      NOTA: Dado que este método public void init() lanza ServletException, tenemos una anulación de la clase HttpServlet cuya codificación es como:

      public void init() throws ServletException  
      {
         //empty body
      }
      

      Dado que su cuerpo está en blanco, por lo tanto, se conoce como «método auxiliar» , ya que se utiliza con fines primordiales.

      Ahora, cuando el servlet comience a ejecutar sus métodos, llamará a la versión parametrizada de init(). Dado que no tenemos que anular la versión parametrizada, llamará a la versión parametrizada HttpServlet de init(). Dado que la codificación de una versión parametrizada de init() de HttpServlet es igual que la anterior, por lo tanto, a partir de ahí llamará a init() (es decir, una versión no parametrizada de init). Dará una llamada a nuestra clase versión no parametrizada de init() y el código continúa.
      Ahora, como puede ver, el número total de llamadas init() es 2, que es menor que el primer enfoque. Por lo tanto, el tiempo de ejecución es menor en el segundo enfoque y menos dolor de cabeza para la CPU para mantener la pila y su velocidad aumenta en comparación con el primer enfoque.
      Por lo tanto, se recomienda anular la versión no parametrizada de init(). Aunque ambos se ejecutarán, pero debido a la eficiencia, el primer enfoque rara vez se usa y también en el primer enfoque también tenemos que usar la palabra clave super. Por lo tanto, en el programa mencionado a continuación, tenemos anula la versión no parametrizada de init().

  • método de servicio():
    1. El método service() es el método más importante que proporciona la conexión entre el cliente y el servidor.
    2. El servidor web llama al método service() para manejar las requests provenientes del cliente (navegadores web) y enviar la respuesta al cliente.
    3. Este método determina el tipo de solicitud Http (GET, POST, PUT, DELETE, etc.).
    4. Este método también llama a varios otros métodos, como doGet(), doPost(), doPut(), doDelete(), etc., según sea necesario.
    5. Este método acepta dos parámetros.
    6. El prototipo de este método:
      public void service(ServletRequest req, ServletResponse resp) 
      throws ServletException, IOException { }

      dónde

      • req es el objeto ServletRequest que encapsula la conexión del cliente al servidor
      • resp es el objeto ServletResponse que encapsula la conexión del servidor al cliente
  • destruir() método:
    1. El método destroy() se llama solo una vez.
    2. Se llama al final del ciclo de vida del servlet.
    3. Este método realiza varias tareas, como cerrar la conexión con la base de datos, liberar memoria asignada al servlet, liberar recursos asignados al servlet y otras actividades de limpieza.
    4. Cuando se llama a este método, el recolector de basura entra en acción.
    5. El prototipo de este método es:
      public void destroy() { // Finalization code...}

A continuación se muestra un programa de ejemplo para ilustrar Servlet en Java:

// Java program to show servlet example
// Importing required Java libraries
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
  
// Extend HttpServlet class
public class AdvanceJavaConcepts extends HttpServlet 
{ 
   private String output;
    
   // Initializing servlet 
   public void init() throws ServletException 
   {
      output = "Advance Java Concepts";
   }
  
   // Requesting and printing the output
   public void doGet(HttpServletRequest req, 
                    HttpServletResponse resp)
      throws ServletException, IOException 
      {
         resp.setContentType("text/html");
         PrintWriter out = resp.getWriter();
         out.println(output);
      }
  
      public void destroy() 
      {
         System.out.println("Over");
      }
}

Publicación traducida automáticamente

Artículo escrito por Kartik Thakral y traducido por Barcelona Geeks. The original can be accessed here. Licence: CCBY-SA

Deja una respuesta

Tu dirección de correo electrónico no será publicada. Los campos obligatorios están marcados con *