Jakarta EE Programming/Jakarta Server Pages Syntax

The JavaServer Pages is a technology for inserting dynamic content into an HTML or XML page using a Java servlet container. In other word, instead of sending HTML pages to web clients that are always the same for every one, you can send HTML pages that can be different for each client and each time they receive it (using database data for instance). To explain it, let's have a simple HTML page on a web server. The data flow is simple. To put it simply, the client requests a HTML page by sending the page URL and the server returns the given HTML page:

Here are the HTML file and the display on the client:

The returned page is always the same. Now we want to display the current time. To do so, we add a servlet container to the web server. The HTML page will no longer exist on the server. When the page will be requested by a client, a Java class will generate the HTML page and the HTML page will be sent to the client. This Java class is called a servlet:

Here are the Java class, the generated HTML file and the display on the client:

Now the page is dynamic but the servlet is hard to code and to read. So we will use a JavaServer Page (JSP). A JSP is written like a HTML page. It has the file extension  for HTML page and the file extension   for an XML markup page. In addition to the HTML syntax, it has embedded scriptlets and jsp tags. A scriptlet is a portion of Java code. The servlet container generates a servlet from the JSP and the servlet will be used to generate HTML pages or XML content. The HTML markups will remains as it is. The embedded scriptlets are inserted into the code of the servlet. The jsp tags are transformed into Java code. So let's use a JSP:

Actually, the servlet is generated by the JSP only for the first request call. The same servlet is reused after then. It is generated again when the JSP will change. Now we have a JSP, that generates a servlet, that generates a HTML page, that will be displayed to the client:

Scripting elements
There are three basic kinds of scripting elements that allow java code to be inserted directly into the JSP. <%! int serverInstanceVariable = 1; %> Declaration tags also allow methods to be defined. <%!   /**     * Converts the Object into a string or if     * the Object is null, it returns the empty string. */   public String toStringOrBlank(Object obj) { if (obj != null) { return obj.toString; }       return ""; } %> <% int localStackBasedVariable = 1; out.println(localStackBasedVariable); %> <%= "expanded inline data " + 1 %> <%-- This is my first JSP. --%>
 * A declaration tag places a variable definition inside the body of the java servlet class. Static data members may be defined as well. Also inner classes can be defined here.
 * A scriptlet tag places all of the statements contained within it, inside the  method of the java servlet class.
 * An expression tag places an expression to be evaluated inside the java servlet class. Expressions should not be terminated with a semi-colon.
 * A comment tag does nothing. It is ignored. It lets you document the file. It is different from a HTML comment as a HTML comment will appear in the generated HTML file.

Directives
JSP directives are added at the top of a JSP page. These directives control how the JSP compiler generates the servlet. The following directives are available:

<%@ include file="somefile.jspf" %>
 * include : The include directive informs the JSP compiler to include a complete file into the current file. It is as if the contents of the included file were pasted directly into the original file. This functionality is similar to the one provided by the C preprocessor. Included files generally have the extension "jspf" (for JSP Fragment):


 * page : The page directive has several attributes:

<%@ page import="java.util.*" %> <%-- example import --%> <%@ page contentType="text/html" %> <%-- example contentType --%> <%@ page isErrorPage="false" %> <%-- example for non error page --%> <%@ page isThreadSafe="true" %> <%-- example for a thread safe JSP --%> <%@ page session="true" %> <%-- example for using session binding --%> <%@ page autoFlush="true" %> <%-- example for setting autoFlush --%> <%@ page buffer="20kb" %> <%-- example for setting Buffer Size --%>
 * Note: Only the "import" page directive can be used multiple times in the same JSP.

<%@ taglib prefix="myprefix" uri="taglib/mytag.tld" %>
 * taglib : The taglib directive indicates that a JSP tag library is to be used. The directive requires a prefix (much like a namespace in C++) and the URI for the tag library description.

Example
Regardless of whether the JSP compiler generates Java source code for a servlet or emits the byte code directly, it is helpful to understand how the JSP compiler transforms the page into a Java servlet. For example, consider the following input JSP and its resulting generated Java Servlet.

Implicit objects
We have seen that we can declare objects in a scriplet that we can use further. There are also already declared objects that can be used by the programmer. They are called implicit object:

JSP actions
JSP actions are XML tags that invoke built-in web server functionality. They are executed at runtime. Some are standard and some are custom (which are developed by Java developers). The following are the standard ones.

jsp:include
Like the include directive, this tag includes a specified jsp into the returned HTML page but it works differently. The Java servlet temporarily hands the request and response off to the specified JavaServer Page. Control will then return to the current JSP, once the other JSP has finished. Using this, JSP code will be shared between multiple other JSPs, rather than duplicated.

jsp:param
Can be used inside a,   or   block. Specifies a parameter that will be added to the request's current parameters.

jsp:forward
Used to hand off the request and response to another JSP or servlet. Control will never return to the current JSP. In this forwarding example, the request is forwarded to.

jsp:plugin
Older versions of Netscape Navigator and Internet Explorer used different tags to embed an applet. This action generates the browser specific tag needed to include an applet. The plugin example illustrates an HTML uniform way of embedding applets in a web page. Before the advent of the  tag, there was no common way of embedding applets. Currently, the  tag does not allow for dynamically called applets. For example,  cannot be used with a charting applet that requires the data points to be passed in as parameters unless the number of data points is constant. You cannot, for example, loop through a ResultSet to create the  tags. Each  tag must be hand-coded.

jsp:fallback
The content to show if the browser does not support applets.

jsp:getProperty
Gets a property from the specified JavaBean.

JSP tag libraries
In addition to the pre-defined JSP actions, developers may add their own custom actions using the JSP Tag Extension API. Developers write a Java class that implements one of the Tag interfaces and provide a tag library XML description file that specifies the tags and the java classes that implement the tags.

Consider the following JSP.

<%@ taglib uri="mytaglib.tld" prefix="myprefix" %> …  <%-- The start tag --%> …  <%-- The end tag --%> …

The JSP compiler will load the mytaglib.tld XML file:

The JSP compiler will see that the tag  is implemented by the java class  : The first time the tag is used in the file, it will create an instance of. Then (and each additional time that the tag is used), it will invoke the method  when it encounters the starting tag. It looks at the result of the start tag, and determines how to process the body of the tag. The body is the text between the start tag and the end tag. The  method may return one of the following:

Note: If tag extends the  class, the method   will be called when the body has been processed just prior to calling the. This method is used to implement looping constructs.

When it encounters the end tag, it invokes the  method. The method may return one of two values:

If you want to iterate the body a few times, your java class (tag handler) must implement the  interface. It returns  &mdash; which means to invoke the body again.

JSP Standard Tag Library (JSTL)
The JavaServer Pages Standard Tag Library (JSTL) is a component of the Java EE Web application development platform. It extends the JSP specification by adding a tag library of JSP tags for common tasks, such as XML data processing, conditional execution, loops and internationalization.

Struts Tag Library
The Struts project includes the Struts Tag Library, the bulk of which is useful independently of the Struts architecture.

Internationalization
Internationalization in JSP is accomplished the same way as in a normal Java application, that is by using resource bundles.

Expression Language
The Expression Language (EL) is a faster/easier way to display parameter values. It is available since JSP 2.0. For instance, it allows developers to create Velocity-style templates: Same as

It also offers a clearer way to navigate nested beans. Consider some beans:

Then, if an instance of Person was to be placed onto a request attribute under the name "person", the JSP would have:

Same as.

JSP Technology in the Java EE 5 Platform
The focus of Java EE 5 has been ease of development by making use of Java language annotations that were introduced by J2SE 5.0. JSP 2.1 supports this goal by defining annotations for dependency injection on JSP tag handlers and context listeners.

Another key concern of the Java EE 5 specification has been the alignment of its webtier technologies, namely JavaServer Pages (JSP), JavaServer Faces (JSF), and JavaServer Pages Standard Tag Library (JSTL).

The outcome of this alignment effort has been the Unified Expression Language (EL), which integrates the expression languages defined by JSP 2.0 and JSF 1.1.

The main key additions to the Unified EL that came out of the alignment work have been: A pluggable API for resolving variable references into Java objects and for resolving the properties applied to these Java objects, Support for deferred expressions, which may be evaluated by a tag handler when needed, unlike their regular expression counterparts, which get evaluated immediately when a page is executed and rendered, and Support for lvalue expression, which appear on the left hand side of an assignment operation. When used as an lvalue, an EL expression represents a reference to a data structure, for example: a JavaBeans property, that is assigned some user input. The Unified EL is defined in its own specification document, which is delivered along with the JSP 2.1 specification.

Thanks to the Unified EL, JSTL tags, such as the JSTL iteration tags, can be used with JSF components in an intuitive way.

JSP 2.1 leverages the Servlet 2.5 specification for its web semantics.

Model-view-controller paradigm
A model-view-controller pattern can be used with the JSP files in order to split the presentation from request processing and computer data storage. Either regular servlets or separate JSP files are used to process the request. After the request processing has finished, control is passed to a JSP used only for creating the output. There are several platforms based on Model-view-controller pattern for web tiers (such as Barracuda, Apache Struts, Stripes, and the Spring MVC framework).

Environment
Both the Java Server (J2EE specification) and the page scripts and/or extended customised programming added operate by (in the runtime context of being loaded programs used) a special pre-installed base program called a Virtual Machine that integrates with the host Operating System, this type being the Java Virtual Machine (JVM).

Because either, both a Compiler-JVM set (called an SDK or JDK) or the lone JVM (called a JRE, Java Runtime Environment) is made for most computer platform OSs and the compiled programs for the JVM are compiled into special Java Byte code files for the JVM the Byte-code files (compiled Java program .class files) can be effectively transferred between platforms with no requirement to be recompiled excepting versioning compatibility, or special circumstance. The source code for these J2EE servlet or J2EE JSP programs is almost always supplied with J2EE JSP material and J2EE Web Applications because the server must call the compiler when loading them. These small extension programs (custom tags, servlets, beans, page scripting) are variable and likely to be updated or changed either shortly before runtime or intermittently but particularly when sending JSP page requests themselves,  it requires the JSP server to have access to a Java compiler (SDK or JDK) and the required source code (not simply the JVM JRE and byte code class files) to successfully exploit the method of serving.

JSP syntax has two basic forms, scriptlet and markup though fundamentally the page is either HTML or XML markup. Scriptlet tagging (called Scriptlet Elements) (delimited) blocks of code with the markup are not effectively markup and allows any java server relevant API (e.g. the servers running binaries themselves or database connections API or java mail API) or more specialist JSP API language code to be embedded in an HTML or XML page provided the correct declarations in the JSP file and file extension of the page are used. Scriptlet blocks do not require to be completed in the block itself only the last line of the block itself being completed syntactically correctly as a statement is required, it can be completed in a later block. This system of split inline coding sections is called step over scripting because it can wrap around the static markup by stepping over it. At runtime (during a client request) the code is compiled and evaluated, but compilation of the code generally only occurs when a change to the code of the file occurs. The JSP syntax adds additional XML-like tags, called JSP actions, to be used to invoke built-in functionality. Additionally, the technology allows for the creation of JSP tag libraries that act as extensions to the standard HTML or XML tags. JVM operated Tag libraries provide a platform independent way of extending the capabilities of a Web server. Note that not all company makes of Java servers are J2EE specification compliant.

Programmation JEE/JSP Programmeren in Java/JSP