Guide to JavaServer Pages (JSP)

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, visit the documentation page.

You can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Java applications have a notoriously slow startup and a long warmup time. The CRaC (Coordinated Restore at Checkpoint) project from OpenJDK can help improve these issues by creating a checkpoint with an application's peak performance and restoring an instance of the JVM to that point.

To take full advantage of this feature, BellSoft provides containers that are highly optimized for Java applications. These package Alpaquita Linux (a full-featured OS optimized for Java and cloud environment) and Liberica JDK (an open-source Java runtime based on OpenJDK).

These ready-to-use images allow us to easily integrate CRaC in a Spring Boot application:

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, you can get started over on the documentation page.

And, you can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Whether you're just starting out or have years of experience, Spring Boot is obviously a great choice for building a web application.

Jmix builds on this highly powerful and mature Boot stack, allowing devs to build and deliver full-stack web applications without having to code the frontend. Quite flexibly as well, from simple web GUI CRUD applications to complex enterprise solutions.

Concretely, The Jmix Platform includes a framework built on top of Spring Boot, JPA, and Vaadin, and comes with Jmix Studio, an IntelliJ IDEA plugin equipped with a suite of developer productivity tools.

The platform comes with interconnected out-of-the-box add-ons for report generation, BPM, maps, instant web app generation from a DB, and quite a bit more:

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.

The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

Get non-trivial analysis (and trivial, too!) suggested right inside your IDE or Git platform so you can code smart, create more value, and stay confident when you push.

Get CodiumAI for free and become part of a community of over 280,000 developers who are already experiencing improved and quicker coding.

Write code that works the way you meant it to:

The AI Assistant to boost Boost your productivity writing unit tests - Machinet AI.

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation.
Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code.
And, the AI Chat crafts code and fixes errors with ease, like a helpful sidekick.

Simplify Your Coding Journey with Machinet AI:

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.

The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

Since its introduction in Java 8, the Stream API has become a staple of Java development. The basic operations like iterating, filtering, mapping sequences of elements are deceptively simple to use.

But these can also be overused and fall into some common pitfalls.

To get a better understanding on how Streams work and how to combine them with other language features, check out our guide to Java Streams:

Do JSON right with Jackson

Get the most out of the Apache HTTP Client

Get Started with Apache Maven:

Working on getting your persistence layer right with Spring?

Building a REST API with Spring?

Get started with Spring and Spring Boot, through the Learn Spring course:

Explore Spring Boot 3 and Spring 6 in-depth through building a full REST API with the framework:

Get started with Spring and Spring Boot, through the reference Learn Spring course:

Yes, Spring Security can be complex, from the more advanced functionality within the Core to the deep OAuth support in the framework.

I built the security material as two full courses - Core and OAuth, to get practical with these more complex scenarios. We explore when and how to use each feature and code through it on the backing project.

You can explore the course here:

Table of Contents

1. Overview

JavaServer Pages (JSP) allows dynamic content injection into static contents using Java and Java Servlets. We can make requests to a Java Servlet, perform relevant logic, and render a specific view server-side to be consumed client-side. This article will provide a thorough overview of JavaServer Pages using Java 8 and Jave 7 EE.

We’ll start by exploring a few key concepts relevant to JSP: namely, the difference between dynamic and static contents, the JSP lifecycle, and JSP syntax as well as directives and the implicit objects created at compilation!

2. JavaServer Pages

JavaServer Pages (JSP) enabled Java-specific data to be passed into or placed within a .jsp view and consumed client-side.

JSP files are essentially .html files with some extra syntax, and a couple of minor initial differences:

1. the .html suffix is replaced with .jsp (it’s considered a .jsp filetype) and
2. the following tag is added to the top of the .html markup elements:

Let’s go over some of the key concepts in JSP.

2.1. JSP Syntax

There are two ways to add Java code to a .jsp. First, we can use basic Java Scriptlet syntax which involves placing Java code blocks within two Scriptlet tags:

The second method is specific to XML:

 Java code here 

Importantly, one can use conditional logic clientside with JSP by using if, then, and else clauses and then wrapping the relevant blocks of markup with those brackets.

 
Doodad!
 else < %>
Hello!
 %>

For example, if doodad is true, we would display the first, div element otherwise we would display the second, p element!

2.2. Static and Dynamic Contents

Static web contents are fixed assets that are consumed independently of RESTful, SOAP, HTTP, HTTPS requests, or other user-submitted information.

Static content, however, is fixed and is not modified by user inputs. Dynamic web contents are those assets that respond to, are modified by, or change in light of user actions or information!

JSP technology allows for the clean separation of responsibilities between dynamic and static contents.

The server (servlet) manages the dynamic contents and the client (the actual .jsp page) is the static context into which dynamic contents are injected.

Let’s take a look at the implicit objects that are created by JSP and which allow you to access JSP-relevant data server-side!

2.3. Implicit Objects

Implicit objects are generated by the JSP engine automatically during compilation.

Implicit objects include the HttpRequest and HttpResponse objects and expose various serverside functionalities for use in your servlet and for interacting with your .jsp! Here’s the list of implicit objects that are created:

request
request belongs to the class jakarta.servlet.http.HttpServletRequest. The request object exposes all user input data and makes it available serverside.

response
response belongs to the class jakarta.servlet.http.HttpServletResponse and determines what is passed back clientside after a request is made.

Let’s take a closer look at the request and response implicit objects since they’re the most important and heavily-used ones.

The example below demonstrates a very simple, incomplete, servlet method to handle GET requests. I’ve omitted most of the details so that we can focus on how to use the request and response objects:

protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException < String message = request.getParameter("message"); response.setContentType("text/html"); . . . >

First, we see that the request and response objects are passed in as parameters into the method making them available within its scope.

We can access request parameters using the .getParameter() function. Above, we snag the message parameter and initialize a string variable so we can use it in our server-side logic. We can also access the response object which determines what and how the data passed into the view will be.

Above we set the content type on it. We don’t need to return the response object to have it’s payload display on the JSP page at render!

out
out belongs to the class jakarta.servlet.jsp.JspWriter and is used to write content to the client.

There are at least two ways to print to your JSP page and its worth discussing both here. out is created automatically and allows you to write to memory and then to the response object:

out.print(“hello”); out.println(“world”);

The second approach can be more performant since it allows you to write directly to the response object! Here, we use PrintWriter:

PrintWriter out = response.getWriter(); out.println("Hello World");

2.4. Other Implicit Objects

Here are some other Implicit objects that are also good to know!

session
session belongs to the class jakarta.servlet.http.HttpSession maintains user data for the duration of the session.

application
application belongs to the class jakarta.servlet.ServletContext stores application-wide parameters set at initialization or that need to be accessed application-wide.

exception
exception belongs to the class jakarta.servlet.jsp.JspException is used to display error messages on JSP pages which have the tag .

page
page belongs to the class java.lang.Object allows one to access or reference current servlet information.

pageContext
pageContext belongs to the class jakarta.servlet.jsp.PageContext defaults to page scope but can be used for accessing request, application, and session attributes.

config
config belongs to the class jakarta.servlet.ServletConfig is the servlet configuration object allowing one to get the servlet context, name, and configuration parameters.

Now that we’ve covered the implicit objects provided by JSP, let’s turn to directives which allow .jsp pages to (indirectly) access some of these objects.

2.5. Directives

JSP supplies out of the box directives that can be used to specify core functionalities for our JSP files. There are two parts to JSP directives: (1) the directive itself and (2) the attribute of that directive which is assigned a value.

The three kinds of directives that can be referenced using directive tags are which defines dependencies and attributes of the JSP including content type and language, which specifies an import or file to be used, and which specifies a tag library defining custom actions to be used by a page.

So, as an example, a page directive would be specified using JSP tags in the following way:

2.6. Page Directive Attributes

There are a lot of attributes that can be declared within a page directive:

autoFlush

autoFlush controls the buffer output, clearing it out when the buffer size is reached. The default value is true.

buffer

buffer sets the size of the buffer used by our JSP page. The default value is 8kb.

errorPage

errorPage specifies a JSP page as an error page.

extends

extends specifies the super class of the corresponding servlet code.

info is used to set a text-based description for the JSP.

isELIgnored

isELIgnored states whether or not the page will ignore Expression Language (EL) in JSP. EL enables the presentation layer to communicate with Java managed beans and does so using $ syntax and while we won’t get into the nitty-gritties of EL here, there are several examples found below that are sufficient to build our example JSP app! The default value for isELIgnored is false.

isErrorPage

isErrorPage says whether or not a page is an error page. We must specify an error page if we create an error handler for our page within the application.

isThreadSafe

isThreadSafe has a default value of true. isThreadSafe determines whether or not the JSP can use Servlet multi-threading. In general, you would never want
to turn off that functionality.

language

language determines what scripting language to use in the JSP. The default value is Java.

session

session determines whether or not to maintain the HTTP session. It defaults to true and accepts values of true or false.

trimDirectiveWhitespaces

trimDirectiveWhitespaces stripes out white-spaces in the JSP page condensing the code into a more compact block at compile-time. Setting this value to true may help to reduce the size of the JSP code. The default value is false.

3. Three Examples

Now that we’ve reviewed the concepts central to JSP, let’s apply those concepts to some basic examples that will help you to get your first JSP-serving servlet up and running!

There are three main ways to inject Java into a .jsp and we’ll explore each of those ways below using native functionalities in Java 8 and Jakarta EE.

First, we’ll render our markup server-side to be displayed client-side. Second, we’ll look at how to add Java code directly into our .jsp file independent of jakarta.servlet.http‘s request and response objects.

Third, we’ll demonstrate how to both forward an HttpServletRequest to a specific .jsp and bind server-side processed Java to it.

Let’s set up our project in Eclipse using the File/New/Project/Web/Dynamic web project/ type to be hosted in Tomcat! You should see after creating the project:

|-project |- WebContent |- META-INF |- MANIFEST.MF |- WEB-INF |- lib |- src

We’re going to add a few files to the application structure so that we end up with:

|-project |- WebContent |- META-INF |- MANIFEST.MF |- WEB-INF |-lib *-web.xml |- ExampleTree.jsp |- ExampleTwo.jsp *- index.jsp |- src |- com |- baeldung *- ExampleOne.java *- ExampleThree.java

Let’s set up index.jsp which will be displayed when we access the URL context in Tomcat 8:

     
Simple JSP Examples
 
Invoke HTML rendered by Servlet: here
 
Java in static page: here
 
Java injected by Servlet: here
  

There are three a, each linking to one of the examples we’ll go through below in sections 4.1 through 4.4.

We also need to make sure that we’ve got our web.xml set up:

 index.html index.htm index.jsp  ExampleOne com.baeldung.ExampleOne  ExampleOne /ExampleOne 

A main note here is – how to correctly map each of our servlets to a particular servlet-mapping.Doing so associates each servlet with a specific endpoint where it can consumed! Now, we’ll go through each of the other files below!

3.1. HTML Rendered in Servlet

In this example, we’ll actually skip building a .jsp file!

Instead, we’ll create a string representation of our markup and then write it to the GET response with PrintWriter after ExampleOne Servlet receives a GET request:

public class ExampleOne extends HttpServlet < @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException < response.setContentType("text/html"); PrintWriter out = response.getWriter(); out.println( "" + "" + "" + "" + "" + "" + "
HTML Rendered by Servlet

" + "
This page was rendered by the ExampleOne Servlet!
" + "" + "" ); > >

What we’re doing here is injecting our markup through our servlet request handling directly. Instead of a JSP tag, we generate our HTML, along with any and all Java-specific data to be inserted, purely server-side without a static JSP!

Earlier, we reviewed the out object which is a feature of JspWriter.

Above, I used the PrintWriter object instead which writes directly to the response object.

JspWriter actually buffers the string to be written into memory which is then written to the response objects after the in-memory buffer is flushed.

PrintWriter is already attached to the response object. I’ve preferred to write directly to the response object in the examples above and below for those reasons.

3.2. Java in a JSP Static Content

Here we create a JSP file named ExampleTwo.jsp with a JSP tag. As seen above, this allows Java to be added directly into our markup. Here, we randomly print an element of a String[]:

     
Java in Static Page Example
 ; String greetings = arr[(int)(Math.random() * arr.length)]; %> 

Above, you’ll see that variable declaration within JSP tags objects: type variableName and an initialization just like regular Java.

I’ve included the above example to demonstrate how to add Java to a static page without making recourse to a specific servlet. Here, Java is simply added to a page and the JSP lifecycle takes care of the rest.

3.3. JSP With Forwarding

Now, for our final and most involved example! Here, we’re going to use the @WebServlet annotation on ExampleThree which eliminates the need for servlet mappings in server.xml.

@WebServlet( name = "ExampleThree", description = "JSP Servlet With Annotations", urlPatterns = ) public class ExampleThree extends HttpServlet < @Override protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException < String message = request.getParameter("message"); request.setAttribute("text", message); request.getRequestDispatcher("/ExampleThree.jsp").forward(request, response); >>

ExampleThree takes a URL parameter passed in as message, binds that parameter to the request object, and then redirects that request object to ExampleThree.jsp.

Thus, we’ve not only accomplished a truly dynamic web experience but we’ve also done so within an application containing multiple .jsp files.

getRequestDispatcher().forward() is a simple way to ensure that the correct .jsp page is rendered.

All the data bound to the request object sent its (the .jsp file’s) way will then be displayed! Here’s how we handle that last part:

     
Bound Value
 
You said: $ 

Note the JSP tag added to the top of ExampleThree.jsp. You’ll notice that I switched the JSP tags here. I’m using Expression Language (which I mentioned before) to render our set parameter (which is bound as $ )!

3.4. Try It Out!

Now, we’ll export our application into a .war to be launched and hosted in Tomcat 8! Find your server.xml and we’ll update our Context to:

Which will allow us to access our servlets and JSP’s on localhost:8080/spring-mvc-xml/jsp/index.jsp! Pick up a working copy over at: GitHub. Congrats!

4. Conclusion

We’ve covered quite a bit of ground! We’ve learned about what JavaServer Pages are, what they were introduced to accomplish, their lifecycle, how to create them, and finally a few different ways to implement them!

This concludes the introduction to JSP! Be well and code on!

Partner – DBSchema – NPI EA (tag = SQL)

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.

The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

Baeldung Pro – NPI EA (cat = Baeldung)

Baeldung Pro comes with both absolutely No-Ads as well as finally with Dark Mode, for a clean learning experience:

Once the early-adopter seats are all used, the price will go up and stay at $33/year.

Partner – Orkes – NPI EA (tag = Microservices)

Modern software architecture is often broken. Slow delivery leads to missed opportunities, innovation is stalled due to architectural complexities, and engineering resources are exceedingly expensive.

Orkes is the leading workflow orchestration platform built to enable teams to transform the way they develop, connect, and deploy applications, microservices, AI agents, and more.

With Orkes Conductor managed through Orkes Cloud, developers can focus on building mission critical applications without worrying about infrastructure maintenance to meet goals and, simply put, taking new products live faster and reducing total cost of ownership.

Partner – Microsoft – NPI EA (cat = Spring Boot)

Azure Container Apps is a fully managed serverless container service that enables you to build and deploy modern, cloud-native Java applications and microservices at scale. It offers a simplified developer experience while providing the flexibility and portability of containers.

Of course, Azure Container Apps has really solid support for our ecosystem, from a number of build options, managed Java components, native metrics, dynamic logger, and quite a bit more.

To learn more about Java features on Azure Container Apps, visit the documentation page.

You can also ask questions and leave feedback on the Azure Container Apps GitHub page.

Partner – Machinet – NPI EA (cat = Baeldung)

The AI Assistant to boost Boost your productivity writing unit tests - Machinet AI.

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation.
Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code.
And, the AI Chat crafts code and fixes errors with ease, like a helpful sidekick.

Simplify Your Coding Journey with Machinet AI:

Partner – DBSchema – NPI EA (tag = Spring Data JPA)

DbSchema is a super-flexible database designer, which can take you from designing the DB with your team all the way to safely deploying the schema.

The way it does all of that is by using a design model, a database-independent image of the schema, which can be shared in a team using GIT and compared or deployed on to any database.

And, of course, it can be heavily visual, allowing you to interact with the database using diagrams, visually compose queries, explore the data, generate random data, import data or build HTML5 database reports.

Partner – Bellsoft – NPI EA (cat = Spring)

Looking for the ideal Linux distro for running modern Spring apps in the cloud?

Meet Alpaquita Linux: lightweight, secure, and powerful enough to handle heavy workloads.

This distro is specifically designed for running Java apps. It builds upon Alpine and features significant enhancements to excel in high-density container environments while meeting enterprise-grade security standards.

Specifically, the container image size is ~30% smaller than standard options, and it consumes up to 30% less RAM:

Partner – Codium – NPI EA (cat = Testing)

Explore the secure, reliable, and high-performance Test Execution Cloud built for scale. Right in your IDE:

Basically, write code that works the way you meant it to.

Partner – Machinet – NPI EA (cat = Testing)

AI is all the rage these days, but for very good reason. The highly practical coding companion, you'll get the power of AI-assisted coding and automated unit test generation.
Machinet's Unit Test AI Agent utilizes your own project context to create meaningful unit tests that intelligently aligns with the behavior of the code.

Simplify Your Coding Journey with Machinet AI:

Course – LS – NPI EA (cat=REST)

Get started with Spring Boot and with core Spring, through the Learn Spring course: