Support for custom actions (or custom tags) within JSP was introduced in the JSP 1.1 specification. This feature allows developers to extend the available tags beyond what JSP alone provides for. The custom tags are grouped together into tag libraries, which can be reused across applications.
The Struts framework takes advantage of the tag library feature of JSP to include several different categories of tags that help to make the presentation layer more manageable and reusable. Using the Struts custom tag libraries, developers are able to interact with the rest of the framework without including Java code in the JSP pages.
This chapter provides an overview of the different categories of tags available in the Struts framework and how they can make developing applications even easier. This chapter is not meant to be an exhaustive reference for every tag that’s part of the Struts tag libraries—that information can be found within the Struts user guide or JavaDocs. The real purpose of this chapter is to put forth the benefits of using the Struts tag libraries and to provide a few strategies that can help make the switch to using the tags less painful.
Finally, this chapter will touch upon a new initiative going through the Java Community Process (JCP) that is intended to help standardize some of the more commonly used custom tags. This, in turn, will make applications built using these tags even more portable across containers and frameworks.
This section provides a brief overview of JSP custom tags and how they can add value to an application. They are explicitly tied to the JavaServer Pages technology and therefore are used only when building web applications based on JSP, such as those built using the Struts framework.
Before we talk specifically about JSP tags, it’s important that you understand what a tag is in general terms. Keep in mind that this section refers to tags in general, not JSP custom tags or Struts tags. We’ll discuss those shortly.
If you’re familiar with HTML, you already should have a good understanding of the concept of a tag. There are two basic types of tags:
Bodyless tags
Tags with a body
Bodyless tags are tags that specify attributes but contain no content. They have the syntax:
<tagName attributeName="someValue" attributeName2="someValue2"/>
Bodyless tags are most often used to perform simple actions such as rendering HTML fields or displaying images. An example of a bodyless tag is:
<img src="images/struts-power.gif"/>
Tags can define certain predefined attributes, which supply
information to the tag and can affect how the tag performs its
duties. In the HTML img tag, for example, the
src attribute supplies the tag with the path to a
graphical image that will be rendered by the tag.
Tags with a body have a start tag and a matching end tag, with some content between them. The syntax looks like:
<tagName attributeName="someValue" attributeName2="someValue2"> <!-- The Tag body is between the start and end tags --> </tagName>
Tags with a body are used to perform operations on the body content, such as iterating over a collection, formatting HTML output, and so on. Here’s another example from HTML:
<html> <!-- The HTML body inside the start and end HTML tags --> </html>
The end tag must always begin with a “/” character.
When
parsing an HTML file, the browser determines how to process and
handle the tags the file contains based on a set of standards. The
purpose of JSP custom tags is to give the developer the ability to
extend the set of tags that can be used inside a JSP page. With
ordinary HTML tags, the browser contains the logic to process the tag
and render the output. With JSP custom tags, the functionality exists
in a special Java class called the tag
handler
.
The tag handler is a Java class that carries out the specific
behavior of the tag. It implements one of several custom tag
interfaces, depending on the type of tag that you need to develop.
The handler class has access to all of the JSP resources, such as the
PageContext object and the request, response, and
session objects. The tag also is populated with the attribute
information, so it can customize its behavior based on the attribute
values.
There are many benefits of using custom tags instead of scriptlets and Java code in your JSP pages:
Tags are reusable, which saves precious development and testing time.
Tags can be customized using attributes, either statically or dynamically.
Tags have access to all of the objects available to the JSP page, including request, response, and output variables.
Tags can be nested, which allows for more complex interactions within a JSP page.
Tags simplify the readability of a JSP page.
In general, using JSP tags helps to further the concept of reuse, as the behavior is implemented in a single location, the tag handler; it’s not replicated throughout multiple JSP pages.
A tag library is a set of JSP custom tags grouped together from a packaging perspective. Although it’s not a requirement, the tags within a tag library should solve a similar type of problem. Because web applications can include multiple tag libraries, there’s no need to place all of the tags into a single library.
You can see an example of how tags can be grouped logically by looking at the Jakarta Taglibs project at http://jakarta.apache.org/taglibs/. Tag libraries are available for rendering dates and times, manipulating strings, and many other purposes. Notice that each tag library is focused on a single concept or task. The Jakarta Taglibs project will be discussed further later in this chapter.
A tag library is made up of the following components:
Tag handler
Tag library descriptor file
The application deployment descriptor (web.xml) file
The tag library declaration in the JSP page
You’ve already been introduced to the tag handler. This is where the implementation of the tag is located. It’s a Java class that gets invoked at runtime and that performs some predefined behavior.
The tag library descriptor (TLD) file is an XML file that contains meta-information about the tags within a library. Information such as the tag name, the attributes that are required, and the tag handler class name are all contained in this file and read in by the JSP container.
We discussed web application deployment descriptors in Chapter 3. Within this descriptor, you must define what tag libraries are being used in the web application and which TLD files should be used to describe each tag library.
Obviously, the JSP page is a key component. It contains the include directives for one or more tag libraries, as well as the needed calls to the tag libraries within the JSP page. There is essentially no limit to how many tag libraries or tag references you can have in a JSP page.
Warning
There have been some reports of sluggishness in JSP containers when the number of tags in a single JSP page approaches 40-50. Vendors have a lot of freedom in terms of how they initialize and process custom tags; some are better than others. If this becomes a problem for your implementation, you might try to redesign the page to reduce the number of tags, or combine some of the tags into a single handler. If that doesn’t solve your problem, run your tags in a different container and evaluate the performance.
Attempting to cover all aspects of JSP custom tags is beyond the scope of this book. In fact, there are entire books written on the subject. A good source of information on custom tags and their use in applications is Hans Bergsten’s JavaServerPages (O’Reilly).