You write a custom JSP tag by writing a Java class that is called a tag handler.

The JSP 2.3 API defines a set of classes and interfaces that you use to write custom tag handlers.

See the JSP 2.3 Specification at http://java.sun.com/products/jsp/reference/api/index.html.

Documentation for the javax.servlet.jsp.tagext API is available at https://docs.oracle.com/javaee/7/api/overview-summary.html.

Your tag handler must be of one of the following two types:

• Classic Tag Handlers implement one of three interfaces:

  Tag—Implement the javax.servlet.jsp.tagext.Tag interface if you are creating a custom tag that does not need access to its interface. The API also provides a convenience class TagSupport that implements the Tag interface and provides default empty methods for the methods defined in the interface.

  BodyTag—Implement the javax.servlet.jsp.tagext.BodyTag interface if your custom tag needs to use a body. The API also provides a convenience class BodyTagSupport that implements the BodyTag interface and provides default empty methods for the methods defined in the interface. Because BodyTag extends Tag it is a super set of the interface methods.

  IterationTag—Implement the javax.servlet.jsp.tagext.IterationTag interface to extend Tag by defining an additional method doAfterBody() that controls the reevaluation of the body.

• Simple Tag Handlers (SimpleTag interface):

  Implement the javax.servlet.jsp.tagext.SimpleTag interface if you wish to use a much simpler invocation protocol. The SimpleTag interface does not extend the javax.servlet.jsp.tagext.Tag interface as does the BodyTag interface. Therefore, instead of supporting the doStartTag() and doEndTag() methods, the SimpleTag interface provides a simple doTag() method, which is called once and only once for each tag invocation.

You write the tag handler class by doing one of the following:

• Implement one of three interfaces, SimpleTag, Tag, or BodyTag, which define methods that are invoked during the life cycle of the tag.

• Extend an abstract base class that implements the SimpleTag, Tag, or BodyTag interfaces.

Extending an abstract base class relieves the tag handler class from having to implement all methods in the interfaces and also provides other convenient functionality. The SimpleTagSupport, TagSupport, and BodyTagSupport classes implement the SimpleTag, Tag or BodyTag interfaces and are included in the API.

You can include one or more custom JSP tags in a tag library. You define a tag library by a tag library descriptor (.tld) file. The TLD describes the syntax for each tag and ties it to the Java classes that execute its functionality.

Custom tags can perform the following tasks:

• Produce output. The output of the tag is sent to the surrounding scope. The scope can be one of the following:

  • If the tag is included directly in the JSP page, then the surrounding scope is the JSP page output.

  • If the tag is nested within another parent tag, then the output becomes part of the evaluated body of its parent tag.

• Define new objects that can be referenced and used as scripting variables in the JSP page. A tag can introduce fixed-named scripting variables, or can define a dynamically named scripting variable with the id attribute.

• Iterate over body content of the tags until a certain condition is met. Use iteration to create repetitive output, or to repeatedly invoke a server side action.

• Determine whether the rest of the JSP page should be processed as part of the request, or skipped.

• An empty tag can perform server-side work based on the tag's attributes. The action that the tag performs can determine whether the rest of the page is interpreted or some other action is taken, such as a redirect. This function is useful for checking that users are logged in before accessing a page, and redirecting them to a login page if necessary.

• An empty tag can insert content into a page based on its attributes. You can use such a tag to implement a simple page-hits counter or another template-based insertion.

• An empty tag can define a server-side object that is available in the rest of the page, based on its attributes. You can use this tag to create a reference to an EJB, which is queried for data elsewhere in the JSP page.

• A body tag has the option to process its output before the output becomes part of the HTML page sent to the browser, evaluate that output, and then determine the resulting HTML that is sent to the browser. This functionality could be used to produce "quoted HTML," reformatted content, or used as a parameter that you pass to another function, such as an SQL query, where the output of the tag is a formatted result set.

• A body tag can repeatedly process its body until a particular condition is met.

1. Write a tag handler class.

   When you use a custom tag in your JSP, this class executes the functionality of the tag. A tag handler class implements one of three interfaces:

   javax.servlet.jsp.tagext.BodyTag
   javax.servlet.jsp.tagext.Tag
   javax.servlet.jsp.tagext.SimpleTag

   Your tag handler class is implemented as part of a tag library.

2. Reference the tag library in your JSP source using the JSP <taglib> directive. A tag library is a collection of JSP tags. Include this directive at the top of your JSP source.

   See Configuring JSP Tag Libraries.

3. Write the tag library descriptor (TLD). The TLD defines the tag library and provides additional information about each tag, such as the name of the tag handler class, attributes, and other information about the tags.

   See Creating a Tag Library Descriptor.

4. Reference the TLD in the Web application deployment descriptor (web.xml).
5. Use your custom tag in your JSP.

   See Configuring JSP Tag Libraries.