JAVA EE: RequestDispatcher

Showing posts with label RequestDispatcher. Show all posts

Wednesday, 23 April 2014

Servlets : Send Redirect vs. Forward

🚀 Master Java & Servlets with Ram N Java!

Subscribe to get clear, beginner-friendly tutorials right when they drop.

Send Redirect vs. Forward: The Core Difference

When transferring control between components in a Java web application, developers rely on two primary approaches: RequestDispatcher Forward and HttpServletResponse SendRedirect.

While both move user navigation to a new target, the way they handle client-server roundtrips, request scopes, and browser URLs is fundamentally different.

Detailed Comparison Breakdown

Feature	Forward (RequestDispatcher)	Send Redirect (HttpServletResponse)
Execution Location	Server-side internal transfer	Client-side two-step navigation
HTTP Requests	Single request & response cycle	Two distinct requests (Status 302 + GET)
Browser URL Bar	Remains unchanged (shows original URL)	Updates to reflect the target URL
Request Scope Attributes	Preserved across components	Lost (new request instance created)
Target Scope	Within the same web application only	Within same server or external domain

When Should You Use Each?

Use Forward: When dispatching from a controller servlet to a view (JSP), sharing prepared request attributes, or when you want internal execution without revealing destination URLs.
Use Send Redirect: Following form submissions (Post/Redirect/Get pattern to prevent duplicate submissions on reload), navigating to an external domain, or redirecting unauthenticated users to a login page.

Recommended Next Watch

Learn more about request handling and dispatching in Java Servlets with these tutorials:

Click here to watch in Youtube : https://www.youtube.com/watch?v=xMgpVkRHFZE

Click the below Image to Enlarge

Servlets : Send Redirect vs. Forward

Thursday, 17 April 2014

Servlets : RequestDispatcher Example

Master Java Web Development!

Subscribe to Ram N Java for step-by-step Java tutorials, servlet architecture, and practical backend coding guides!

🔔 Subscribe to Ram N Java

What is RequestDispatcher in Java Servlets?

The RequestDispatcher interface is an essential component of the javax.servlet package. It acts as a server-side traffic controller, allowing you to pass an incoming client request from one servlet to another web resource, such as another servlet, a JSP file, or an HTML file, within the same web application.

Unlike client-side redirection (sendRedirect), which asks the browser to initiate a new request, RequestDispatcher operates entirely on the server. This keeps the URL unchanged in the user's browser and preserves the original request and response objects throughout the process.

Key Methods of RequestDispatcher

The RequestDispatcher interface provides two primary methods to transfer or combine resources:

forward(ServletRequest request, ServletResponse response): Forwards a request from one servlet to another resource. The second resource takes over generating the complete response to the user.
include(ServletRequest request, ServletResponse response): Includes the content of another resource (such as a shared header, banner, or footer) directly inside the calling servlet's response.

Real-World Use Case: User Login Flow

A classic, practical example of using RequestDispatcher is an authentication workflow:

A user enters their username and password on a web login form.
LoginServlet receives the credentials and validates them against the database.
If authentication succeeds: LoginServlet forwards control to WelcomeServlet using dispatcher.forward(request, response) to render the user's dashboard.
If authentication fails: LoginServlet includes an error message and redisplays the login form using dispatcher.include(request, response).

Recommended Related Tutorials

Explore more core Java servlet concepts with these handpicked tutorials from Ram N Java:

Click here to watch in Youtube : https://www.youtube.com/watch?v=x91U0h2xY2U

Click the below Image to Enlarge

RequestDispatcherDemo Project Dir Structure

LoginServlet.java

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

import javax.servlet.RequestDispatcher;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class LoginServlet extends HttpServlet
{

 private static final long serialVersionUID = 1L;

 public void init() throws ServletException
 {
  System.out
          .println("------------------------------------------------------");
  System.out.println(" Init method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException
 {
  response.setContentType("text/html");
  PrintWriter out = response.getWriter();

  String userName = request.getParameter("username");
  String passWord = request.getParameter("password");

  if (userName.equalsIgnoreCase("ram") && passWord.equals("ram"))
  {
   RequestDispatcher requestDispatcher = request
           .getRequestDispatcher("/welcome");
   requestDispatcher.forward(request, response);
  }
  else
  {
   out.print("Sorry UserName or Password is Wrong!");
   RequestDispatcher requestDispatcher = request
           .getRequestDispatcher("/index.html");
   requestDispatcher.include(request, response);
  }
 }

 public void destroy()
 {
  System.out
          .println("------------------------------------------------------");
  System.out.println(" destroy method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");
 }
}

WelcomeServlet.java

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

import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;

public class WelcomeServlet extends HttpServlet
{

 private static final long serialVersionUID = 1L;

 public void init() throws ServletException
 {
  System.out
          .println("------------------------------------------------------");
  System.out.println(" Init method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");
 }

 public void doPost(HttpServletRequest request, HttpServletResponse response)
         throws ServletException, IOException
 {

  response.setContentType("text/html");
  PrintWriter out = response.getWriter();

  String userName = request.getParameter("username");
  out.print("Welcome " + userName);
 }

 public void destroy()
 {
  System.out
          .println("------------------------------------------------------");
  System.out.println(" destroy method is called in "
          + this.getClass().getName());
  System.out
          .println("------------------------------------------------------");
 }
}

web.xml

<?xml version="1.0" encoding="ISO-8859-1"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
 xmlns="http://java.sun.com/xml/ns/javaee"
 xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
 metadata-complete="true" version="3.0">
 <display-name>RequestDispatcherDemo</display-name>
 <description>
        This is a simple web application with a source code organization
        based on the recommendations of the Application Developer's Guide.
    </description>
 
 <servlet>
  <servlet-name>LoginServlet</servlet-name>
  <servlet-class>LoginServlet</servlet-class>
 </servlet>
 <servlet>
  <servlet-name>WelcomeServlet</servlet-name>
  <servlet-class>WelcomeServlet</servlet-class>
 </servlet>


 <servlet-mapping>
  <servlet-name>LoginServlet</servlet-name>
  <url-pattern>/login</url-pattern>
 </servlet-mapping>
 <servlet-mapping>
  <servlet-name>WelcomeServlet</servlet-name>
  <url-pattern>/welcome</url-pattern>
 </servlet-mapping>
 
</web-app>

index.html

<!DOCTYPE HTML>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>RequestDispatcherDemo</title>
</head>
<body>
 <form action="login" method="post">
  
  UserName :  <input type="text" name="username" /><br /> 
  
  Password :&nbsp; &nbsp; <input type="password" name="password" /><br /> 
   
  <input type="submit" value="login" />
  
 </form>
</body>
</html>

Environment Used

JDK version :1.6.0_30
Tomcat version : 7.0.50

To Download RequestDispatcherDemoApp Project Click the below link
https://sites.google.com/site/javaee4321/servlets/RequestDispatcherDemoApp.zip?attredirects=0&d=1

See also:

Servlets Tutorial

All Design Patterns Links

Wednesday, 9 April 2014

Servlets : RequestDispatcher Introduction

Level Up Your Java & Servlet Skills!

Subscribe to Ram N Java for beginner-friendly, deep-dive programming tutorials and clear backend architecture guides!

🔔 Subscribe to Ram N Java

What is RequestDispatcher in Java Servlets?

In Java web development, the RequestDispatcher interface is part of the javax.servlet package. It enables communication between web components on the server side by allowing one servlet to forward a client request or include the content of another resource, such as a servlet, JSP, or HTML page.

Because this process happens entirely on the server side, the client's browser is completely unaware of the dispatch. As a result, the URL shown in the browser address bar remains unchanged, and the original request and response objects are preserved.

How to Obtain a RequestDispatcher Instance

You can obtain a RequestDispatcher object in your servlet code through two primary methods:

Using ServletRequest: request.getRequestDispatcher("path") allows you to specify a relative path or an absolute path within the context.
Using ServletContext: getServletContext().getRequestDispatcher("/path") requires a path that begins with a slash (/), interpreted relative to the context root.

Forward vs. Include Methods

The RequestDispatcher interface defines two core methods to manage request routing:

forward(request, response): Passes full control to the destination resource. The target resource handles generating the final response sent back to the user.
include(request, response): Incorporates content from the target resource directly into the current servlet's response stream. This is ideal for reusing common components like navigation headers, banners, or footers across multiple pages.