JavaRush /Java Blog /Random EN /What is JSP? Let's explore the possibilities in practice
Анзор Кармов
Level 31

What is JSP? Let's explore the possibilities in practice

Published in the Random EN group
JSP or Java Server Pages is a Java technology that allows you to create dynamic web pages for Java applications. In this article we will talk in more detail about what JSP is, discuss some of the capabilities of this technology, look at the structure of JSP pages, and also try to take a practical look at what these Java Server Pages are. What is JSP?  Understanding the possibilities in practice - 1But first, let's talk about the benefits and importance of JSP. JSP allows the developer to:
  • receive data from a web page into Java code;
  • send data from Java code to a web page;
  • write Java code directly inside html (however, you should not abuse this).
The need for JSP knowledge can be assessed quite highly for several reasons:
  • JSP is one of the main Java web technologies;
  • JSP is widely used in most companies and projects;
  • JSP integrates seamlessly with Java servlets inside a servlet container.

JSP Definition

Here's a definition from Wikipedia: JSP (JavaServer Pages) is a technology that allows web developers to create content that has both static and dynamic components. A JSP page contains two types of text: static source data, which can be in one of the text formats HTML, SVG, WML, or XML, and JSP elements, which construct dynamic content. In addition, JSP tag libraries can be used, as well as Expression Language (EL) to embed Java code into the static content of JSP pages. The JSP page code is translated into servlet Java code using the Jasper JSP page compiler, and then compiled into Java Virtual Machine (JVM) bytecode. Servlet containers capable of executing JSP pages are written in the platform-independent Java language. JSP technology is a platform-independent, portable and easily extensible technology for developing web applications.

JSP page structure

In general, JSP refers to dynamic web pages in which the dynamic part is generated using Java, and the static part is generated using markup languages, most often HTML. Such a page is a text document with the .jsp extension, written in one of the markup languages ​​(such as HTML, SVG, WML and XML), interspersed with JSP elements (or JSP tags). These tags contain calls to the server code (data) and also perform some calculations. These files are processed on the server, as a result of which all JSP tags are converted into html tags, and the output is a regular html page. The diagram below shows a diagram of the structure of a JSP page and its interaction with the server. What is JSP?  Understanding the possibilities in practice - 2An example of a simple JSP page:
    <p> ${2 + 2} равно 4 </p>
In this example, a JSP expression written in a special language, Expression Language (EL), is “embedded” inside the html code . It provides an important mechanism for interaction between the presentation layer (web pages) and the application business logic layer (Java code). As you can see from the example, the JSP expression is enclosed in curly braces, with a leading dollar sign - ${...}. Everything that is inside the curly braces is evaluated on the server, and the result of this expression is given in html, in the place where the JSP expression was originally defined. After processing all the tags, the page will look like this:
    <p> 4 равно 4 </p>

Installing and running the servlet container

Since the JSP code is translated into Java servlet code, we need to get some kind of servlet container somewhere so that we can talk about how the JSP works. Otherwise, without a container, JSP will not work. But first, let's look at the definition of a servlet container. A servlet container is a program that is a server that provides system support for servlets and ensures their life cycle in accordance with the rules defined in the specifications. It can work as a full-fledged independent web server, be a page provider for another web server, or integrate into a Java EE application server. One of the most popular servlet containers is Apache Tomcat. What is JSP?  Understanding the possibilities in practice - 3It is worth mentioning that Tomcat is not a full-fledged Java EE application server. However, for the vital needs of servlets and JSP pages, the Tomcat server is more than enough. Let's start the installation. You can download Tomcat from the official page . For Windows OS you can install Tomcat as follows:
  1. Download 32-bit/64-bit Windows Service Installer.

  2. Let's run the file.

  3. Next, follow the usual installation procedure:

    1. Don’t forget to check the Examples checkbox on the corresponding installer window:

      What is JSP?  Understanding the possibilities in practice - 4
    2. and specify the path to the preinstalled JRE:

      What is JSP?  Understanding the possibilities in practice - 5
  4. After installation, launch Tomcat and open the browser. Go to http://localhost:8080/ .

If you see the Tomcat start page, it means the installation was successful and the server is running. To start and stop Tomcat manually, you can run one of two executable files in the bin directory. It is located inside the directory where Tomcat is installed: What is JSP?  Understanding the possibilities in practice - 6

Demo applications. Hidden objects

Let's look at some JSP features in action. One of them is access to so-called hidden objects ( Implicit Objects ). These are objects that can be accessed using the Expression Language (EL). Examples of such objects are HTTP headers or URL parameters. Let's reveal (or refresh our memory) what URL parameters are. The example below shows a URL with parameters. Parameters are in bold: ?param1=value1¶m2=value2&a=1&name=Tom Parameters always begin with a question mark (?). This is followed by the name of the parameter, followed by the equal sign - the value of the parameter is determined. There can be several or one parameters. If there is more than one, each name-value pair is separated by an ampersand character (&). In the example above, several parameters and their values ​​were defined:
Parameter name Parameter value
param1 value1
param2 value2
a 1
name Tom
Let's take a look at how you can access hidden objects in JSP, including URL parameters. To do this, launch Tomcat and open the browser on the page http://localhost:8080/ Then go to the Examples page: What is JSP?  Understanding the possibilities in practice - 7Then follow the link JSP Examples: What is JSP?  Understanding the possibilities in practice - 8On the examples page follow the link Implicit Objects -> Execute: What is JSP?  Understanding the possibilities in practice - 9On this page you can see an example of use hidden objects. Below is a screenshot of the page with detailed explanations: What is JSP?  Understanding the possibilities in practice - 10Try changing the value of the parameter foousing the corresponding field on the page, then notice that the value of this parameter has also changed in the address bar. The presented page does not have much functionality, but it is a good reference that you can refer to in the future when you need to access a particular hidden object. This page contains a list of hidden objects that can be accessed. And below, in the table, it is demonstrated how you can access a particular object.

JSP functions

Now let's go back to the previous page and take a look at the source code of the “hidden objects” page: What is JSP?  Understanding the possibilities in practice - 11Here it is:
<%@page contentType="text/html; charset=UTF-8" %>
<%@ taglib prefix="fn" uri="" %>

    <title>JSP 2.0 Expression Language - Implicit Objects</title>
    <h1>JSP 2.0 Expression Language - Implicit Objects</h1>
    This example illustrates some of the implicit objects available
    in the Expression Language.  The following implicit objects are
    available (not all illustrated here):
      <li>pageContext - the PageContext object</li>
      <li>pageScope - a Map that maps page-scoped attribute names to
          their values</li>
      <li>requestScope - a Map that maps request-scoped attribute names
          to their values</li>
      <li>sessionScope - a Map that maps session-scoped attribute names
          to their values</li>
      <li>applicationScope - a Map that maps application-scoped attribute
          names to their values</li>
      <li>param - a Map that maps parameter names to a single String
          parameter value</li>
      <li>paramValues - a Map that maps parameter names to a String[] of
          all values for that parameter</li>
      <li>header - a Map that maps header names to a single String
          header value</li>
      <li>headerValues - a Map that maps header names to a String[] of
          all values for that header</li>
      <li>initParam - a Map that maps context initialization parameter
          names to their String parameter value</li>
      <li>cookie - a Map that maps cookie names to a single Cookie object.</li>

      <u><b>Change Parameter</b></u>
      <form action="implicit-objects.jsp" method="GET">
          foo = <input type="text" name="foo" value="${fn:escapeXml(param["foo"])}">
          <input type="submit">
        <table border="1">
            <td><b>EL Expression</b></td>
            <td>${fn:escapeXml(param["foo"])} </td>
            <td>${fn:escapeXml(param["foo"])} </td>
            <td>${fn:escapeXml(header["host"])} </td>
            <td>${fn:escapeXml(header["accept"])} </td>
            <td>${fn:escapeXml(header["user-agent"])} </td>
If you are familiar with HTML, the source code of the page should be quite clear to you. Pay attention to these lines:
  <td>${fn:escapeXml(param["foo"])} </td>
Here we see html tags <tr>and <td>. The tags are followed by <td>JSP tags, wrapped in curly braces ${ }. However, notice how the value of the URL parameter is output foo:
The value is output through the use of a JSP function fn:escapeXml(). JSP functions encapsulate some functionality that can be reused. In this case, it's XML escaping. JSP technology provides a wide range of functions to choose from, as well as the ability to create your own functions. To use a function in a JSP, you must import the appropriate library in which the function is defined into the JSP file.

Tag libraries

Let's take a look at another line of source code (second line) above:
<%@ taglib prefix="fn" uri="" %>
This is how tag libraries are imported. The syntax is intuitive. We define several things:
  • taglib(tag library - tag library);
  • url, where this library is located;
  • a prefix (in this case fn) through which it will be possible to call functions defined in this library.
In the example above, we looked at importing functions. Specifically, in our example, we imported the JSTL (JSP Standard Tag Library) library. JSTL is a standard tag library that contains a set of different libraries that come with every servlet and JSP implementation, including Tomcat. Another popular tag library is core, which can be imported like this:
<%@ taglib uri = "" prefix = "c" %>
As with fn, the notation cis optional and generally accepted. This designation can be found almost everywhere where these libraries are used. Here is an example of a function from the core library:
<c:out value = "${'<div>'}"/>
This function will simply output the tag <div>. This function already does XML escaping. This function is important from a security point of view, because by outputting the value of variables directly, through ${variable}, we open the door to script injection.

JSP Editing

Now, armed with new knowledge, let's try to make changes to the demo application inside Tomcat. To do this, we will find the source code of this page inside the folder in which this servlet container was installed. This file can be found at the following address: ...\Apache Software Foundation\Tomcat 9.0\webapps\examples\jsp\jsp2\el Then open the file implicit-objects.jsp in any text editor Add the import of the core library, and then use it Let's output some text: What is JSP?  Understanding the possibilities in practice - 12Now let's refresh the hidden objects page and take a look at the changes made: What is JSP?  Understanding the possibilities in practice - 13


So, we have superficially examined such technology as JSP. We discussed:
  • what is JSP;
  • JSP page structure;
  • procedure for installing and running the Tomcat servlet container;
  • demo application for accessing hidden objects, which is included in the Tomcat server distribution package;
  • JSP functions and tag libraries.

What's next?

To secure the material you can:
  1. Repeat everything described in this article.
  2. Consider other demo applications included with the Tomcat server.
  3. Write your own application and deploy it to a servlet container. As a guide, you can use the article Creating a simple web project in IntelliJ Idea Enterprise. Step by step, with pictures.