Course: Advanced Java Training
Topic: Understanding JSP Scriptlets, Expressions, and Declarations
Course Link: Advanced Java Training Course
Demo Link: Register for a Course Demo
Website: JustAcademy
JavaServer Pages (JSP), known as Jakarta Server Pages in modern Jakarta EE environments, is a server-side technology used to create dynamic web pages. It allows developers to combine HTML markup with dynamic values and server-side application data. A JSP page is processed by a JSP container, which translates the page into a servlet implementation and compiles it when required.
JSP provides three traditional scripting elements for embedding Java code into a page: scriptlets, expressions, and declarations. Each element has a different purpose and is processed according to its role in the generated servlet.
These scripting elements are important for understanding legacy JSP applications. In modern JSP development, Expression Language (EL), JSTL, servlets, and Java classes are generally preferred because they keep presentation separate from application logic.
After completing this topic, learners should be able to:
JSP scripting elements are special JSP syntax structures that allow Java code to interact with template content. The JSP container processes these elements when generating the servlet implementation.
| Scripting Element | Syntax | Main Purpose | Typical Use |
|---|---|---|---|
| Scriptlet | <% ... %> |
Execute Java statements | Conditions, loops, and request-time processing in legacy pages |
| Expression | <%= ... %> |
Write an expression's value to the response | Displaying a calculated or retrieved value |
| Declaration | <%! ... %> |
Declare fields and methods in the generated servlet class | Legacy page-level fields or helper methods |
Although all three elements contain Java code, they do not behave identically. Their placement in the generated servlet affects variable scope, execution, output, and concurrency.
A JSP scriptlet is a block of Java statements embedded in a JSP page. Its code is executed when the generated servlet processes a request. A scriptlet can contain local variable declarations, conditional statements, loops, method calls, and other valid Java statements.
<%
// Java statements go here
%>The opening tag <% starts the scriptlet, and %> ends it. Unlike a JSP expression, a scriptlet does not automatically print the result of a statement. Output must be produced explicitly or through the surrounding template.
<%
String message = "Welcome to Advanced Java";
out.println(message);
%>Explanation:
message stores a string.out implicit object writes content to the JSP response output.<%
int marks = 78;
if (marks >= 40) {
out.println("Result: Pass");
} else {
out.println("Result: Fail");
}
%>This example checks whether the marks meet the passing threshold. The selected message is written to the response. In a real application, the marks would normally be calculated or retrieved by a Java service rather than hard-coded in a JSP.
<%
for (int i = 1; i <= 5; i++) {
out.println("<p>Number: " + i + "</p>");
}
%>The loop runs five times and writes five HTML paragraph elements. The browser renders those elements as separate lines of content.
Scriptlets can be combined with static HTML, allowing a page to conditionally display template content.
<%
boolean loggedIn = true;
%>
<html>
<body>
<%
if (loggedIn) {
%>
<h2>Welcome back!</h2>
<%
} else {
%>
<h2>Please log in.</h2>
<%
}
%>
</body>
</html>This is valid as a scripting example, but it becomes difficult to maintain when large amounts of Java code are mixed with HTML. A controller and a tag-based view are generally better for new applications.
A JSP expression evaluates a single Java expression and inserts its result into the response output. The value is converted to its textual representation by the JSP processing mechanism.
<%= expression %>A JSP expression does not require a semicolon at the end because it represents an expression rather than a sequence of Java statements.
<p>Course: <%= "Advanced Java Training" %></p>The string value is inserted into the generated HTML response.
<p>Total: <%= 100 + 250 %></p>
<p>Discount: <%= 500 * 0.10 %></p>The first expression evaluates to 350, while the second evaluates to 50.0. These values are included in the response as text.
<p>Current server time:
<%= new java.util.Date() %>
</p>This example displays the date and time produced by the server when the page is processed. The exact result depends on the server's clock and time-zone configuration.
<%
String studentName = "Aarav";
%>
<p>Student Name: <%= studentName %></p>The scriptlet declares a local variable, and the expression writes its value to the response. The variable is available here because the scriptlet and expression are translated into the same JSP service-processing context.
if or for directly inside an expression.Security warning: Never assume that a JSP expression safely renders untrusted input. Directly inserting user-supplied text into HTML can create a cross-site scripting (XSS) vulnerability. Use appropriate output encoding or trusted escaping tags.
A JSP declaration defines a field or method in the generated JSP servlet class. Unlike a scriptlet, which is placed inside the request-processing method, a declaration is placed at class level.
<%!
// Field or method declaration
%>Declarations do not directly produce output. Their fields and methods may be referenced by scriptlets and expressions in the same JSP page, subject to normal Java access and scope rules.
<%!
int pageVisits = 0;
%>This declares a field on the generated servlet instance. It is not a separate local variable for each request. If the JSP servlet instance is shared across requests, concurrent requests can access the same field.
Important: A field like pageVisits is not a reliable or thread-safe way to count visitors. Multiple requests may access or modify it concurrently, and the value may reset when the JSP is recompiled or the application restarts. Use a suitable counter service or carefully designed concurrent data structure if shared counting is genuinely required.
<%!
public String getCourseName() {
return "Advanced Java";
}
%>
<p>Course: <%= getCourseName() %></p>The declaration defines a method on the generated servlet class. The JSP expression calls that method and inserts its returned string into the response.
<%!
private static final String COURSE_NAME =
"Advanced Java Training";
%>
<p>Course: <%= COURSE_NAME %></p>This example declares a constant and displays it. Although a constant is safer than mutable shared state, application-wide constants and reusable business logic are generally better placed in ordinary Java classes.
| Feature | Scriptlet | Expression | Declaration |
|---|---|---|---|
| Syntax | <% ... %> |
<%= ... %> |
<%! ... %> |
| Purpose | Execute Java statements | Write a value to the response | Define fields or methods |
| Generated location | Inside the request-processing method | As output-writing code in the request-processing method | At class level in the generated servlet |
| Typical execution | During request processing | During request processing | Field initialization follows Java class and instance initialization rules |
| Direct output | Only if code writes output | Yes, the evaluated value is written | No |
| Can declare a local variable? | Yes | No; it evaluates an expression | Can declare a field at class level |
| Can define a method? | Not as a method declaration in the method body | No | Yes |
| Concurrency consideration | Local variables are generally request-local | Depends on the data accessed | Mutable fields may be shared across concurrent requests |
| Modern recommendation | Avoid in new view code | Prefer EL for ordinary view data | Move reusable logic to Java classes |
A JSP container processes scripting elements while translating a JSP page into a servlet implementation. The exact generated source is container-dependent, but the conceptual mapping helps explain their different behavior.
<%
String name = "Aarav";
%>Conceptually, this code becomes a local variable declaration inside the generated request-processing method.
<%= name %>Conceptually, the container generates code that evaluates the expression and writes its result to the output writer.
<%!
private String getMessage() {
return "Welcome";
}
%>Conceptually, this method becomes a method of the generated servlet class, outside the request-processing method.
The JSP specification defines the required behavior, but developers should not depend on implementation-specific generated source details.
One of the most important differences between scriptlets and declarations is where their variables live.
<%
int total = 10;
total = total + 5;
%>
<p>Total: <%= total %></p>The variable total is local to the request-processing method. It is not a field shared across all requests to the JSP servlet.
<%!
int total = 10;
%>
<%
total++;
%>
<p>Total: <%= total %></p>This example uses a mutable field shared by requests handled by the same servlet instance. Concurrent requests can update it at the same time, potentially producing race conditions and unpredictable results. Avoid this pattern for request-specific values.
JSP provides implicit objects that can be accessed directly in scripting elements. They are supplied by the JSP container and do not need to be declared by the developer.
| Object | Purpose | Example |
|---|---|---|
request |
Provides information about the current HTTP request | request.getParameter("name") |
response |
Represents the HTTP response | response.setContentType("text/html") |
out |
Writes output to the response | out.println("Welcome") |
session |
Represents the current HTTP session, if enabled | session.getAttribute("user") |
application |
Provides access to the web application's servlet context | application.getAttribute("siteName") |
pageContext |
Provides access to page context and JSP-related facilities | pageContext.getRequest() |
config |
Provides servlet configuration information | config.getServletName() |
page |
Refers to the current generated JSP servlet object | Used rarely in normal page code |
<%
String username = request.getParameter("username");
if (username == null || username.isBlank()) {
username = "Guest";
}
%>
<p>Welcome, <%= username %>!</p>This example reads a query or form parameter and supplies a fallback when the value is absent. In production, the value must also be encoded appropriately before being inserted into HTML. A servlet controller and an escaping tag are preferable to direct rendering.
The following example demonstrates a scriptlet, an expression, and a declaration within one JSP page. It is intended for learning syntax rather than as a recommended production design.
<%@ page contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<%!
private String getCourseLevel() {
return "Advanced";
}
%>
<%
String courseName = "Java Web Development";
int duration = 30;
int completedDays = 12;
int remainingDays = duration - completedDays;
%>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>JSP Scripting Example</title>
</head>
<body>
<h1>Course Information</h1>
<p>Course: <%= courseName %></p>
<p>Level: <%= getCourseLevel() %></p>
<p>Duration: <%= duration %> days</p>
<p>Completed: <%= completedDays %> days</p>
<p>Remaining: <%= remainingDays %> days</p>
<%
if (remainingDays > 0) {
%>
<p>Your course is in progress.</p>
<%
} else {
%>
<p>Your course is complete.</p>
<%
}
%>
</body>
</html>getCourseLevel().| Problem | Reason | Solution |
|---|---|---|
| JSP compilation error | Invalid Java syntax or mismatched JSP delimiters | Check opening and closing tags and verify Java syntax. |
| Expression does not compile | A statement was used instead of an expression | Use a valid Java expression and remove an unnecessary semicolon. |
| Scriptlet variable is undefined | Variable scope or declaration order is incorrect | Declare the local variable in a compatible scope before use. |
| Method cannot be found | Method declaration is missing or its signature is incorrect | Verify the declaration syntax and method name. |
| Unexpected shared value | A declaration field is shared between requests | Use a local variable or properly managed application component. |
| Incorrect output | Wrong expression, data type, or calculation | Check the expression and inspect server logs. |
| HTML appears as text | Output has been escaped or encoded differently than intended | Check the rendering context and intended output encoding. |
| Untrusted input creates unsafe markup | Input is printed without context-appropriate encoding | Use an escaping mechanism and validate input. |
| Changes do not appear | Stale deployment or browser cache | Refresh the browser and verify the deployed application. |
For new JSP pages, developers should usually prepare values in a controller and display them with EL. JSTL can handle common presentation operations without embedding Java statements in the page.
request.setAttribute("courseName", "Advanced Java");
request.setAttribute("courseDuration", 30);
request.getRequestDispatcher("/course.jsp")
.forward(request, response);<%@ page contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8" %>
<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<title>Course Details</title>
</head>
<body>
<h1>Course Details</h1>
<p>Course: ${requestScope.courseName}</p>
<p>Duration: ${requestScope.courseDuration} days</p>
</body>
</html>This approach separates request handling from presentation. For untrusted or user-generated values, use context-appropriate output encoding; EL alone does not guarantee safe HTML rendering.
Answer: JSP scripting elements are constructs that embed Java code in JSP pages. The three traditional elements are scriptlets, expressions, and declarations.
Answer: A scriptlet uses <% ... %> and contains Java statements executed during request processing.
Answer: A JSP expression uses <%= ... %> and writes the evaluated expression's value to the response output.
Answer: A JSP declaration uses <%! ... %> to declare fields or methods in the generated servlet class.
Answer: No. A standard JSP expression represents a single Java expression, so a trailing semicolon is not required.
Answer: No. A scriptlet executes statements. To write output, it must use an output mechanism such as the JSP out object, or the page must use a separate expression or template element.
Answer: A variable declared inside a scriptlet is normally local to the generated request-processing method. A field declared with <%! ... %> belongs to the generated servlet class and may be shared across concurrent requests handled by the same instance.
Answer: Yes. A declaration can define a method that is available to other scripting elements in the same JSP page.
Answer: Mutable fields may be accessed by multiple requests concurrently. Unsynchronized updates can cause race conditions and incorrect results.
Answer: Scripting elements embed Java code directly in JSP. EL provides a simpler way to access data and properties for presentation, usually without writing Java statements.
Answer: Generally, no. EL, JSTL, servlets, and Java classes usually produce cleaner and more maintainable code.
Answer: Validate inputs and encode untrusted values according to the output context. Use a trusted escaping tag or library rather than printing raw user-provided values.
<% ... %> represents a scriptlet.<%= ... %> represents an expression.<%! ... %> represents a declaration.Understanding JSP scriptlets, expressions, and declarations helps developers read, debug, and maintain Java web applications. Scriptlets execute Java statements, expressions display evaluated values, and declarations define fields or methods in the generated servlet class. Although these constructs remain important for understanding existing JSP code, modern applications benefit from using servlets or framework controllers, Java service classes, Expression Language, and JSTL to separate application logic from presentation.
By learning the syntax, scope, execution behavior, and limitations of each scripting element, developers can avoid common compilation errors, reduce concurrency risks, and build more maintainable web applications.
Explore the Advanced Java Training Course to learn more about JSP, Servlets, JDBC, and enterprise web application development.
To learn more about the course, visit the Course Demo Registration Page or the JustAcademy Website.
Official references: Jakarta Server Pages Specification and Jakarta EE Guide to Servlets and Server Pages.
