Handling HTTP Requests with Java Servlets

Understanding GET vs. POST

Before we write any code, it's essential to understand the "what" and "why" of doGet() and doPost(). These methods correspond to the two most common HTTP methods. At a high level:

• GET is used to request data from a server.
• POST is used to send data to a server to create or update a resource.

Your familiarity with basic HTTP methods will be helpful here, but let's dive into the practical implications for a servlet developer. The following video provides an excellent explanation.

To summarize the key distinctions discussed in the video:

The Role of HttpServlet

So, how does the Servlet Container know to call doGet() for a GET request and doPost() for a POST request?

As we saw in the previous lesson, the container calls the service() method for every request. The HttpServlet class (which our servlet will extend) provides a default implementation of service() that acts as a dispatcher. It inspects the HTTP method of the request and calls the corresponding do...() method, like doGet() or doPost().

This process is illustrated perfectly in the diagram below.

This raises an interesting question: what happens if a request arrives for a method you haven't implemented? For example, if a POST request is sent to a servlet where you've only overridden doGet()? The default doPost() method in HttpServlet will be executed, which sends back an HTTP 405 "Method Not Allowed" error.

To see exactly why this happens, the next short clip looks at the actual source code of HttpServlet.

Implementing Your First Servlet: Step-by-Step

Now it's time to build a simple servlet that adds two numbers. This classic example will allow us to focus on the mechanics of handling requests and responses.

We'll use a textual guide for this section. It contains all the necessary code snippets for an HTML form, the servlet, and the web.xml configuration.

Let's break down the implementation into logical pieces, following the article.

1. The Servlet Class Structure

As shown in the article under "Servlet to Handle GET Request," a servlet is just a Java class that extends javax.servlet.http.HttpServlet.

// Basic structure
public class AddServlet extends HttpServlet {
    // We will implement methods here
}

2. Handling a GET Request

First, we'll implement doGet(). The method signature gives you two crucial objects:

• HttpServletRequest req: Contains everything about the incoming request (parameters, headers, etc.).
• HttpServletResponse res: Your tool for crafting the response to send back to the client.

Inside the method, we perform three main actions:

1. Get Parameters: We use req.getParameter("num1") to get the data submitted from the HTML form. Since getParameter always returns a String, we must parse it into a number using Integer.parseInt().
2. Process Logic: We perform our business logic—in this case, simple addition.
3. Send Response: We get a PrintWriter object from the response using res.getWriter() and use it to write our HTML output back to the browser.

// From the article: AddServlet.java with doGet()
public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
    int num1 = Integer.parseInt(req.getParameter("num1"));
    int num2 = Integer.parseInt(req.getParameter("num2"));
    int result = num1 + num2;

    PrintWriter out = res.getWriter();
    out.println("The result is = " + result);
}

3. Mapping the Servlet with web.xml

How does the servlet container know that a request to http://.../add should be handled by com.learnservlets.AddServlet? This mapping is defined in the Deployment Descriptor, a file named web.xml located in your project's WEB-INF directory.

This file is central to your request for understanding the foundations before frameworks. Spring Boot will later automate this for you, but knowing how it works is key.

The web.xml configuration has two parts:

• <servlet>: Gives a logical name to your fully qualified servlet class.
• <servlet-mapping>: Maps a URL pattern (e.g., /add) to that logical name.

<!-- From the article: web.xml -->
<web-app>
    <servlet>
        <servlet-name>AddServlet</servlet-name>
        <servlet-class>com.learnservlets.AddServlet</servlet-class>
    </servlet>

    <servlet-mapping>
        <servlet-name>AddServlet</servlet-name>
        <url-pattern>/add</url-pattern>
    </servlet-mapping>
</web-app>

4. Handling a POST Request

Now, let's handle POST requests. Look at the code under "Step 3: Handling POST Requests" in the article. You'll notice the code inside doPost() is identical to doGet(). This is common for simple actions. You would create a second HTML form, but this time with method="post".

5. Refactoring for "DRY" Code

Having identical code in doGet() and doPost() violates the "Don't Repeat Yourself" (DRY) principle. A better approach, shown in "Step 4" of the article, is to have both methods call a single, shared private method.

public class AddServlet extends HttpServlet {

    public void doGet(HttpServletRequest req, HttpServletResponse res) throws IOException {
        processRequest(req, res); // Delegate to the shared method
    }

    public void doPost(HttpServletRequest req, HttpServletResponse res) throws IOException {
        processRequest(req, res); // Delegate to the shared method
    }

    private void processRequest(HttpServletRequest req, HttpServletResponse res) throws IOException {
        // All the logic is now in one place
        int num1 = Integer.parseInt(req.getParameter("num1"));
        int num2 = Integer.parseInt(req.getParameter("num2"));
        int result = num1 + num2;

        PrintWriter out = res.getWriter();
        out.println("The result is = " + result);
    }
}

This is much cleaner and more maintainable. If you need to change the logic, you only have to do it in one place.

Key Takeaways

• A servlet is a Java class that extends HttpServlet.
• You must override doGet() and/or doPost() to handle HTTP GET and POST requests. The base class implementations will otherwise return an error.
• The HttpServletRequest object provides access to incoming data, like form parameters via getParameter().
• The HttpServletResponse object is used to construct the response, typically by using its getWriter().
• The web.xml file is used to map a URL pattern to a specific servlet class, telling the container how to route requests.
• It's good practice to refactor common logic from doGet() and doPost() into a shared private method.

What's Next?

Congratulations on designing your first servlet! You've successfully handled the most common types of web requests and configured the application manually.

In our next lesson, "Describe the Servlet lifecycle (init, service, destroy)," we will take a closer look at the lifecycle methods we first introduced in lesson 2. You'll learn how to use init() for one-time setup tasks and destroy() for cleanup, giving you full control over your servlet's existence within the container.