SE452: Lecture 9 (Tag Libraries/Tag Files/JSTL/Filters)

Tag Libraries - implementing

Tag Files - implementing

JSTL - Intro

Filters

A custom tag consists of a tag handler and a tag library descriptor

• Tag handler is a Java class
• Tag Library Descriptor is an XML configuration file

Types:

• Classic tags - Java classes that implement either Tag, BodyTag or IterationTag interfaces.
• Simple Tags -- Java classes that implement SimpleTag or tag extensions created using only JSP syntax instead of Java

To use the tag:

• Import into a page using the taglib directive
• Use the custom tag in a JSP

A custom tag must implement the javax.servlet.jsp.tagext.Tag or javax.servlet.jsp.tagext.SimpleTag interface (which now extends javax.servlet.jsp.tagext.JspTag for organizational purposes

This is usually done by extending a base utility class

• javax.servlet.jsp.tagext.SimpleTag implements JspTag
• javax.servlet.jsp.tagext.TagSupport implements IterationTag, Tag
• javax.servlet.jsp.tagext.BodyTagSupport implements BodyTag, IterationTag, Tag
• IterationTag extends Tag
• BodyTag extends IterationTag

The Tag interface supplies doStartTag() and doEndTag()

BodyTag supplies doInitBody(), setBodyContent()

IterationTag supplies doAfterBody()

TryCatchFinally supplies doCatch(), doFinally() and helps tags manage resources better

To implement a tag handler:

• Extend:
  • TagSupport for empty tags
  • BodyTagSupport for non-empty tags
  • SimpleTagSupport for simple non-empty tags
  • TagAdapter for SimpleTags that need to work as classic tags
• Define the attributes of the tag (follow the JavaBeans design pattern for setters)
• Define one or more of the following methods
  • doTag() -- for Simple Tags
  • doStartTag()
  • doEndTag()
  • doInitBody()
  • doAfterBody()

doTag() - Called by the container to invoke this tag, and is called once and only once. The lifecycle for SimpleTag is simpler than Tag, IterationTag, or BodyTag.

Lifecycle:

1. A new tag handler instance is created each time by the container by calling the provided zero-args constructor. Unlike classic tag handlers, simple tag handlers are never cached and reused by the JSP container. This can be a performance issue, but in modern JVMs is not nearly as much of an issue.
2. The setJspContext() and setParent() methods are called by the container. The setParent() method is only called if the element is nested within another tag invocation.
3. The setters for each attribute defined for this tag are called by the container. Use JavaBean conventions for this functionality.
4. If a body exists, the setJspBody() method is called by the container to set the body of this tag, as a JspFragment. If the action element is empty in the page, this method is not called at all.
5. The doTag() method is called by the container. All tag logic, iteration, body evaluations, etc. occur in this method.
6. The doTag() method returns and all variables are synchronized.

If you need to create a SimpleTag, but use it as a classic tag, you can use a TagApapter to wrap the SimpleTag and then the SimpleTag can be used where a classic Tag is expected.

doStartTag()

• invoked when start tag is encountered
• return value indicates whether body is skipped or processed
  • SKIP_BODY - required if TLD has a body-content of empty
  • EVAL_BODY_INCLUDE - pass through

doEndTag()

• invoked for all tags
• return whether to evaluate rest of page
  • EVAL_PAGE
  • SKIP_PAGE

Lifecycle:

doAfterBody()

• Used for tags that repeat data
• called to determine if tag should be evaluated again
• Returns iteration status
  • EVAL_BODY_AGAIN
  • SKIP_BODY

Lifecycle:

• if doStartTag() returns SKIP_BODY
  • body not evaluated
  • neither of the methods called

• if doStartTag() returns EVAL_BODY_INCLUDE
  • body is evaluated, but neither of the methods called
  • doAfterBody() and doEndTag() are invoked

• setBodyContent(BodyContent b)
  • invoked at most once per action invokation (tag)
  • if doStartTag() returns EVAL_BODY_INCLUDE

• doInitBody()
  • called after setBodyContent()
  • prepares for evaluation of the body

Lifecycle:

An auxiliary interface for tags that want more control over resources

doCatch()

• invoked if a Throwable occurs while evaluating the body in
  • Tag.doStartTag()
  • Tag.doEndTag()
  • IterationTag.doAfterBody()
  • BodyTag.doInitBody()

doFinally - invoked in all cases after doEndTag() for any class implementing Tag, IterationTag, or BodyTag

In order for your tag library to be processed properly by the Servlet container, you must supply a configuration file known as a tag library descriptor. This basically servers the purpose of web.xml for a web application, it is information that the container uses to manage the libraries at runtime

http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd for JSP 2.0

http://java.sun.com/dtd/web-jsptaglibrary_1_2.dtd for JSP 1.2

http://java.sun.com/dtd/web-jsptaglibrary_1_1.dtd for JSP 1.1>

TLD structure:

• taglib - requires tlib-version, jsp-version, short-name, and tags. Optional are uri, description, validator (a TagLibraryValidator), and listeners.
  • tag - requires name and tag class, optional are body-content (JSP/empty, or tagdependent), variables entries (scripting variable names), attributes, tei (TagExtraInfo) classes, and description
    • attribute - requires name, required (whether it is required, false by default), rtexprvalue (whether it is a runtime JSP expression), type (must be fully qualified)

Examples:

<?xml version="1.0" encoding="UTF-8" ?>

<taglib 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
	http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
	version="2.0">


    <tlib-version>2.0</tlib-version>
    <jsp-version>2.0</jsp-version>
    <short-name>se452</short-name>
    <uri>/se452</uri>
    <display-name>se452-taglib</display-name>
    <small-icon></small-icon>
    <large-icon></large-icon>
    <description>
        A set of example tag libraries for SE452 at DePaul University
    </description>
    
    <tag>
        <name>date</name>
        <tag-class>se452.tags.DateTag</tag-class>
        <body-content>empty</body-content>
        <description>
        Prints the current time and date
        </description>
    </tag>
  
    <tag>
        <name>debug</name>
        <tag-class>se452.tags.DebugTag</tag-class>
        <body-content>JSP</body-content>
        <description>
        Includes the contents of the tag if debug request parameter
        is set to true
        </description>
    </tag>
    
    <tag>
        <name>select</name>
        <tag-class>se452.tags.SelectTag</tag-class>
        <body-content>empty</body-content>
        <description>
            Displays an html select with preselected options
        </description>
        <attribute>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <name>selected</name>
            <required>false</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
        <attribute>
            <name>list</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
            <type>java.lang.String</type>
        </attribute>
    </tag>
    
</taglib>

1. Put the class files in "doc root"/WEB-INF/classes
2. Put the tag library descriptor anywhere in the webapp
3. Edit WEB-INF/web.xml, Add the following to your web.xml after servlet-mappings and session-config, but before resource-ref:

<jsp-config>
    <taglib>
        <taglib-uri>se452-taglib.tld</taglib-uri>
        <taglib-location>/WEB-INF/tld/se452-taglib.tld</taglib-location>
    </taglib>
</jsp-config>

Use taglib directive

<%@ taglib uri="se452-taglib.tld" prefix="se452" %>
    

Write the tag in the JSP

<se452:tag1>

or

<se452:tag1>
	Body (any JSP/html/Text)
</se452:tag1>

The JavaServer Pages Standard Tag Library (JSTL) encapsulates, as simple tags, core functionality common to many JSP applications

JSTL is hosted at Jakarta - along with many other useful tag libraries

JSTL, unlike the other libraries, is standardized through the Java Community Process (JCP).

JSTL comes in two versions:

• 1.0 - for Servlets 2.3, JSP 1.2
• 1.1 - for Servlets 2.4, JSP 2.0

JSTL is the origin of the Expression Language that is now standard in JSP 2.0, so you can use the EL in any JSTL 1.0 tags in a JSP 1.2 container, but the EL is not available outside of JSTL tags (like in a JSP 2.0 container).

To deploy the JSTL, just follow the same directions as for any tag library.

JSTL comes in 4 libraries:

1. Core library - c
2. XML processing library - x
3. Internationalization (i18n) library - fmt
4. Database Access (SQL) library - sql

Core is for management of variables, iteration, output, conditional logic

XML processing is for parsing, selection of XML, XSTL transforms, logic based on XML data

The i18n library supports formatting of things like currency, dates, and numbers, as well as localized output of content based on Locale

The SQL library is not meant to promote good design of database based apps, but provide for easy access to databases and presentation of the data, without a large amount of abstraction.

Goal: To write a simple tag library from scratch.

1. Create a tag library that solves a display problem for your application. The key is to look for scriptlets in your JSP, or complicated logic that is needed to provide part of your presentation layer. If you don't have any good candidates in your current code, add something.
2. The tag can be any of the tag types, including SimpleTag
3. Write the tag library descriptor.
4. Add a reference to your tag library in web.xml
5. Use the tag library in a JSP.

Supply the application as a deployable war file. Test deploying it before submitting it to make sure you have the format right. Place the source files for the servlet in a src directory in the war file. Please link the homework assignment to the index.html file in the document root.

Grading Breakdown:

Revised: 11/9/2003