JSP Directives and Actions

Beyond scripting elements, JSP has two other tag families that control how a page is processed: directives, which configure page-level settings understood at translation time, and actions, which perform tasks at request time using XML-style tags. Both look similar to scripting tags but serve very different purposes, and confusing the two is a common source of mistakes for beginners.

Directives: page, include, taglib

A directive gives the container instructions about the page as a whole, processed during translation rather than at request time. Directives use the syntax <%@ directiveName attribute="value" %>.

• page — configures page-wide settings such as contentType, import (for Java classes used in scriptlets/expressions), session (enable/disable), errorPage, and isErrorPage.
• include — performs a static, translation-time include of another file's raw content, merging it into this page's source before compilation (different from the include action below, which happens at request time).
• taglib — declares a tag library prefix, such as <%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>, which is required before using JSTL tags like <c:forEach>.

Standard Actions

Actions use XML tag syntax (<jsp:actionName />) and execute at request time, unlike directives. The most commonly used standard actions mirror the servlet mechanisms you already know: <jsp:forward page="target.jsp" /> transfers control to another resource (like RequestDispatcher.forward), <jsp:include page="fragment.jsp" /> includes another resource's output at request time (like RequestDispatcher.include, and distinct from the include directive), and <jsp:useBean>/<jsp:setProperty>/<jsp:getProperty> work with JavaBean objects in a given scope.

Include Directive vs Include Action

This distinction trips up many learners: the include directive (<%@ include file="header.jsp" %>) merges the included file's source at translation time, before compilation — so it behaves as if you had pasted the content in by hand, and any change to the included file requires the including page to be recompiled to take effect. The include action (<jsp:include page="header.jsp" />) instead calls the target resource at request time and inserts its live output, meaning the included page can be changed independently and always reflects its latest compiled version.

Examples

<%@ page contentType="text/html;charset=UTF-8" import="java.util.List" %>
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>

<html><body>
  <jsp:include page="/WEB-INF/views/header.jsp" />

  <h2>Product List</h2>
  <ul>
    <c:forEach var="item" items="${productList}">
      <li>${item}</li>
    </c:forEach>
  </ul>

  <jsp:include page="/WEB-INF/views/footer.jsp" />
</body></html>

Browser output (assuming productList = ["Mouse", "Keyboard"]):
[header content]
Product List
- Mouse
- Keyboard
[footer content]

<%-- forward: control leaves this page entirely, URL logic handled server-side --%>
<jsp:forward page="/WEB-INF/views/thankyou.jsp" />

<%-- include: output of cart-summary.jsp is embedded here, and this page continues after it --%>
<jsp:include page="/WEB-INF/views/cart-summary.jsp" />
<p>Continue shopping below.</p>

With jsp:forward, only thankyou.jsp's output reaches the browser. With jsp:include, cart-summary.jsp's output appears, followed by "Continue shopping below."

Exercise

A teammate is about to make this mistake: Confusing the include directive (<%@ include %>, translation-time, static) with the include action (<jsp:include />, request-time, dynamic). Use Directives: page, include, taglib to review the decision. Write a corrected implementation or design sketch that follows Directives (page, include, taglib) configure the page at translation time; actions (jsp:forward, jsp:include, jsp:useBean) execute at request time., then name one edge case you would check.

Quick quiz

Interview questions