RequestDispatcher: Forward vs Include

Servlets frequently need to hand off processing to another resource — often a JSP that renders the final HTML, or another servlet that handles a sub-task. Java provides three distinct mechanisms for this, and mixing them up is one of the most common sources of confusing bugs in servlet-based applications: RequestDispatcher.forward(), RequestDispatcher.include(), and HttpServletResponse.sendRedirect().

The key distinction is server-side vs client-side. Forward and include both happen entirely on the server, within the same request; sendRedirect tells the browser to make an entirely new, separate request.

forward() — Hand Off Control, Same Request

RequestDispatcher.forward(request, response) transfers control to another resource on the server, within the same request and response objects. Any attributes set with request.setAttribute() before the forward are still visible to the target resource — this is the standard way a controller servlet passes data to a JSP view. The browser's address bar does not change, because the browser is never told a redirection happened; it only ever sees the response from the final resource. Anything written to the response before the forward should generally be avoided, since forward is meant to hand off rendering, not append to it.

include() — Embed Another Resource's Output

RequestDispatcher.include(request, response) executes another resource and inserts its output into the current response, then returns control back to the original servlet, which can continue writing more content afterward. This is useful for composing a page out of reusable fragments — a header, a footer, or a sidebar — much like a template include. Unlike forward, the including resource retains control and can write both before and after the include call.

sendRedirect() — A New Request From the Browser

response.sendRedirect(url) sends an HTTP 302 (or 303) status back to the browser with a Location header; the browser then issues a brand-new GET request to that URL. This is client-side: the address bar changes to the new URL, request attributes from the original request are lost (because it truly is a new request), and it works for redirecting to external sites, unlike forward/include which only work within the same application's resources.

• forward() — server-side, same request, URL unchanged, attributes preserved.
• include() — server-side, embeds output, control returns to caller.
• sendRedirect() — client-side, new request, URL changes, attributes lost, can target external URLs.

Examples

import java.io.IOException;
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 ProductServlet extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {
        request.setAttribute("productName", "Wireless Mouse");
        request.setAttribute("price", 799.00);

        // Server-side hand-off: URL stays "/products", attributes are visible in the JSP
        RequestDispatcher dispatcher = request.getRequestDispatcher("/WEB-INF/views/product.jsp");
        dispatcher.forward(request, response);
    }
}

Browser address bar remains: /products
Rendered page (from product.jsp using ${productName} and ${price}):
Product: Wireless Mouse
Price: 799.0

// Option A: forward — address bar stays "/checkout"
request.getRequestDispatcher("/WEB-INF/views/confirmation.jsp").forward(request, response);

// Option B: sendRedirect — address bar changes to "/confirmation", new GET request issued
response.sendRedirect("confirmation");

Forward: bar shows /checkout while confirmation.jsp renders. Redirect: browser navigates to /confirmation with a fresh request; refreshing the page does not resubmit the original form data.

Exercise

Using the lesson's Controller servlet forwarding to a JSP view with request attributes example, create a small implementation or design sketch that demonstrates forward() and include() are server-side and share the same request/response; sendRedirect() is client-side and creates a new request.. Add a test case or scenario that would catch Using sendRedirect() after a form POST and expecting request.getAttribute() values to still be available in the next page — a redirect starts a brand-new request., and describe the expected result.

Quick quiz

Interview questions