Have you ever wondered what actually happens behind the scenes when you type a URL in your browser and get a Java-based web page loaded instantly? Well, that little magic trick is performed by something known as a Servlet — a Java class that lives and breathes to handle your web requests.
Let’s get straight to it — this article is all about understanding the life cycle of a servlet in Java — not just from a textbook point of view but from a developer’s real-world perspective. I’ll also share some of my personal experiences dealing with servlets
What is a Servlet?
Before we talk about the life cycle of a servlet in Java, let’s take a step back.
A Servlet is basically a Java program that runs on a web server. It’s used to handle requests from clients (like your web browser) and send responses (like HTML pages or JSON data). Think of it as a middleman between your web app’s front-end and back-end logic.
When I first learned servlets, I imagined them as waiters in a restaurant, — they take your order (request), give it to the chef (server logic), and bring back your food (response). That’s literally how servlets work!
Now let’s see what happens behind the curtain — the life cycle of a servlet in Java.
Understanding the Life Cycle of a Servlet in Java
Here’s the exciting part — how a servlet is born, lives, and eventually dies in the server’s world.
The life cycle of a servlet in Java is controlled by the Servlet container (like Apache Tomcat, Jetty, or GlassFish). This container takes care of loading, initializing, running, and destroying servlets automatically.
Let’s walk through the major phases one by one.
1. Loading and Instantiation
When a client (say your browser) sends a request for the first time, the Servlet container checks if the servlet is already loaded in memory.
-
If not, it loads the servlet class.
-
Then it creates an instance of that class using the default constructor.
At this stage, the servlet is like a newborn baby — just created, but not yet ready to serve.
When I first deployed a servlet, I forgot to include it in my web.xml file. Guess what happened? The container didn’t even know my servlet existed! It’s like inviting guests to a party but forgetting to tell them your address. Lesson learned!
2. Initialization (init() method)
Next, the Servlet container calls the init() method exactly once for the servlet’s lifetime.
public void init() throws ServletException {
// Initialization code here
}
This is where you perform setup tasks like:
-
Establishing database connections
-
Reading configuration parameters
-
Allocating resources
In simple words — this phase is like preparing the kitchen before serving food. Once initialization is complete, the servlet is ready to process client requests.
💡 Pro Tip: Never put heavy logic or long database operations inside init() unless absolutely necessary — it might delay your servlet’s startup time.
3. Request Handling (service() method)
Now comes the heart of the life cycle of a servlet in Java — the service() method. This method is called every time a client sends a request.
public void service(ServletRequest request, ServletResponse response)
throws ServletException, IOException {
// Handle client requests here
}
The container creates separate threads for each client request (multithreading at work! ⚙️). Inside this method, the servlet decides which specific method to call based on the HTTP request type:
-
doGet()→ For HTTP GET requests -
doPost()→ For HTTP POST requests -
doPut()→ For PUT requests -
doDelete()→ For DELETE requests
So, if you’re logging in to a site, it’s probably a POST request being handled inside doPost().
When I was a beginner, I once wrote everything inside doGet() and wondered why my POST requests weren’t working.
4. Destruction (destroy() method)
Every servlet has to say goodbye eventually. When the server shuts down or the servlet is no longer needed, the container calls the destroy() method.
public void destroy() {
// Cleanup code here
}
This method releases resources like database connections or file handles. Think of it as cleaning up your workspace before leaving for the day.
5. Garbage Collection
After the destroy() method runs, the servlet object becomes eligible for garbage collection. The Java Garbage Collector (GC) then removes it from memory.
You might not see this step directly, but it’s an essential part of the life cycle of a servlet in Java. It ensures efficient memory management and prevents leaks.
Quick Recap: Servlet Life Cycle Steps
| Phase | Description |
|---|---|
| Loading | The container loads the servlet class. |
| Instantiation | Creates an instance of the servlet. |
| Initialization | Calls init() once. |
| Request Handling | Calls service() for every request. |
| Destruction | Calls destroy() before unloading. |
It’s a clean 5-step journey from creation to termination — simple but powerful!
Real-Life Example: Servlet in Action
Here’s a quick example I used when I first tested a servlet:
import java.io.*;
import javax.servlet.*;
import javax.servlet.http.*;
public class HelloServlet extends HttpServlet {
public void init() throws ServletException {
System.out.println("Servlet Initialized!");
}
public void doGet(HttpServletRequest request, HttpServletResponse response)
throws ServletException, IOException {
response.setContentType("text/html");
PrintWriter out = response.getWriter();
out.println("<h2>Hello from Servlet!</h2>");
}
public void destroy() {
System.out.println("Servlet Destroyed!");
}
}
When you deploy this on Apache Tomcat and visit the URL, you’ll see the lifecycle messages in the console. It’s a fun experiment to visualize the life cycle of a servlet in Java.
My Thoughts on Learning Servlets
When I started learning Java web development, understanding the life cycle of a servlet in Java was a turning point. It helped me truly grasp how web servers communicate with clients.
If you ever feel confused while debugging servlet issues, just remember this: every error you face is probably happening in one of these phases — loading, init, service, or destroy. Break it down, trace it, and you’ll find your fix.
Conclusion:
Understanding the life cycle of a servlet in Java isn’t just academic — it’s essential for writing efficient, secure, and scalable web applications. Knowing how a servlet is created, initialized, serves requests, and gets destroyed gives you better control over your application’s performance.
So the next time your servlet acts weird or doesn’t respond,
Just walk through its life cycle — you’ll know exactly where things might have gone wrong.
Want to go deeper? Kaashiv Infotech Offers Full Stack Java Developer Course, Java Course, Java Internship In Online & Offline Visit Our Website www.kaashivinfotech.com.
