Servlet Life Cycle

Introduction

Servlets are a core component of Java-based web applications. They are used to handle requests from clients (usually through HTTP) and generate responses, often HTML or JSON. Understanding the life cycle of a servlet is essential for building efficient and scalable Java web applications.

Servlet Life Cycle Phases

The Servlet life cycle consists of the following phases:

1. Loading and Instantiation
2. Initialization (init method)
3. Request Processing (service method)
4. Destruction (destroy method)

Each of these stages plays an important role in how a servlet is created, utilized, and eventually terminated by the server.

1. Loading and Instantiation

When a servlet is first requested, the server checks if the servlet instance already exists. If not, the servlet is loaded into memory, and the servlet container (like Apache Tomcat) instantiates the servlet class.

• Loading
  The servlet is loaded from its .class file, which might be loaded when the server starts (if it’s configured to load on startup) or when the servlet is first called.
• Instantiation
  After the class is loaded, the servlet container creates an instance of the servlet using its default no-argument constructor.

Example:

public class MyServlet extends HttpServlet {
    public MyServlet() {
        // Constructor
        System.out.println("Servlet instantiated.");
    }
}

At this point, the servlet object is created but not yet initialized. Initialization occurs in the next phase.

2. Initialization (init method)

Once the servlet instance is created, the servlet container calls the init() method to initialize the servlet. This method is called only once during the servlet’s life cycle. It is typically used to set up resources that the servlet will need throughout its life, such as database connections or configuration parameters.

Example:

@Override
public void init() throws ServletException {
    // Servlet initialization logic
    System.out.println("Servlet is being initialized.");
}

The init() method is passed a ServletConfig object, which contains initialization parameters and other configuration details.

Key points about init method:

• It is called only once when the servlet is first loaded.
• If initialization fails (throws a ServletException), the servlet will not be available to handle requests.
• You can override the init() method in your servlet class to define your custom initialization logic.

3. Request Processing (service method)

After initialization, the servlet is ready to handle client requests. For every incoming request, the servlet container calls the service() method, which determines the type of request (e.g., GET, POST) and calls the appropriate handler method (doGet, doPost, etc.).

Key points about service method:

• The service() method is called once for each request.
• It is responsible for dispatching the request to the correct method based on the HTTP request type.

Here’s how it typically works:

• If the request is a GET request, the servlet calls the doGet() method.
• If the request is a POST request, the servlet calls the doPost() method.

Example of a doGet() method:

@Override
protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    response.setContentType("text/html");
    PrintWriter out = response.getWriter();
    out.println("<h1>Hello, this is a GET request!</h1>");
}

Similarly, for handling POST requests:

@Override
protected void doPost(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
    // Handle POST request
}

Important points about request handling:

• Each request is handled in a separate thread (thread-per-request model).
• The service() method is called multiple times during the servlet’s lifecycle, as long as it’s active and running.

4. Destruction (destroy method)

When the servlet container decides that a servlet instance should be removed (this usually happens when the server is shutting down or when the servlet is no longer needed), it calls the destroy() method.

This method allows the servlet to clean up resources (such as closing database connections, releasing memory, etc.) before the instance is garbage-collected.

Example:

@Override
public void destroy() {
    // Clean up resources
    System.out.println("Servlet is being destroyed.");
}

Key points about destroy method:

• It is called only once, just before the servlet is removed from memory.
• After destroy() is called, the servlet is considered out of service, and it cannot handle any more requests.
• It should release any resources, such as open files or database connections.

A servlet dies under two main circumstances:

1. Server Shutdown
   When the server shuts down, all servlets are destroyed.
2. Manual Removal
   A servlet may be explicitly unloaded by the administrator or through configuration changes, which will also trigger the destroy() method.

Summary of Servlet Life Cycle Methods

• Constructor
  Instantiates the servlet.
• Init method
  Initializes the servlet (called once after instantiation).
• Service method
  Processes each client request (called for every request).
• Destroy method
  Cleans up resources and prepares for garbage collection (called once before removal).

Best Practices

• Initialization
  Perform resource initialization and configuration in the init method to ensure they are ready before handling client requests.
• Thread Safety
  Servlet instances are typically shared among multiple threads to handle concurrent requests. Ensure thread safety when accessing shared resources or mutable instance variables.
• Cleanup
  Implement robust cleanup logic in the destroy method to release resources properly, preventing memory leaks and ensuring efficient resource management.

Conclusion

Understanding the servlet life cycle is fundamental to developing efficient, well-behaved servlets in Java web applications. The life cycle ensures that servlets are properly instantiated, initialized, and destroyed, allowing them to handle client requests efficiently while also managing resources effectively.

By leveraging the init, service, and destroy methods, developers can control how their servlets initialize resources, process requests, and release resources at the appropriate time.