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

How do I forward request to another page in JSP?

By Wayan in JSP 0 Comment

To forward a request from one page to another JSP page we can use the <jsp:forward> action. This action has a page attribute where we can specify the target page of the forward action. If we want to pass parameter to another page we can include a <jsp:param> in the forward action. But make sure that the forward page is a JSP page to enable the parameters to be processed.

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <title>JSP - Forward Demo</title>
</head>
<body>

<jsp:forward page="message.jsp">
    <jsp:param name="message" value="Welcome!"/>
</jsp:forward>

</body>
</html>

And here is how to read the parameters in the message.jsp.

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Message: ${param["message"]}</title>
</head>
<body>
Message: ${param["message"]}
</body>
</html>
jsp:forward Demo

jsp:forward Demo

When you access the jspForward.jsp page in the web browser what you will see is the content of the message.jsp page. This is because the <jsp:forward> action forward your request to the message.jsp before returning the response back to the browser for display.

How do I forward to other page using <jsp:forward>?

By Wayan in Taglib 0 Comment

The <jsp:forward/> tag forward user request to other page. For example, a user request page1.jsp and in this page the server found a <jsp:forward page="page2.jsp"/>. The server immediately stop the processing of page1.jsp and jump to the page2.jsp.

Let see an example of using <jsp:forward/> tag.

page1.jsp

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Page 1</title>
</head>
<body>
<strong>This is page 1</strong>

<jsp:forward page="page2.jsp"/>
</body>
</html>

page2.jsp

<%@ page contentType="text/html;charset=UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
    <title>Page 2</title>
</head>
<body>
<strong>This is page 2</strong>
</body>
</html>

When you try to run the example above by accessing the URL http://localhost:8080/forward/page1.jsp you are going to see the content of page2.jsp instead of page1.jsp. It’s happen because on the server side page1.jsp forward your request to the page2.jsp. But if you look at your browser URL address it will still point to page1.jsp.

Here is the directory structure of our example:

.
├─ pom.xml
└─ src
   └─ main
      └─ webapp
         └─ forward
            └─ page1.jsp
            └─ page2.jsp

Maven Dependencies

<dependency>
  <groupId>javax.servlet</groupId>
  <artifactId>jstl</artifactId>
  <version>1.2</version>
</dependency>

Maven Central