How do I include content from another servlet or JSP?

By Wayan in Servlet 0 Comment

To include the content of one servlet or JSP into another, you can use the functionality provided by the RequestDispatcher interface in Jakarta Servlet (previously Javax Servlet). The two primary methods for including content are:

  1. Using RequestDispatcher.include():
    This method includes the response of another servlet or JSP within the response of the current servlet or JSP.

  2. Using <jsp:include /> Tag:
    This is specifically used in JSP to include another JSP or servlet dynamically.

1. Using RequestDispatcher.include() in servlets

You can use the include() method of the RequestDispatcher to include the content of another servlet or JSP. Here’s how it works:

  • Steps:
    1. Obtain a RequestDispatcher object for the target servlet or JSP.
    2. Use the include() method to include its output.

Example Code:

package org.kodejava.servlet;

import jakarta.servlet.*;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.*;

import java.io.IOException;

@WebServlet("/include")
public class IncludeServletExample extends HttpServlet {
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
        response.setContentType("text/html");
        var out = response.getWriter();
        out.println("<html><body>");
        out.println("<h1>Content from Main Servlet</h1>");

        // Getting RequestDispatcher for another servlet or JSP
        RequestDispatcher dispatcher = request.getRequestDispatcher("/example");

        // Including content
        dispatcher.include(request, response);

        out.println("<h1>This is after including the content</h1>");
        out.println("</body></html>");
    }
}

2. Using <jsp:include /> in JSP

This is used to include either static or dynamic content from another JSP or servlet directly within a JSP page.

  • Syntax:
<jsp:include page="URL or Path" />

The page attribute specifies the relative URL or path of the servlet or JSP to be included.

Example Code:

<html>
<body>
  <h1>Content from Main JSP</h1>

  <!-- Include another servlet or JSP -->
  <jsp:include page="includedJspPage.jsp" />

  <h1>This is after including the content</h1>
</body>
</html>

Important Notes

  • Differences between include() and forward():
    • include(): Includes the response from the target servlet/JSP into the current response. The execution continues after including the content.
    • forward(): Forwards the request to another servlet/JSP. The control does not return to the original servlet/JSP.
  • Context-relative paths:
    • When specifying the path in RequestDispatcher (e.g., /example), always use context-relative paths (starting with a / relative to the root of the web application).
  • Dynamic Content:
    • The target servlet or JSP can contain dynamic content, as it is executed when included.

Maven dependencies

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.1.0</version>
    <scope>provided</scope>
</dependency>

Maven Central

How do I forward requests with RequestDispatcher?

By Wayan in Servlet 0 Comment

In Java, the RequestDispatcher is used to forward a client’s request to another resource, such as a servlet, JSP, or HTML file. This is common when you want to break down the processing of a request into multiple components.

Syntax to Use RequestDispatcher

The RequestDispatcher interface provides two main methods to forward or include content:

  1. forward(ServletRequest request, ServletResponse response): Forwards the request to another resource.
  2. include(ServletRequest request, ServletResponse response): Includes the content of another resource in the response.

Steps to Forward Requests

  1. Get the RequestDispatcher object:
    Use ServletRequest.getRequestDispatcher(String path) to obtain a RequestDispatcher instance. The path can be relative or absolute.

  2. Forward the request:
    Call the forward() method on the RequestDispatcher object to forward the request and response to another resource.

Example of Using RequestDispatcher

Here’s an example of using the RequestDispatcher to forward a request to another servlet or JSP:

import jakarta.servlet.RequestDispatcher;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;

@WebServlet("/forwardExample")
public class ForwardExampleServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // Add some attributes to the request
        request.setAttribute("message", "This is a forwarded request");

        // Get the RequestDispatcher for the target resource
        RequestDispatcher dispatcher = request.getRequestDispatcher("/target.jsp");

        // Forward the request and response
        dispatcher.forward(request, response);
    }
}

What Happens When You Forward?

  1. The forward() method hands over control of the request to the specified resource.
  2. The original request and response objects are passed along to the next resource.
  3. The client’s browser does not see a new request or URL change. The forward happens entirely on the server.

Example of the Target Resource (target.jsp)

Here’s an example target.jsp that receives the forwarded request:

<%@page contentType="text/html" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
    <head>
        <title>Forwarded Page</title>
    </head>
    <body>
        <h1>Forwarded Page</h1>
        <p>Message: ${message}</p>
    </body>
</html>

Key Points to Remember

  1. Forward Happens Internally:
    The URL in the browser doesn’t change, and the operations happen on the server side.

  2. Avoid Committing the Response:
    You cannot forward() the request if the response has already been committed (e.g., if you’ve written something to the response output already).

  3. Relative and Absolute Paths:

    • A path starting with / is absolute (relative to the web application root).
    • A path without / is relative to the current request path.
  4. Forward vs Redirect:
    • Forward happens on the server side; the browser is unaware.
    • Redirect happens by sending a response back to the client, requiring the client to make a new request.

Maven dependencies

<dependency>
    <groupId>jakarta.servlet</groupId>
    <artifactId>jakarta.servlet-api</artifactId>
    <version>6.1.0</version>
    <scope>provided</scope>
</dependency>

Maven Central