JSP Technology II

© People Strategists www.peoplestrategists.com Slide 1 of 45

JSP Technology -II


In this session, you will learn to:

Work with JSTL tags

Identify custom tags

Implement EL

Objectives


Working with JSTL

What is JSTL?


Working with JSTL (Contd.)


JSP was introduced with a vision of segregating the UI-related code and the business logic-related code in Web applications.

However, the use of scriptlets in a JSP page does not fulfill the preceding requirement.

In addition, the use of scriptlets leads to readability and maintenance issues.

Therefore, JSTL was introduced to solve these problems.

JSTL is a tag library that consists of predefined tags to perform common tasks in JSP pages, such as:

Iterating over a list of items.

Formatting the page output according to a specific condition.



JSTL contains several types of tags.

JSTL tags are classified into the following categories according to their functions:

Core tags

Formatting tags

Database tags

The core tags are used to perform the following tasks:

Implementing flow control

Iterating through a list

Implementing URL rewriting

Redirecting users to a new URL

Creating a URL with query parameters



The core tags are divided into the following four groups, depending on the function performed by the tags:

Variable support tags: Are used to access and manipulate the values of variables in a JSP page. JSTL consists of two variable support tags, <set> and <remove>.

Flow control tags: Are used to implement flow control in a JSP page. JSTL consists of four flow control tags, <choose>, <forEach>, <forTokens>, and <if>.

URL tags: Are used to perform tasks, such as rewriting URLs for session management, including the contents of another page in a JSP page, and redirecting a user to a JSP page. Some of the JSTL URL management tags are, <import>, <redirect>, and <URL>.

Miscellaneous tags: Are used to output the value of a variable or property or to implement exception handling. JSTL consists of two miscellaneous tags, <out> and <catch>.

Identifying JSTL Core Tags


The following table describes some of the JSTL core tags along with their syntax:

Tag Description Syntax

<out>Is used to display text or the value

of a variable<c:out value=”Output Value”/>

<set>Is used to assign a value to a

variable or property

<c:set var=”varName”

value=”value”

[scope=”{page|request|session|app

lication}”]/>

<if> Is used to evaluate a condition

<c:if test=”expression”

var=”varName”

[scope=”{page|request|session|app

lication}”] >

body </c:if>

<choose>

Is used to evaluate a condition. It is similar to the switch…case

construct in Java

<c:choose>

When conditions

</c:choose>

<when>

Is the child tag of the <choose>

tag. It is similar to the case statement of a switch…case

construct

<c:choose>

<c:when test condition>

</c:when>

</c:choose>

Identifying JSTL Core Tags (Contd.)



<otherwise>

Is the child tag of the

<choose> tag. It is similar

to the default clause of the

switch…case construct

<c:otherwise>

Message text

</c:otherwise>

<import>

Is used to specify the

names of the files to be

inserted during the

compilation of the JSP

page

<c:import url="URL of the file

to be imported"/>

<forEach>Is used to iterate over a

collection of objects

<c:forEach items=”collection”

[var=”varName”]

[varStatus=”varStatusName”]

[begin=”begin”] [end=”end”]

[step=”step”]>

body content

</c:forEach>

<url>Is used to perform URL

rewriting<c:url value='URL'/>

<redirect>Is used to redirect a user to

a specific URL

<c:redirect url="URL to which

the user should be redirected/>



To use JSTL core tags, you need to add a taglib directive in the desired JSP page, as shown in the following code snippet:

<%@ taglib prefix="c"

uri="http://java.sun.com/jsp/jstl/core" %>

The following code snippet depicts the use of, <out>, the core tag in a JSP page:

<%@taglib prefix="c"


<html>

<head>

<title>Core Tags</title>

</head>

<body>

<c:out value="Hello there ! "/>

</body>

</html>



The following code snippet depicts how to retrieve input variables in a requested JSP page using JSTL:

<%@taglib

uri="http://java.sun.com/jsp/jstl/core"

prefix="c"%>

<html>

<body bgcolor="lightblue">

<form method=post action="jstldemo1.jsp">

NAME <input type=text name="text1"><br>

PLACE<input type=text name="text2"><br>

<input type=submit>

</form>

NAME:<c:out value="${param.text1}" /><br>

PLACE:<c:out value="${param.text2}" />

</body>

</html>

jstldemo1.jsp



The following code snippet depicts how to evaluate conditions using the <if> tag in JSTL:

<%@ page contentType="text/html" %>



<html>

<body bgcolor="lightgray">

<form method=post action="CheckCondition.jsp">

<select name="combo1">

<option value="sam">sam

<option value="tom">tom

</select>

<input type=submit value="Press me">

</form>

<c:set var="s" value="${param.combo1}" />

<strong> <br>

<c:if test="${s eq 'sam' }" >

<c:out value="Good Morning...SAM!" />

</c:if>

<c:if test="${s == 'tom'}" >

<c:out value=" How Are You?....TOM!" />

</c:if> </strong>

</body>

</html>

CheckCondition.jsp



Consider a scenario where you need to create a JSP page using JSTL. The JSP page should be based on the following guideline:

Identify the day of week and display it on Web page.

Saturday and Sunday should be displayed as weekend.

By default weekend should be displayed on Web page.

The Web page should be displayed as shown in the following figure.

Activity: Using Conditional Construct in JSTL

The Expected Output


The following code snippet depicts how to use the forEach loop in JSTL:





<html>

<body bgcolor=lightblue>

<% pageContext.setAttribute("colors", new String[]

{"red","green","blue","orange","black"} ); %>

<table border=1 bgcolor="cyan" width="50%">

<c:forEach var="n" items="${colors}" varStatus="a">

<tr align="center">

<td><c:out value="${a.index}" /> </td>

<td> <c:out value="${a.count}" /> </td>

<td> <c:out value="${a.first}" /> </td>

<td> <c:out value="${a.last}" /> </td>

<td> <c:out value="${a.current}" /> </td>

</tr> </c:forEach>

</table>

</body>

</html>


The following code snippet depicts how to use the import tag in JSTL:


<html>

<body>

WELCOME

<br>

</body>

</html>




<html>

<body bgcolor=lightblue>

<c:import url="welcome.html"/>

<c:out value="to our web-site!" />

</body>

</html>

Welcome.html ImportDemo.jsp


The following code snippet depicts how to link a Web page in JSTL:

The following code snippet depicts how to redirect a Web page in JSTL:




<html>

<body>

<a href="<c:url value="welcome.html"/>">send </a>

</body>

</html>



<html>

<body>

<c:redirect url="welcome.html" />

</body>

</html>


Formatting tags are used to format and display text, numbers, date, or time in a specific format.

Some of the formatting tags include:

<formatNumber>

<parseNumber>

<formatDate>

<timeZone>

<setLocale>

Identifying JSTL Formatting Tags


The following code snippet depicts the use of a formatting tag in a JSP page:

Identifying JSTL Formatting Tags (Contd.)

<%@taglib prefix="fmt"

uri="http://java.sun.com/jsp/jstl/fmt" %>

<html>

<head>

<title>Formatting Tags</title>

</head>

<body>

<fmt:formatNumber value="123000.4509"

type="currency"/>

</body>

</html>


Database tags are used to interact with relational databases, such as Microsoft SQL Server and Oracle.

The following table describes some of the JSTL database tags along with their syntax.

Identifying JSTL Database Tags


<setDataSource>

Is used to specify the name of the data source that needs to be used in the Web application

<sql:setDataSource var="data source name" driver="driver name" url="data source URL" user="database user id" password="database password"/>

<query>

Is used to specify the query that needs to be executed against the data source, such as a SELECT or INSERT query

<sql:query dataSource="name of the data source" var="name of the database">

//SQL statement to be executed

</sql:query>

<param>Is used to specify the value for a SQL command parameter

<sql:query dataSource="name of the data source" var="name of the database">

<sql:param value="parameter value" />

</sql:query>

<transaction>Is used to execute SQL statements as part of a transaction

<sql:transaction dataSource="name of the data

source"> Body Content </sql:transaction>


The following code snippet depicts the use of the database tag in a JSP page:

Identifying JSTL Database Tags (Contd.)

<%@taglib prefix="sql"

uri="http://java.sun.com/jsp/jstl/sql" %>

<html>

<head>

<title>Core Tags</title>

</head>

<body>

<sql:setDataSource var="db"

driver="com.microsoft.sqlserver.jdbc.SQLServerDriver"

url="jdbc:sqlserver://PC1:1433;databaseName=EmployeeDB;

user=sa;password=pass#1234"/>

<sql:query dataSource="${db}" var="result">

SELECT * from Emplyee;

</sql:query>

</body>

</html>


Identifying Custom Tags

What is custom tag?


Identifying Custom Tags (Contd.)


Custom tags can be classified into the following categories:

Empty tags: Refer to the custom tags that do not have any attribute or bodyand are used to display simple information, such as the current date or a message. The following code snippet shows an empty custom tag:

<td:welcome />

Tags with attributes: Refer to the custom tags that have attributes. Attributes allow a developer to customize the behavior of custom tags. The following code snippet shows a custom tag with an attribute named color:

<td: welcome color=”blue”></td:welcome>

Tags with a body: Refer to the custom tags that contain nested custom tags, scripting elements, actions, HTML text, and JSP directives. The following code snippet shows a custom tag that contains a JSP scripting element as its body:

<td:welcome>

<%=today_date%>

</td:welcome>



The advantages of custom tags are:

They separate Java code from a JSP page.

They can be reused in different JSP pages.

They support standard Web application development job roles.

A custom tag consists of:

Tag handler: Consists of definitions of the classes and methods that define the functionality of the tag.

Tag Library Descriptor (TLD) file: Is an XML file that describes the tag library.



A tag handler is a Java class that is used by the Web container to evaluate a custom tag during the execution of the JSP page that references the tag.

A tag handler class file derives its methods from the javax.servlet.jsp.tagext package and implements the Tag, SimpleTag, or BodyTag interfaces.

The Tag interface is implemented for tags with an empty body and the SimpleTag and BodyTag interfaces are implemented for tags that use a body.

Creating a Tag Handler


The following table describes the classes of the javax.servlet.jsp.tagext package.

Creating a Tag Handler (Contd.)

Class Description

BodyContentIs a subclass of the JSPWriter class and represents the body content of a tag

TagSupport Acts as a base class for tag handlers and implements empty tags

BodyTagSupportImplements the BodyTag interface. This class is used to develop custom tags with body

SimpleTagSupportIs a base class for tag handlers that implement the SimpleTaginterface

TagData Represents the attributes and their values

TagInfo

Represents the information specified in the <tag></tag> element of the TLD file. This class is used by the JSP engine while translating a JSP page to a servlet

TagLibraryInfoRepresents the information of the TLD file, such as the tags it defines and versioning information

TagVariableInfo Represents information about the variables of a custom tag


To create a tag handler, you need to define the functionality of a custom tag by using the following methods of the Tag interface:


Method Description

doStartTagIs invoked when the Web container encounters the start tag of a custom tag.

doEndTagIs invoked when the Web container encounters the end tag of a custom tag.

release Is invoked to release the instance of the tag handler.


The following table lists some of the methods that need to be implemented according to the structure of the tag handler.


Structure of the Tag Handler Methods to be Implemented

Simple tag with no body and no attributes

doStartTag, doEndtag, and release

Tag with attributes doStartTag, doEndtag, and the

respective setAttribute and

getAttribute methods

Tags with body doStartTag, doEndTag, release,

doInitBody, doAfterBody

Tags that implement the SimpleTag interface

doTag()


The TLD file is an XML file that contains the tag library description.

The components of a TLD file can be categorized into two groups:

The first group consists of the elements that are part of the root tag of the TLD or the taglib tag.

The second group, placed within the taglib tag, consists of the elements that are a part of the tag element.

The taglib element is written as <taglib> and the tag element as <tag>.

Identifying the TLD File


The following table describes some of the sub tags of the <taglib> element.

Identifying the TLD File (Contd.)

Sub tag Specify

<tlib-version>The version of the tag library, such as <tlib-version>1.0</tlib-version>

<jsp-version>The version of JSP that the tag library depends on, such as <jsp-version>1.2</jsp-version>

<short-name> The name for the tag library

<uri>The universal resource identifier—an optional component that is a

unique id for the tag library

<tag> The details of a custom tag


The following table describes some of the sub tags of the <tag> element.


Sub tag Specify

<tag-class> The name of the tag handler of a custom tag

<body-content> Specifies the format of the body content of a custom tag

<name> The name of a custom tag


The following code snippet shows a sample TLD file:

<taglib version="2.1"

xmlns="http://java.sun.com/xml/ns/javaee"

xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"

xsi:schemaLocation="http://java.sun.com/xml/ns/javaee

http://java.sun.com/xml/ns/javaee/web-

jsptaglibrary_2_1.xsd">

<tlib-version>1.0</tlib-version>

<jsp-version>2.0</jsp-version>

<short-name>tld1</short-name>

<uri>/WEB-INF/tlds/tld1</uri>

<tag>

<name>TestTag</name>

<tag-class>FirstServlet</tag-class>

</tag>

</taglib>



Consider a scenario where you are assigned for a task that displays current time on every Web page at the top left corner. For this, you need to use custom tag so that you will create the custom tag once and can use it number of times in future. The custom tag should display output as shown in the following figure.

Activity: Implementing Custom Tags

The Expected Output


Expression Language (EL):

is used extensively in JSTL tags.

can be used to create dynamic JSP pages.

EL is a scripting language that allows programmers to use simple expressions to access and manipulate:

application data stored in JavaBeans components.

implicit objects.

Java classes.

collections elements.

scoped variables.

Implementing EL


EL expressions can be used in the following ways:

As attribute values:

EL expressions can be used as attribute values in standard and custom tags.

The attribute values are replaced by the values generated after the evaluation of

EL expression.

The following code snippet shows the use of an EL expression as an attribute

value in the include tag:

<jsp:include page=”${location}”>

As text in a JSP page:

EL expressions can be used as text in a JSP page.

The text is displayed on the JSP page after the evaluation of an EL expression.

The following code will display a welcome message along with the value stored in

the variable, name:

<h1>Welcome ${name}</h1>

Implementing EL (Contd.)


EL provides implicit objects that can be used to easily access all implicit objects and scoped variables of JSP.

The following table describes some of the EL implicit objects.


Implicit Object Description

pageContext Represents the JSP PageContext object for the current page

pageScope Maps the names and values of page-scoped variables or attributes

requestScope Maps the names and values of request-scoped variables or attributes

sessionScope Maps the names and values of session-scoped variables or attributes

applicationScope Maps the names and values of application-scoped variables or attributes

param Provides access to a request parameter value

paramValues Provides access to request parameter values as String arrays

initParam Maps a context initialization parameter name to a single value

cookie Maps a cookie name to a single cookie

headerValues Maps a request header name to an array of values

header Maps a request header name to a single value


EL can also be used to access JavaBeans.

A JavaBean:

is a simple Java class that exposes internal fields as properties using the corresponding getter and setter methods.

is a reusable and a self-contained software component that takes advantage of all the security and platform-independent features of Java.

can be included in a JSP page to start processing user requests.

The following code snippet sets and retrieves the value of the firstName property from a bean named customer:

<jsp:setProperty name="customer"

property="firstName" value="Sam" />

<h2>${customer.firstName}</h2>



EL supports the following types of operators:

Arithmetic operators

Relational operators

Logical operators

The following table describes the different arithmetic operators supported by EL.


Operator Description

+ It represents the addition operator.

- It represents the subtraction operator.

* It represents the multiplication operator.

/ and div It represents the division operator.

% and mod It represents the remainder operator.


The following table describes the different relational operators supported by EL.



== and eq It represents the equality operator.

!= and ne It represents the not equal to operator.

< and lt It represents the less than operator.

> and gt It represents the greater than operator.

<= and le It represents the less than or equal to operator.


The following table describes the different logical operators supported by EL.



&& and and It represents the AND operator.

|| and or It represents the OR operator.

! and not It represents the NOT operator.


The following program illustrates how to sends the request to the process.jsp which in turn prints the name of the user using EL.


<html>

<body>

<form action="process.jsp">

Enter name:<input

type="text"

name="name"/><br/><br/>

<input type="submit"

value="go"/>

</form>

</body>

</html>

Default.jsp

<html><body>

Welcome, ${ param.name }

</body>

</html>

p1.jsp


The following program illustrates how to store value in the sessionobject and retrieve it sessionScope object using EL.


<html>

<body>

<h3>welcome to default

page</h3>

<%

session.setAttribute("user",

"peter");

%>

<a href="p1.jsp">Click here

</a> </body>

</html>

Default.jsp

<html><body>

Variable value is = ${

sessionScope.user }

</body>

</html>

p1.jsp


Consider a scenario where you need to display the values entered in a Web page and a context parameter value defined inside the web.xml file inside the requested page. In addition, you are required to display session details and set the background color of the requested Web page using the pageContext object.

Activity: Implementing EL in JSP

The Expected Output

The Expected Output


JSTL is a component of Java EE platform that contains a library of JSP tags, which are required to perform common tasks in JSP pages.

JSTL tags are classified into the following categories according to their functions:

Core tags

Formatting tags

Database tags

To use JSTL core tags, you need to add a taglib directive in the desired JSP page.

A custom tag provides a mechanism that can be used by a Web developer to encapsulate complex recurring code or tasks.

Custom tags can be classified into the following categories:

Empty tags

Tags with attributes

Tags with a body

Summary


To create custom tags, you need to perform the following tasks:

Create a tag handler.

Create the TLD file.

A tag handler is a Java class that is used by the Web container to evaluate a custom tag during the execution of the JSP page that references the tag.

EL is a scripting language that allows programmers to use simple expressions to access and manipulate the properties of a JSP page.

EL expressions can be used in the following ways:

As attribute values

As text in a JSP page

Summary (Contd.)