JSP Implicit Objects

Because every JSP page is compiled into a servlet, the container automatically declares a set of ready-to-use objects inside the generated _jspService() method, without you ever declaring or importing them. These are the JSP implicit objects, and JSP defines exactly nine of them, each corresponding to something a plain servlet would otherwise have to obtain manually.

The Nine Implicit Objects

Each implicit object gives access to a specific part of the request-handling environment, and most map directly onto objects you already know from servlet programming.

• request — the current HttpServletRequest, for reading parameters, headers, and attributes.
• response — the current HttpServletResponse, for setting headers or redirecting.
• session — the current HttpSession (unless the page explicitly disables sessions via the page directive).
• application — the ServletContext, shared across the entire web application, useful for app-wide data.
• out — a JspWriter used to write output to the response body; buffered, unlike a raw PrintWriter.
• config — the ServletConfig for this JSP's generated servlet, giving access to init parameters.
• pageContext — a JSP-specific object that provides access to all scopes (page, request, session, application) through one unified API.
• page — a reference to the current servlet instance itself (equivalent to "this"), rarely used directly.
• exception — available only on pages marked as an error page (via the isErrorPage="true" page directive), giving access to the exception that triggered the error page.

Scope and pageContext

JSP defines four attribute scopes: page (this request/response cycle within this page only), request (survives a forward to another resource), session (survives across a user's requests), and application (shared by every user of the app). pageContext.setAttribute(name, value, scope) lets you set an attribute in any of these four scopes from one API, which is useful when writing reusable code that shouldn't assume which scope it's working with.

out vs response.getWriter()

out is not simply response.getWriter() — it is a JspWriter, which adds buffering on top. This buffering is why you can still call response.sendRedirect() or set headers partway through a JSP page in some cases: as long as the JSP's output buffer hasn't been flushed yet, the response has not been "committed," so headers can still be changed. Mixing raw use of the underlying writer with out is not recommended, since it can produce output in the wrong order.

Examples

<html><body>
  <p>Requested URI: <%= request.getRequestURI() %></p>
  <p>Session ID: <%= session.getId() %></p>

  <%
      application.setAttribute("visitCount",
          ((Integer) (application.getAttribute("visitCount") == null
              ? 0 : application.getAttribute("visitCount"))) + 1);
  %>
  <p>Total application-wide visits: <%= application.getAttribute("visitCount") %></p>

  <% out.println("<p>Written directly through the implicit 'out' object.</p>"); %>
</body></html>

Browser output (visit count shared by every user of the app):
Requested URI: /webnest/welcome.jsp
Session ID: 9F1A2B3C...
Total application-wide visits: 5
Written directly through the implicit 'out' object.

<%@ page isErrorPage="true" %>
<html><body>
  <h3>Something went wrong</h3>
  <p>Error message: <%= exception.getMessage() %></p>
</body></html>

Browser output when another page throws an exception and forwards here (via <%@ page errorPage="error.jsp" %>):
Something went wrong
Error message: / by zero

Exercise

Using the lesson's Several implicit objects used together on one page example, create a small implementation or design sketch that demonstrates JSP defines nine implicit objects: request, response, session, application, out, config, pageContext, page, and exception.. Add a test case or scenario that would catch Trying to use the "exception" implicit object on a normal page that is not marked isErrorPage="true" — it causes a compile error there., and describe the expected result.

Quick quiz

Interview questions