JSP Tag Libraries

Tag Libraries
JSTL
The “Classic” Custom Tag Event Model
Custom Tag

#JSTL #CustomTag #Dynamic

 Review
• JSP Standard Actions
– jsp:method attribute
• Java Beans
– jsp:useBean, jsp:setPropety, jsp:getProperty
– Scopes: page, request, session, application
• Dispatching Mechanisms
– jsp:include, jsp:forward, jsp:param
• Expression Language – EL
– ${EL Expression}
– Operators, Implicit Objects, Scope Variables
– Functions
– Coersions
 Objectives
• How to remove all java code in JSP (View)?
Complete the MVC 2 Design Pattern with
View
– JSTL
• How to build the data grid tag library using in
JSP?
– Tag Libraries
• Model
• Classical, Simple, and Handles
• How to implement the custom Tag Lib and use it in JSP
 Objectives
Day 1, 2, 3, 4, 5, 6 – Login
Servlet, JDBC

Day 7, 8, 9 – Search
Break Down

Day 10, 11 – MVC2

JSP
Web Day 12, 13, 14, 15 – CUD, Shopping Carts
Web based
App - PBL Sessions

Day 16, 17 – Login

JavaBeans

Day 18, 19, 20 – CRUD

MVC 2 Complete - JSTL - Taglib

Day 21, 22, 23 – Filter

MVC2 Using Filter as Controller
 Complete MVC 2
Requirements
• Complete the MVC 2 with CRUD Web Application in previous topic
Complete MVC 2
Requirements
Complete MVC 2
Requirements
Complete MVC 2
Expectation
 JSTL
JSP Standard Tag Library
• Is a new component being offered by the Sun for JSP
programming.
• A library of predefined tags (by Sun) that provides a set of
reusable standard tags that works in the similar manner
everywhere
• Allows programming using tags rather than scriptlet code
JSTL has reusable standard set of tags.
• Provides the user with a script-free environment
• Are easier for non-programmers & inexperienced
programmers
• Disadvantages
– It adds processing overhead to the server. The tag libraries are
compiled into a servlet, which is then executed by the servlet
container. The server is added with much more code by the JSTL.
– JSTL is also less powerful than the scriptlets as embedded java
codes can do everything in JSP pages
 JSTL
Type of Tag Library

JSP Standard Tag Library (JSTL)

Core Tag I18N &

SQL Tag XML Tag
EL Functions Formatting
Library Library Library
Tag Library
 JSTL
Core Tag Library
• The library contains the tags for looping,
expression evaluation, handle flow controls, and
basic input and output.
• It can be declared by
<%@ taglib prefix=“c” uri= “http://java.sun.com/jsp/jstl/core” %>
• General Purpose Tags
– Are used to set, remove and display variable values
that are created within a JSP page.
– The core tag library contains tags for getting, setting
and displaying attribute values.
 JSTL
Core Tag Library – General Purposes
Tags Descriptions

- <c:set var=“varName” value=“value/exp”

scope=“page|request|session|application” />
- Assigns or update a value to a variable in scope
- Similar to set attribute to some scope using setAttribute() method
- Ex: <c:set var=”simple” value=”${2+1}” scope=“session”/>
<c:set>
- Similar to <% session.setAttribute(“simple”, new Integer(2+1)) %>
- The var of set can be accessed using
${varName} on page, or
${scope.varName} on page or other pages, or
<%= scope.getAttribute(“varName”) %>
- <c:remove var=“varName”
scope=“page|request|session|application” />
- Remove a scope variable. This is an empty tag
<c:remove> - Similar to remove attribute from some scope using
removeAttribute() method
- Ex : <c:remove var=”simple” scope=”session”/>
- Similar to <% session.removeAttribute(”simple”) %>
 JSTL
Core Tag Library – General Purposes
Tags Descriptions

- <c:out value=“value|expression” escapeXml=“true|false”

default=“defaultValue” />
- Evaluate an expression & store the result in the current
JspWrite object
<c:out>
- Default value if the resulting value is null
- Similar to print out the data using out object in JSP Implicit Object
- Ex: <c:out value=”${simple}”/>
similar to <%= pageContext.getAttribute(simple) %>
- <c:catch [var=”varName”]>…</c:catch>
<c:catch> - Provides an exception handling functionality, such as try-catch,
inside JSP pages without using scriptlets
 JSTL
Requirement
• Required Library for JSTL
– JSTL 1.2.2 (jstl-impl.jar, jstl-api.jar)

• Choose JSTL 1.2.2

 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – Decision Making
• Support conditions in a JSP page
• Are necessary as the contents or the output of the JSP page is often
conditional based on the value of the dynamic application data
Tags Descriptions
- <c:if test =“testcondition” var=“varName” scope=“page | request |
session | application”>…</c:if>
<c:if> - Is used for conditional execution of the code
- Is a container tag that allows the execution of the body if the test
attribute evaluates to true
- <c:choose>
<c:when test=”cond”>...</c:when>
<c:otherwise>…</c:otherwise>
</c:choose>
<c:choose> - Is similar to the switch statement in Java (multiple conditions)
- Performs conditional block execution (replace to c:if)
- Multiple <c:when> tags can be embedded in a <c:choose> tag
- If none of the conditions evaluates to true, then the body of
<c:otherwise> tag is processed.
 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – Example
 JSTL
Example
• Improve the 6th topic using EL combining with JSTL
JSTL
Example
JSTL
Example
 JSTL
Core Tag Library – Iterations
• Is required for performing looping function
• The object can be retrieved from a collection in the JavaBeans
component and assigned to a scripting variable by using iteration tags
Tags Descriptions

- <c:forEach var=“varName” items=“collection” begin=“begin”

end=“end” step=“step”
varStatus=“internalLoopobject”>…</c:forEach>
<c:forEach> - Is used repeat the body content over a collection of objects
- Will continue for a number of times specified by the user in the
code
- varStatus’s methods: count (int), current (obj), index (int)
- <c:forTokens items=“stringofToken” delims=“delimiters”
var=“varName” >...</c:forTokens>
<c:forTokens> - Is used to iterate over a collection of tokens separated by user-
specified delimiters
- It is a container tag
 JSTL
Core Tag Library – Example
 JSTL
Core Tag Library – URL-Related Actions
• Are used to import resources from a given URL, re-encode URLs, redirect to
URLs, as well as pass additional request parameters where necessary
Tags Descriptions

- <c:import url=“url of resource import” var=“varName”

scope=“scopeName”>…</c:import>
- Imports the content of a URL-based resource.
<c:import>
- Action main include nested <c:param> tags to specify the query
string (unless the varReader attribute is specified).
- Ex: <c:import var=“xml” url=“WEB-INF/abc.xml”/>
- <c:url var=“varName” value=”path” scope=”scopeName” >...</c:url>
- Builds a URL with the proper rewriting rules applied (only relative
URLs are rewritten).
<c:url>
- Action may include nested <c:param> tags to specify the query string
- Ex: <c:url var=“addr” value=“ProcessServlet”/>
<a href=“${addr}”>click here</a>
 JSTL
Core Tag Library – URL-Related Actions
Tags Descriptions

- <c:redirect url=“url path”>…</c:redirect>

- Sends the client a response to redirect to the specified URL.
This action willabort processing of the current page.
<c:redirect>
- Action may include nested <c:param> tags to specify the
query string.
- Ex: <c:redirect url=“abc.jsp”/>
- <c:param name=“nameOfQuery”
value=”ValueOfParameter”>...</c:param>
<c:param> - Adds request parameters to a URL.
- This action can only be nested within <c:import>, <c:url>, or
<c:redirect>
 JSTL
Core Tag Library – URL-Related Actions

Same as “nextPage.jsp?user=khanh
 JSTL
Core Tag Library – URL-Related Actions
 JSTL
Core Tag Library – URL-Related Actions
 JSTL
Core Tag Library – URL-Related Actions
 JSTL
Core Tag Library – URL-Related Actions
 JSTL Core Tag Library – Summary
Core Tag Library

General Purpose Decision Making

Iteration Tags
Tags Tags

set remove out if choose forEach forTokens

URL Related
Tags

import url redirect param

 Complete MVC 2
Requirements
• Complete the MVC 2 with CRUD Web Application in previous topic
Complete MVC 2
Requirements
Complete MVC 2
Requirements
 JSTL
Functions Tag Libraries
• The library contains tags, which provides the utility functions in
process on jsp page combining jstl
• All functions treat null Strings as empty Strings
• It can be declared by
<%@ taglib prefix=“fn” uri=”http://java.sun.com/jsp/jstl/functions” %>
• Some functions
– fn:length
– fn:contains
– fn:containsIgnoreCase
– fn:indexOf
– fn:split
– fn:trim
– fn:substring
– …
 JSTL
Functions Tag Libraries
 JSTL
Functions Tag Libraries
 JSTL
SQL Tag Library
• The library contains tags, which are used to access SQL databases,
are used to perform the database related tasks, such as selection,
insertion, deletion and modification without using java codes
• It provides an interface for executing SQL queries on database
through JSP.
• It can be declared by
<%@ taglib prefix=“sql” uri=”http://java.sun.com/jsp/jstl/sql” %>
• The “setDataSource” Tag
– Is used to set a data source for the database.
– Is an empty tag and allows the user to set data source information for the
database
– Syntax:
<sql:setDataSource dataSource=“datasource” | url=“jdbcurl”
driver=“jdbcclassdriver” user=“username” password=“password”
var=“varName” scope=“page | request | session | application” />
– If the DataSource attribute is used, then url attribute cannot be used.
 JSTL
• The “query” Tag
SQL Tag Library
– Searches the database and returns a result set containing rows of data. (Passing database
queries function)
– The tag can either be an empty tag or a container tag.
– The SELECT statement is used to select data from the table.
– Syntax
<sql:query var=“varName” dataSource=“datasource” scope=“page | request |
session | application”>
SQL Statement
<sql:param value=“value” />
</sql:query>
• The “update” Tag
– Executes the INSERT, UPDATE AND DELETE statements.
– Zero is returned if no rows are affected by statements
– Syntax
<sql:update var=“varName” dataSource=“datasource” scope=“page | request |
session | application”>
SQL Statement
<sql:param value=“value” />
</sql:update>
 JSTL
SQL Tag Library
• The var attribute of query Tag
– Is javax.servlet.jsp.jstl.sql.Result interface
– Methods
• columnNames: Returns the names of the columns in the result
• rowCount: Returns the number of rows in the cached ResultSet
• rows: Returns the result of the query as an array of SortedMap objects
• rowsByIndex: Returns the result of the query as an array of arrays
• limitedByMaxRows: Returns true if the query was limited by a maximum
row setting
 JSTL
SQL Tag Library – Example
 JSTL
SQL Tag Library
• The “transaction” Tag
– Is used to established a transaction context for <sql:query> and
<sql:update> tags.
– The connection object is obtained from <sql:transaction> as this
tag is responsible for managing access to the database.
– Syntax
<sql:transaction dataSource=“datasource” isolation=“isolationLevel”>
<sql:update> or <sql:query> Statements
</sql:transaction>
• The “param” Tag
– Is used to set values for parameters markers (“?”) in SQL
statements.
– It acts as a sub tag for <sql:query> and <sql:update>
– Syntax
<sql:param value=”value”/>
 JSTL
SQL Tag Library

SQL Tag Library

setDataSource query update transaction param

 Build Library Tag Lib Library
Requirements
• Build the data grid tag library using in JSP as
 Tag Libraries
Tag Extension Mechanism
• Enables creation of custom tags
– Java code can be avoided using custom tags
– Separates the work profiles of Web designers and developers
(representation and business logic)
• Custom tags can be reused
• Written using XML syntax
• Encapsulation
• Components of custom tag
– Tag Library Descriptor (TLD): an XML document contains
information about the contents of a tag library.
– Custom Action: a Java class implements the contents in the TLD
– Web deployment descriptor: locate the custom tag library to use
• A Tag is implemented through extending some interfaces of
the javax.servlet.jsp.tagext package
 Tag Libraries
Tag Extension Mechanism
 Tag Libraries
Terminologies
• Classic custom tag is defined by the classic tag handler class.
• Simple custom tag is defined by the simple tag handler classes.
• Basic tags
– Generally do not contain any body. (Even if it contains body, the body is not
processed by the tag.)
– The tag handler class of the basic tag implements the Tag interface and extends
the TagSupport class.
• Iteration tags
– Are valuated time and again.
– Are generally empty tags.
– The tag handler class for an iteration tags needs implementation of IterationTag
interface that extends the Tag interface.
• Complex tags
– Support evaluation of the body content of the tag including other services
provided in the basic tag or iteration tag.
– Implement BodyTag interface and extend the BodyTagSupport class.
Tag Libraries
Terminologies
 Tag Libraries
Custom Tags
• Allow Java programmer to embed Java codes in JSP
documents
• Helps the developer reducing the overhead of writing the
same business logic again for a particular action to be
repeated in programs
• Supporting the front end, developer need not bother
about the complexity of the logic of a tag because the tag
is created by a Java developer and the front end developer
only imports it to the JSP page.
• Provide a mechanism to reuse and encapsulate complex
recurring code or tasks in JSP
• Provide simplicity and reusability of Java code
• Custom tag body can include static text, HTML, and JSP
elements like scriptlets, between the start and the end tag
 Tag Libraries
The Custom Tag Development Process
• There are 4 essential steps to writing a custom tag
– Create a Tag Library Descriptor (.tld) – TLD file
• Is an XML document that is used to validate the tags.
• Contains the information on each tag available in the library
• Provides the JSP engine with meta-information about the custom tag and
about its implementation
• Contains the list and description of all custom tags in the library
• Usually locates at the tlds folder inside WEB-INF directory
– Create a Tag Handler class in proper package with tld file.
• Is a Java class that defines a tag described in the TLD file.
• What a tag will implement depends on what methods can be called and what
is required to be implemented.
• These are of two types, classic and simple.
– Provide details of where to find the TLD file in web.xml
(option – required if the tld files don’t put at the
WEB-INF/tlds directory)
– Creating a JSP page that will access the custom tags: using a
taglib directive in the page before any custom tag is used.
 Tag Libraries
The TLD file
<?xml version="1.0" encoding="UTF-8"?>
<taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-
jsptaglibrary_2_0.xsd">
<tlib-version>1.0</tlib-version>
<short-name>shortName-prefix</short-name>
<uri>/WEB-INF/tlds/CustomTag</uri>
<tag>
<name>tagName-method</name>
<tag-class>TagHandlerName</tag-class>
<body-content>JSP|EMPTY|scriptless|tagdependent</body-content>
<attribute>
<name>attributeName</name>
<required>false/true</required>
<rtexprvalue>false/true</rtexprvalue>
</attribute>
</tag>
/<taglib>
 Tag Libraries
<web-app>
Mapping TLD file in web.xml
…
<jsp-config>
<taglib>
<taglib-uri>tld file name</taglib-uri>
<taglib-location>tld location path</taglib-location>
</taglib>
</jsp-config>
…
</web-app>
• Ex:
<taglib>
<taglib-uri>CustTags-taglib.tld</taglib-uri>
<taglib-location>/WEB-INF/classes/CustTags-taglib.tld</taglib-location>
</taglib>
Tag Libraries
Hunting the Tag
 Tag Libraries
The Tag Libraries
• Is a collection of custom tags
• Allows the developer to write reusable code fragments, which
assign functionality to tags
• The reference to each tag is stored in the tag library
• When a tag is used in a JSP page, the taglib directive must be
imported as
<%@ taglib uri=“/WEB-INF/tlds/TagHandler” prefix=“u” %>
• Locating TLD File: after iterating with the <@%taglib…>
directive, traces the location of the tag library descriptor file
(through URI) and subsequently to the location of the tag handle
class
• Associating URIs with TLD File Locations: The uri attribute is
mapped to the .tld file by two methods
– Implicit
• By referring to the tag library descriptor from the expanded WEB-INF folder.
• By referring to a JAR file containing a tag library.
– Explicit: By defining reference to the tag library descriptor in the deployment
descriptor, web.xml of the Web application
 Tag Libraries
The Tag Libraries
• Tag Library Prefix
– Distinguish these tags from one another, they are named
uniquely by using prefix attributes in the taglib directive
– Is used as a reference by the container to invoke its respective
TLD file and tag handler class
– The value of prefix and the sub element <short-name> inside
the <taglib> within the TLD file should match
• Notes:
– The tld files can be mapped in implicit (e.g. they should be put at
the WEB-INF/tlds)
– The tld files can be packaged into a jar file, and the tld files
within the jar file must have a path that begins /META-INF
directory
– The tld files must contain the optional <uri> element, which
must match the uri of the taglib directive or the namespace
value
 The “Classic” Custom Tag Event Model
Basics
• Uses a tag handler class, which implements Tag, IterationTag and
BodyTag interfaces or extends the classes TagSupport or
BodyTagSupport
Interfaces/Classes Descriptions
- Allows communication between a tag handler and the servlet of a JSP page.
Tag - Is particularly useful when a classic custom tag is without any body or even if it
has body when it is not for manipulation
- Is used to by tag handlers that require executing the tag, time and again without
IterationTag manipulating its content.
- Extends to the Tag interface
- The tag handler class of a tag which manipulates its body needs to implement
BodyTag
- Extends to the IterationTag and in turn to the Tag interface.
- Acts as the base class for most tag handlers which support, empty tag, tag with
attributes and a tag with body iterations.
TagSupport Class - Implements the Tag and IterationTag interfaces. Thus, it implements all the
methods in these interfaces.
- Contains methods such as, doStartTag(),doEndTag() and doAfterBody().
- Can support tags that need to access and manipulate the body content of a tag.
- Implements the BodyTag interface.
BodyTagSupport
- Extends the TagSupport class.
- Contains the following methods: setBodyContent() and doInitBody().
The “Classic” Custom Tag Event Model
Basics

Tag Interfaces and Classes in javax.servlet.jsp.tagext

The “Classic” Custom Tag Event Model
Tag Interface
 Tag Interface
Methods Descriptions
- public int doStartTag() throws JSPException
- Is invoked when a request is made to a tag or encountering the starting tag of the element
- Returns the SKIP_BODY constant if there is no body to evaluate and returns the
doStartTag EVAL_BODY_INCLUDE constant if the body after evaluation needs to be sent to the
output stream.
- In case of the BodyTag interface, it can return EVAL_BODY_BUFFERED that the
evaluated body is to be stored in a buffer temporarily.
- public int doEndTag() throws JSPException
- Is invoked when the JSP page encounters the end tag.
doEndTag - Generally follows the execution of the doStartTag() if the tag is empty.
- Returns the SKIP_PAGE constant if there is no need to evaluate the rest of the page and
returns EVAL_PAGE constant if the rest of the page needs to be evaluated.
- public void setParent(Tag t)
setParent - Sets the current nesting or parent tag of a nested tag.
- Is invoked prior to doStartTag()
- public Tag getParent()
getParent
- Returns the current parent tag
- public void setPageContext(PageContext pc)
setPageContext - Sets the current page context.
- Is called by the page implementation prior to doStartTag().
- public void release()
release - Is invoked so that the tag handler will release the resource it holds. The resources utilized
by the tag instance are now free for further processing inside the remaining JSP page
 Tag Implementation
Empty Custom Tags – Reference uri
• Affecting uri on tld file
 The “Classic” Custom Tag Event Model
Iteration Tag Interface
• Is implemented to the tag handler class to create tags, which
repeatedly evaluates the body inside it.
• Is an extension of the Tag interface
Methods Descriptions

- public int doAfterBody() throws JSPException

- Allows the user to conditionally re-evaluate the body of the tag.
- Is invoked after evaluating the body of the tag.
- Returns the constant SKIP_BODY or EVAL_BODY_AGAIN.
doAfterBody - If the doStartTag() method returns EVAL_BODY_INCLUDE then
this method returns EVAL_BODY_AGAIN.
- Then the doStartTag() is evaluated once again. But when the
doAfterBody() returns SKIP_BODY, the doEndTag() method is
invoked
The “Classic” Custom Tag Event Model
Iteration Tag Interface
The “Classic” Custom Tag Event Model
Iteration Tag Interface
 The “Classic” Custom Tag Event Model
TagSupport Class
• Implements the Tag or IterationTag interface
• Makes it easy to create a handler class by limiting the
implementation of number of methods
• Acts as the base class for all tag handlers for the tags with
out body and iterative tags
• Suffers from a limitation of not being able to manipulate
the body content
 The “Classic” Custom Tag Event Model
BodyTag Interface
• The tag handler class to implement the BodyTag
interface that can include body inside it and manipulate
the content of the body. This also inherits all the methods
from the Tag interface
Methods Descriptions

- public void doInitBody()

- Is invoked immediately after the setBodyContent() method
doInitBody returns the bodyContent object and before the first body
evaluation.
- Can only be invoked if the tag contains any body
- public void setBodyContent(BodyContent bc)
- Sets the bodyContent object for the tag handler, the
bodyContent object of the BodyContent class encapsulates the
setBodyContent
body content of the custom tag for processing.
- Is automatically invoked by the JSP page before the
doInitBody() method.
The “Classic” Custom Tag Event Model
BodyTag Interface
The “Classic” Custom Tag Event Model
BodyTag Interface
 The “Classic” Custom Tag Event Model
BodyTagSupport Class
• By default implements the BodyTag interface and also extends to
the TagSupport class
• The handler class only needs to override the methods of the
BodyTagSupport class. All the methods of the TagSupport class
and Bodytag interface are implemented by default in the handler
class. This makes the creation of tag handler class a lot easier.

Methods Descriptions

- public BodyContent getBodyContent()

- Retrieves the bodyContent object of the class BodyContent.
getBodyContent
- Contains the body of the tag which is accessed by the container
for manipulation.

- public void setBodyContent(BodyContent bc)

setBodyContent
- The bodyContent object is set by the setBodyContent() method
The “Simple” Custom Tag Event Model
The Simple Tag Interface
 The “Simple” Custom Tag Event Model
The Simple Tag Interface
• Provides doTag() method, which is supported by the Classic Tag Handlers.
• The servlet container invokes the setJspContext(), setParent(), and methods
setting attribute, setting JspFragment and then doTag() method
Methods Descriptions

- public void doTag() throws JSPException, IOException

- Is used for handling tag processing.
doTag - Retains body iteration after being processed.
- Is called whenever there is a requirement of tag invocation. All the
manipulations and evaluations are carried out by this method.
- public void setParent(JSPTag parent)
setParent
- Sets the parent of a specified tag
- public JspTag getParent()
getParent
- Returns the parent if the specified tag
- public void setJspContext(JspContext jc)
setJspContext
- Sets the context to the tag handler for invocation by the container.
- public void setJspBody(JspFragment jspBody)
setJspBody - Is provided by the body of the specified tag, which can be invoked any
number of times by the tag handler
 The “Simple” Custom Tag Event Model
The SimpleTagSupport Class
• Acts as a base class for simple tag handlers.
• Implements the SimpleTag interface. It adds several useful methods
• The basic implementation of SimpleTag interface is managed by
javax.servlet.jsp.tagext.SimpleTagSupport class. The interface is
implemented by extending the SimpleTagSupport class and
overriding the doTag() method
Methods Descriptions

- protected JspContext getJspContext()

getJspContext - Returns the context passed into the container by
setJspContext() method

- protected JspFragment getJspBody()

getJspBody - Returns the fragment encapsulating the body of this
tag, set by setJspContext().
 Custom Tags
Tags and Implicit Variables
 The Tag File Model
Overview
• Are simple tags whose source is in JSP-syntax form
• Provide an advanced way to build standard template and
use it when required.
• Is a text file with .tag extension stored in the WEB-INF/tags
directory of the Web application.
• Acts as a tag handler file. During the execution of a JSP
page, while coming across a custom tag is initially taken to tag
file for processing the tag definition.
• Separate tag file are not required because the tag files
contain the total implementation of the custom tag
• Can be access through taglib directive as form
<%@ taglib tagdir=”/WEB-INF/tags” prefix=”prefixName”%>
The Tag File Model
Overview
 The Tag File Model
Tag File vs. TLD

Tags TLDs

Reusable components of JSP pages - Local to a project

Can hide and eliminate scriptlets - Cannot hide and eliminate scriptlets
Can be written easily - High end programming required
Follow syntax closer to HTML - Follow java programming syntax
High level as compared to TLD - Low level components
Need to be defined earlier - Generated automatically
 Tag File Directive
• Is used for instructing the container to compile or interpret efficiently
• During deployment, the Web container generates its own TLD files with the help of these
directives. The tag receives inputs through its directives. It can also be used to generate data
by creating EL variables
Directives Descriptions
- <%@ tag attr1=“…” …%>
- Is similar to a page directive but it is used in JSP tag files.
tag
- It is used to declare custom tag properties.
- Ex: <%@ tag import=“java.util.*”%>
- <%@ tag include file=“file name”%>
- Directive is used to include the contents of other files in the present file.
include
- Can be accessed by more then one tag files if a common source is present.
- Ex: <%@tag include file=“process.jsp”%>
- <%@ taglib uri=“tagLibURI” prefix=“tagPrefix”%>
taglib - Custom actions that need to be related from a tag file can be used by the taglib directive
- Ex: <%@taglib tagdir=”WEB-INF/tags” prefix=“demo“%>
- <%@ attribute att1=“value1” …%>
- Supports the use of attributes in a tag file.
attribute
- Is similar to attribute element in a TLD.
- Ex: <%@ attribute name=“format” required=“false”%>
- <%@ variable att1=“varName” att2=“value”…%>
variable - Is used to define a variable that can be used by the calling JSP page.
- Ex: <%@variable name-given=“price”%>
 The Tag File Model
Implementation

• Click Next Button

 The Tag File Model
Implementation

Fill your tagfile name

Modify or Browser the

location where tags are
stored. Should not be
changed

Choose TagFile
(Standard Syntax)

• Choose Finish Button

• The tags file is automatically created at WEB-INF/tags
• Coding tags body
 The Tag File Model
Implementation
• Building the web application using tag file model has GUI
presenting as following
The Tag File Model
Implementation
The Tag File Model
Implementation
The Tag File Model
Implementation
 Summary
• How to remove all java code in JSP (View)?
Complete the MVC 2 Design Pattern with
View
– JSTL
• How to build the data grid tag library using
in JSP?
– Tag Libraries
• Model
• Classical, Simple, and Handles
• How to implement the custom Tag Lib and use it in JSP

Q&A
 Summary

Web Server
Container
1. Send request C 2. Call
3. Query
6. Response DAO DB
5. Render/Send
4. Store data into
7. Display V
DTO

Q&A
 Next Lecture
• How to preprocess in web application?
– Filter
– Filter Chain
– Using Filter as Controller in MVC2 Design Pattern
 Next Lecture
Day 1, 2, 3, 4, 5, 6 – Login
Servlet, JDBC

Day 7, 8, 9 – Search
Break Down

Day 10, 11 – MVC2

JSP
Web Day 12, 13, 14, 15 – CUD, Shopping Carts
Web based
App - PBL Sessions

Day 16, 17 – Login

JavaBeans

Day 18, 19, 20 – CRUD

MVC 2 Complete - JSTL - Taglib

Day 21, 22, 23 – Filter

MVC2 Using Filter as Controller
Appendix – Complete MVC 2
Welcome page
Complete MVC 2
Welcome page
Complete MVC 2
Welcome page
Complete MVC 2
Welcome page
Complete MVC 2
Register Errors Object
Complete MVC 2
Register Errors Object
Complete MVC 2
Register Page
Complete MVC 2
Register Page
Complete MVC 2
Register Servlet
Complete MVC 2
Register Servlet
Complete MVC 2
Register Servlet
 Appendix – JSTL
SQL Tag Library – Example
 JSTL
SQL Tag Library – Example
 JSTL
SQL Tag Library – Example
 JSTL
SQL Tag Library – Example
 JSTL
SQL Tag Library – Example
 JSTL
SQL Tag Library – Example – Improvement
 JSTL
SQL Tag Library – Example – Improvement
 Appendix – Tag Implementation
Empty Custom Tags – Create TLD

• Click Next Button

 Tag Implementation
Empty Custom Tags – Create TLD
Fill your tld name

Modify or Browse the location

that is used to store tag lib.

Modify the URI or prefix

(shortname)

• Click Finish Button

• Then, the tld file is automatically created in tlds directory
• Do not modify anything in this tld file because the netbeans is automatically the tld
information when the next step is executed
 Tag Implementation
Empty Custom Tags – Create Tag Handler

• Click Next Button

 Tag Implementation
Empty Custom Tags – Create Tag Handler

Fill your tld name

Choose or type the package

Choose Simple Tag Support

• Click Next Button

 Tag Implementation
Empty Custom Tags – Create Tag Handler

Browse to choose the tld file

that will be updated
information

Choose the Body Tag, choose

empty

Add attribute to custom tag

• Click Browse Button to add the information to tld

 Tag Implementation
Empty Custom Tags – Create Tag Handler

• Choose the tld file

• Then, Click Select File Button, then choose the empty option
• Click Finish Button on New Files Diaglog
• The TagHandler Class is created and the custom tag information is
automatically updated in the selected tld file
 Tag Implementation
Empty Custom Tags – Create Tag Handler
• To create emptyTag, clear the body contents in class

• Change “extends SimpleTagSupport” to “implements Tag”

• Click “Light Bulb” to implement all abstract methods

• Coding the doStartTag, doEndTag method

• Using the tag on the Jsp with taglib directive
 Tag Implementation
Empty Custom Tags – Create Tag Handler
 Tag Implementation
Empty Custom Tags – Reference
• Compile the TagHandler class
• Then create the JSP page with following contents

• Change the EVAL_PAGE to

SKIP_PAGE in doEndTag()
 Appendix
Iteration Tag Interface – Example
 Appendix
Iteration Tag Interface – Example
 Appendix
Iteration Tag Interface – Example
 Appendix
Custom Tags with Attributes – TagSupport
• <prefix:name attr=”value”></prefix:name >
• Tags with or without body has attributes
• Are called as parameterized tags.
• Attributes are passed to the tags as arguments are passed
to method.
• Is done to customize the behavior of a custom tag.
 Appendix
Custom Tags with Attributes – TagSupport
• After browsing to tld finish, choose the New button
to Add Attribute to custom Tag
Fill the attribute name
Choose the datatype for attribute
Checking if the attribute is required

Choose type for evaluated the

attribute

• Click OK button
 Appendix
Custom Tags with Attributes – TagSupport

Attribute to add after the above step

• Click Finish button

• The attribute & tag information is automatically updated to the tld file
• Change the SimpleTagSupport to TagSupport in the TagHandler
 Appendix
Custom Tags with Attributes – TagSupport
 Appendix
Custom Tags with Attributes – TagSupport
 Appendix
Custom Tags with Body – BodyTag
 Appendix
Custom Tags with Body – BodyTag
 Appendix
Custom Tags with Body – BodyTag
 Appendix
Empty Custom Tags – using Simple
 Appendix
Empty Custom Tags – using Simple
 Appendix
Custom Tags with Attributes – using Simple
• Adding dynamic attributes to SimpleTag
– Implementing
javax.servlet.jsp.tagext.DynamicAttributes interface
– Define the setDynamicAttribute() method that accepts
dynamic attributes is passed an attribute not present in
the tag library
public void setDynamicAttribute(String uri, String localName,
Object value) throws JspException
– Addition the <dynamic-attributes>element to true in tld
 Appendix
Custom Tags with Attributes – using Simple
 Appendix
Custom Tags with Attributes – using Simple
 Appendix
Custom Tags with Attributes – using Simple
 Appendix
Custom Tags with Body – SimpleTag
• The setJspBody() method is called by the container. By
the use of getJspBody() method, fragment can be
accessed and is executed using the invoke() method.
• Finally, with the help of out.println(), the processed body
content is sent to the output stream as a response.
 Appendix
Custom Tags with Body – SimpleTag
 Appendix
Custom Tags with Body – SimpleTag
Appendix - The Tag File Model
Implementation
Appendix - The Tag File Model
Implementation – Dynamic Attributes
Appendix - The Tag File Model
Implementation – Dynamic Attributes
Appendix – Build Library
Tag File
Build Library Tag Lib Library
Tag File
Build Library Tag Lib Library
Apply
 Tag Hierarchies
• Simple within Simple
– Using JSPTag with getParent() method
– Using instanceOf to compare
• Classic within Classic
– Using Tag with getParent() method
– Using instanceOf to compare
• Simple within Classic
– Using JSPTag with getParent() method
– Using instanceOf to compare
• Classic within Simple
– getAdaptee() return the wrapper-up JSPTag
– getParent() method return the adaptee’s parent