Understanding Servlet in Java, With Examples

Key Points

• A servlet is a class in Java used to respond to client requests, mostly in applications hosted by a web server.
• Servlets have a defined lifecycle with 5 stages: Initialization, Request Handling, Request Processing, Response Generation, and Destruction.
• Servlets are used for dynamically handling HTTP requests and are a portable and scalable way to build web applications.

Java is a widely used programming language, particularly in web development. It has a diverse range of libraries and tools designed for this purpose and is intended to be able to be used on any platform with the help of the Java Virtual Machine (JVM). Another important advantage Java has is the servlet class. The servlet class is designed to improve the functionality of a web server, especially in handling client requests and generating dynamic responses. Today we’re going to explore servlets in detail, examining the underlying concepts and show how they’re used.

What Is a Servlet in Java and How Do Servlets Work?

A servlet is a class that’s used to respond to client requests, mostly in applications that are being hosted by a web server. When they send a request to the web server, the server passes this request on to the servlet. The servlet then processes the request and generates a response. It then passes the response back to the web server and then to the client’s browser.

Each servlet has a servlet container, which contains the infrastructure that’s used for execution and manages the servlet functionality. When it receives a request, the container determines which servlet should handle it. The container also has mechanisms for managing the security of the servlet and also handles individual sessions for each user.

Servlet Lifecycle

Servlets don’t hang around forever and have a defined lifecycle. At a basic level, there are 5 stages in the lifecycle:

1. Initialization

First, the container creates an instance of the servlet once the program needs to use it. Then it uses the “init()” to initialize the servlet’s configuration. If it encounters an exception at this stage, it usually marks the servlet as unavailable and handles the error first.

2. Request Handling

This is the main part of the lifecycle, where the servlet handles the client’s request. This usually comes in the form of an HTTP method such as “GET”, “POST”, “PUT” or “DELETE”. We use “GET” to retrieve data, such as a webpage or image, while we use “POST” to submit data, such as form data, or to create a resource. Meanwhile, we use “PUT” to update or replace a resource on the server, and we use “DELETE” to remove it.

3. Request Processing

Once it receives the request, it must process the request. It does this by using HTTP method-specific methods like “doGet()”, “doPost()”, “doPut()”, or “doDelete()”. These methods receive the request parameters and headers, which provide information about the request and perform operations based on the specific business’ workflows. It can handle multiple requests simultaneously, and the servlet container usually manages this.

4. Response Generation

Next, the servlet generates the response. This response can contain a variety of content depending on the application, such as HTML, JSON, or XML formats. It sends the response back to the client via the container.

5. Destruction

Lastly, if the application is terminated or restarted, or the container needs to free up resources, the servlet will be destroyed. We can use the “destroy()” method, which is called by the container, to do this. We can also perform cleanup tasks, such as releasing resources or disconnecting from databases, at this stage.

Servlet Example

Here is an example of creating an instance of a servlet and configuring its parameters. Typically, we configure servlets through the web.xml deployment descriptor file, where you can define mappings and initialization parameters. However, in Java EE 5 and later, we can also use annotations. This allows us to define configuration settings directly from within the servlet class. You can see this in the code block below.

package com.mycompany.helloservlet;

import java.io.IOException;
import java.io.PrintWriter;

import javax.servlet.annotation.WebServlet;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

@WebServlet(urlPatterns = {"/hello"})
public class HelloServlet extends HttpServlet {
    private static final long serialVersionUID = 1L;

    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws IOException {
        response.setContentType("text/html");
        PrintWriter out = response.getWriter();
        out.println("<html><body>");
        out.println("<h2>Hello, Servlet!</h2>");
        out.println("</body></html>");
    }
}

First, we declare the package name for the servlet, so that we can manage the code more efficiently. We then import various classes:

“IOException” is used to handle input/output operations.

“PrintWriter” provides the methods for writing formatted text to an output stream, and we use it to send the response back to the client.

“WebServlet” allows us to configure the servlet using annotations.

“HttpServlet” creates HTTP servlets and also provides us with methods for generating responses from HTTP requests.

“HttpServletRequest” lets us access and change the information received in the request.

“HttpServletResponse” allows us to set the type of content in our HTTP response and write data to it.

We then configured the servlet with the “@WebServlet” annotation, which maps the servlet to the “/hello” URL pattern. Next, we declare the public “HelloServlet” class, which is an extension of the “HttpServlet” class. After this, we declare the “serialVersionUID” field, which checks that the serialized version of the object is the same as the version being used during deserialization. We declare the “doGet” method next, and we set the content type of the response to “text/html”. The program then retrieves the “PrintWriter” method, and prints the “Hello, Servlet!” message as an h2 heading, enclosed within the HTML tags.

Why Do We Use Servlets?

We use servlets for many reasons, but the main reasons are:

• Platform independence – since we write servlets in Java, we can run them on any operating system that supports the JVM.
• Scalability – Programmers design servlets with efficiency in mind, and they can handle several responses simultaneously without significantly increasing their consumption of resources by using containers.
• Reusability – Since they’re platform-independent, we can integrate servlets relatively easily into different web applications, and customize them as needed. We can also combine Servlets with other Java technologies, such as JavaBeans, Enterprise JavaBeans, or JavaServer Pages.
• Ongoing development – Java has a particularly large community of active developers, so there are a lot of tools, libraries and documentation available to help you develop servlets more effectively.

What Are the Drawbacks of Servlets?

Unfortunately, there are some cons to servlets that you should be aware of. These include:

• Manual handling – Since servlets require low-level programming, the developer must deal with HTTP requests and responses manually, which can be time-consuming.
• Complexity of code – A solid understanding of Java is crucial, as developers must be able to write code to handle requests and responses, manage sessions, and handle concurrent requests.
• Concern ambiguity – The programmer must write the servlet code to manage the logic, presentation, and data access of the application, meaning there isn’t a clear distinction between the concerns of the different application layers. This can make it difficult to maintain the code and handle concerns, especially if the programmer didn’t develop the servlet themselves.
• Asynchronous processing difficulty – Ideally, it would handle requests asynchronously, meaning it can process the next request while the current response is being produced. However, this can be complicated to achieve.

Servlets in Java: Wrapping Up

There’s a lot of theory involved in servlet development, but they’re a powerful tool for dynamically handling HTTP requests. While servlets can be relatively complex and require manual handling, they’re a portable and scalable way to build web applications when used properly. Through the use of methods such as GET, POST, PUT, and DELETE, we can use servlets for data retrieval, data submission and to update resources on the web server.

Summary Table

The image featured at the top of this post is ©iStock.com/Buffik.