ABid

• How to develop and deploy simple tags
• How to develop and deploy advanced tags: parameterized tags and tags with a body
• How to describe tags with the Tag Library Descriptor (TLD)

• Bodyless Tags: A bodyless tag is a tag that has a start tag but does not have a matching end tag. It has the syntax:

<tagName attributeName="value"

anotherAttributeName="anotherValue"/>

• Tags with a Body: A tag with a body has a start tag and a matching end tag. It has the syntax:

<tagName attributeName="value"

anotherAttributeName="anotherValue">

...tag body...

</tagName>

<tagLibrary:tagName>

   body

</tagLibrary:tagName>

<mylib:hello>

 <%= yourName %>

</mylib:hello>

• They can reduce or eliminate scriptlets in your JSP applications. Any necessary parameters to the tag can be passed as attributes or body content, and therefore no Java code is needed to initialize or set component properties.
• They have simpler syntax. Scriptlets are written in Java, but custom tags can be used in an HTML-like syntax.
• They can improve the productivity of nonprogrammer content developers, by allowing them to perform tasks that cannot be done with HTML.
• They are reusable. They save development and testing time. Scritplets are not reusable, unless you call cut-and-paste reuse.

public interface Tag {

   public final static int SKIP_BODY = 0;

   public final static int EVAL_BODY_INCLUDE = 1;

   public final static int SKIP_PAGE = 5;

   public final static int EVAL_PAGE = 6;

   void setPageContext(PageContext pageContext);

   void setParent(Tag parent);

   Tag getParent();

   int doStartTag() throws JspException;

   int doEndTag() throws JspException;

   void release();

}

package tags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class HelloTag implements Tag {

   private PageContext pageContext;

   private Tag parent;

   public HelloTag() {

      super();

   }

   public int doStartTag() throws JspException {

      try {

         pageContext.getOut().print(

         "This is my first tag!");

      } catch (IOException ioe) {

         throw new JspException("Error:

         IOException while writing to client"

         + ioe.getMessage());

      }

      return SKIP_BODY;

   }

   public int doEndTag() throws JspException {

      return SKIP_PAGE;

   }

   public void release() {

   }

   public void setPageContext(PageContext

   pageContext) {

      this.pageContext = pageContext;

   }

   public void setParent(Tag parent) {

      this.parent = parent;

   }

   public Tag getParent() {

      return parent;

   }

}

• Create a new subdirectory called tags, which is the name of the package containing the HelloTag class. This should be created at: c:\tomcat\webapps\examples\web-inf\classes.
• Save HelloTag.java in the tags subdirectory.
• Compile with the command:

c:\tomcat\webapps\examples\web-inf\classes\tags>

javac -classpath c:\tomcat\lib\servlet.jar

HelloTag.java

<?xml version="1.0" encoding="ISO-8859-1" ?>

<!DOCTYPE taglib

        PUBLIC "-//Sun Microsystems, Inc.//

        DTD JSP Tag Library 1.1//EN"

        "http://java.sun.com/j2ee/dtds/

        web-jsptaglibrary_1_1.dtd">

<!-- a tag library descriptor -->

<taglib>

   <tlibversion>1.0</tlibversion>

   <jspversion>1.1</jspversion>

   <shortname>first</shortname>

   <uri></uri>

   <info>A simple tab library for the

   examples</info>

 <tag>

    <name>hello</name>

    <tagclass>tags.HelloTag</tagclass>

    <bodycontent>empty</bodycontent>

    <info>Say Hi</info>

 </tag>

</taglib>

• tagdependent: meaning that any body of the tag would be handled by the tag itself, and it can be empty.
• JSP: meaning that the JSP container should evaluate any body of the tag, but it can also be empty.

<@ taglib uri="/WEB-INF/jsp/mytaglib.tld"

prefix="first" %>

<@ taglib uri="/WEB-INF/myJARfile.jar"

prefix='first" %>

<taglib>

       <taglib-uri>mytags</taglib-uri>

       <taglib-location>/WEB-INF/jsp/

       mytaglib.tld</taglib-location>

    </taglib>

<%@ taglib uri="/WEB-INF/jsp/mytaglib.tld"

 prefix="first" %>

<HTML>

<HEAD>

<TITLE>Hello Tag</TITLE>

</HEAD>

<BODY bgcolor="#ffffcc">

<B>My first tag prints</B>:

<first:hello/>

</BODY>

</HTML>

<%@ taglib uri="mytags" prefix="first" %>

package tags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class HelloTag extends TagSupport {

   public int doStartTag() throws JspException {

      try {

         pageContext.getOut().print("This is my

         first tag!");

      } catch (IOException ioe) {

         throw new JspException("Error:

         IOException while writing

        to client" + ioe.getMessage());

      }

      return SKIP_BODY;

   }

   public int doEndTag() throws JspException {

      return SKIP_PAGE;

   }

}

package tags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class HelloTagParam extends TagSupport {

   private String name;

   public void setName(String name) {

      this.name = name;

   }

   public int doStartTag() throws JspException {

      try {

         pageContext.getOut().print("Welcome to

         JSP Tag Programming, " +name);

      } catch (IOException ioe) {

         throw new JspException("Error:

         IOException

         while writing to client");

      }

      return SKIP_BODY;

   }

   public int doEndTag() throws JspException {

      return SKIP_PAGE;

   }

}

<tag>

 <name>helloparam</name>

 <tagclass>tags.HelloTagParam</tagclass>

 <bodycontent>empty</bodycontent>

 <info>Tag with Parameter</info>

 <attribute>

    <name>name</name>

     <required>false</required>

     <rtexprvalue>false</rtexprvalue>

         </attribute>

</tag>

<%@ taglib uri="mytags" prefix="first" %>

<HTML>

<HEAD>

<TITLE>Hello Tag with Parameter</TITLE>

</HEAD>

<BODY bgcolor="#ffffcc">

<B>My parameterized tag prints</B>:

<P>

<first:helloparam name="JavaDuke"/>

</BODY>

</HTML>

package tags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class Add extends TagSupport {

   private int num1, num2;

   public void setNum1(int num1) {

      this.num1 = num1;

   }

   public void setNum2(int num2) {

      this.num2 = num2;

   }

   public int doStartTag() throws JspException {

      try {

         pageContext.getOut().print("Welcome

         to First

          Grade Math! ");

         pageContext.getOut().print("The sum of: " +

         num1 + " and " + num2 + " is: " + (

         num1+num2));

      } catch (IOException ioe) {

         throw new JspException("Error:

         IOException

          while writing to client");

      }

      return SKIP_BODY;

   }

}

// Subtract.java

package tags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class Subtract extends TagSupport {

   private int num1, num2;

   public void setNum1(int num1) {

      this.num1 = num1;

   }

   public void setNum2(int num2) {

      this.num2 = num2;

   }

   public int doStartTag() throws JspException {

      try {

         pageContext.getOut().print("Welcome to First

          Grade Math! ");

         pageContext.getOut().print("If you

         subtract:

          " + num2 + " from " + num1 +

          ", you get: "+ (num1 - num2));

      } catch (IOException ioe) {

         throw new JspException("Error:

          IOException

         while writing to client");

      }

      return SKIP_BODY;

   }

}

JspWriter out = pageContext.getOut();

out.print("first line");

out.print("second line");

<tag>

    <name>add</name>

    <tagclass>tags.Add</tagclass>

    <bodycontent>empty</bodycontent>

    <info>Tag with Parameter</info>

    <attribute>

       <name>num1</name>

       <required>true</required>

       <rtexprvalue>false</rtexprvalue>

    </attribute>

    <attribute>

      <name>num2</name>

      <required>true</required>

      <rtexprvalue>false</rtexprvalue>

    </attribute>

 </tag>

 <tag>

    <name>sub</name>

    <tagclass>tags.Subtract</tagclass>

    <bodycontent>empty</bodycontent>

    <info>Tag with Parameter</info>

    <attribute>

       <name>num1</name>

       <required>true</required>

       <rtexprvalue>false</rtexprvalue>

    </attribute>

    <attribute>

      <name>num2</name>

      <required>true</required>

      <rtexprvalue>false</rtexprvalue>

    </attribute>

 </tag>

<%@ taglib uri="mytags" prefix="math" %>

<HTML>

<HEAD>

<TITLE>Hello Tag with Parameter</TITLE>

</HEAD>

<BODY bgcolor="#ffffcc">

<B>Calling first tag</B>

<P>

<math:add num1="1212" num2="121"/>

<P>

<B>Calling second tag</B>

<P>

<math:sub num1="2123" num2="3"/>

</BODY>

</HTML>

• Single Evaluation: if the body needs to be evaluated once, the tag handler should implement the Tag interface, or extend the TagSupport abstract class; the doStartTag method needs to return EVAL_BODY_INCLUDE, and if it does not need to be evaluated at all then it should return BODY_SKIP.
• Multiple Evaluation: if the body needs to be evaluated multiple times, the BodyTag interface should be implemented. The BodyTag interface extends the Tag interface and defines additional methods (setBodyContent, doInitBody, and doAfterBody) that enable a tag handler to inspect and possibly change its body. Alternatively, and similarly to the TagSupport class, you can extend the BodyTagSupport class, which provides default implementations for the methods in the BodyTag interface. Typically, you need to implement doInitBody and doAfterBody methods. The doInitBody is called after the body content is set but before it is evaluated, and the doAfterBody is called after the body content is evaluated.

package tags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class ToLowerCaseTag extends BodyTagSupport {

   public int doAfterBody() throws JspException {

      try {

         BodyContent bc = getBodyContent();

         // get the bodycontent as string

         String body = bc.getString();

         // getJspWriter to output content

         JspWriter out = bc.getEnclosingWriter();

         if(body != null) {

            out.print(body.toLowerCase());

         }

      } catch(IOException ioe) {

         throw new JspException("Error:

         "+ioe.getMessage());

      }

      return SKIP_BODY;

   }

}

<tag>

 <name>tolowercase</name>

 <tagclass>tags.ToLowerCaseTag</tagclass>

 <bodycontent>JSP</bodycontent>

 <info>To lower case tag</info>

</tag>

<%@ taglib uri="mytags" prefix="first" %>

<HTML>

<HEAD>

<TITLE>Body Tag</TITLE>

</HEAD>

<BODY bgcolor="#ffffcc">

<first:tolowercase>

Welcome to JSP Custom Tags Programming.

</first:tolowercase>

</BODY>

</HTML>

package tags;

import java.io.*;

import javax.servlet.jsp.*;

import javax.servlet.jsp.tagext.*;

public class LoopTag extends BodyTagSupport {

   int times = 0;

   BodyContent bodyContent;

   public void setTimes(int times) {

      this.times = times;

   }

   public int doStartTag() throws JspException {

      if (times>0) {

        return EVAL_BODY_TAG;

      } else {

         return SKIP_BODY;

      }

   }

   public void setBodyContent(BodyContent

   bodyContent) {

      this.bodyContent = bodyContent;

   }

   public int doAfterBody() throws JspException {

      if (times >1) {

        times--;

        return EVAL_BODY_TAG;

      } else {

         return SKIP_BODY;

      }

   }

   public int doEndTag() throws JspException {

      try {

         if(bodyContent != null) {

           bodyContent.writeOut(

           bodyContent.getEnclosingWriter());

         }

      } catch(IOException e) {

        throw new JspException(

        "Error: "+e.getMessage());

      }

      return EVAL_PAGE;

   }

}

• The doStartTag method gets called at the start of the tag. It checks if the loop needs to be performed.
• The setBodyContent is called by the JSP container to check for more than one loop.
• The doAfterBody method is called after each evaluation; the number of times the loop needs to be performed is decreased by one, then it returns SKIP_BODY when the number of times is not greater than one.
• The doEndTag method is called at the end of the tag, and the content (if any) is written to the enclosing writer.

<tag>

 <name>loop</name>

 <tagclass>tags.LoopTag</tagclass>

 <bodycontent>JSP</bodycontent>

 <info>Tag with body and parameter</info>

 <attribute>

     <name>times</name>

     <required>true</required>

     <rtexprvalue>true</rtexprvalue>

 </attribute>

</tag>

<%@ taglib uri="mytags" prefix="first" %>

<HTML>

<HEAD>

<TITLE>Body Tag</TITLE>

</HEAD>

<BODY bgcolor="#ffffcc">

<first:loop times="4">

Welcome to Custom Tags Programming.<BR>

</first:loop>

</BODY>

</HTML>

• Keep it simple: if a tag requires several attributes, try to break it up into several tags.
• Make it usable: consult the users of the tags (HTML developers) to achieve a high degree of usability.
• Do not invent a programming language in JSP: do not develop custom tags that allow users to write explicit programs.
• Try not to reinvent the wheel: there are several JSP tag libraries available, such as the Jakarta Taglibs Project. Check to see if what you want is already available so you do not have to reinvent the wheel.

WaQaR Aziz
BITF03 - Alumini 
Director Software Development -- Pentasoft inc.

Web Application Development with JSP and XML
Part II: JSP with XML in mind

By Qusay H. Mahmoud

The Extensible Markup Language (XML) has become the de facto standard data representation format for the Internet. XML data can be processed and interpreted on any platform--from handheld device to mainframe. It a perfect companion for Java applications that need portable data.

Java is the winner programming language to use with XML. Most XML parsers are written in Java, and it provides a comprehensive collection of Java APIs specifically targeted at building XML-based applications. JavaServer Pages^TM (JSP^TM) technology has access to all this since it can use the full power of the Java platform to access programming language objects to parse and transform XML documents. JSP has been designed with XML in mind; you can write a JSP page as an XML document!

This article presents a brief overview of XML, then it shows how to:

• Present XML documents
• Generate XML using JSP
• Parse XML documents using Simple Access API for XML (SAX) and Document
• Object Model (DOM)
• Use SAX and DOM in JSP
• Transform XML into other markup languages

Overview of XML

XML is a metalanguage used to define documents containing structured data. The features and benefits of XML can be grouped in the following major areas:

• Extensibility: as a metalanguage, XML can be used to create its own markup languages. Many XML-based markup languages exist today, including the Wireless Markup Language (WML).
• Precise structure: HTML suffers from loose structures and that makes it difficult to process HTML documents effectively. On the other hand, XML documents are well structured; each document has a root element and all elements must be nested within other elements.
• Two document types: there are two main XML document types
  1. Valid document: a valid XML document is defined by a Document Type Definition (DTD), which is the grammar of the document that defines what kind of elements, attributes, and entities may be in the document. The DTD defines the order as well as the occurrence of elements.
  2. Well-Formed document: a well-formed XML document does not have to adhere to a DTD. But it must follow two rules: 1) each element must have an open tag and a close tag. 2) there must be one root element that contains all other elements.
• Powerful extensions: as we mentioned earlier, XML is used to define syntax only. In other words, it is used to define content. To define the semantics, style, or presentation you need to use the Extensible Stylesheet Language (XSL). Note that a document may have multiple stylesheets that can be used by different users.

---

Note: A well-formed document is handy if the document is simple, or when processing simple structures over networks where bandwidth is a concern, since it does not have the overhead of a complex DTD.

---

XML versus HTML

XML and HTML are both markup languages, where tags are used to annotate data. The main differences are:

• In HTML, the syntax and semantics of the document are defined. HTML alone can be used to create a visible presentation to the user. XML allows you to define document syntax.
• HTML documents are not well-formed. For example, not all tags are closed with a matching tag. XML documents are well-formed.
• Tag names are case sensitive in XML, but not in HTML.

Let's look at an XML document. The following example is a sample XML document, from a fictitious quote server, representing a portfolio of stocks. As you can see, there is one root element (portfolio), and every element has a start tag and a close tag.

Sample 1: stocks.xml

<?xml version="1.0" encoding="UTF-8"?>
<portfolio>
  <stock>
    <symbol>SUNW</symbol>
    <name>Sun Microsystems</name>
    <price>17.1</price>
  </stock>
  <stock>
    <symbol>AOL</symbol>
    <name>America Online</name>
    <price>51.05</price>
  </stock>
  <stock>
    <symbol>IBM</symbol>
    <name>International Business Machines</name>
    <price>116.10</price>
  </stock>
  <stock>
    <symbol>MOT</symbol>
    <name>MOTOROLA</name>
    <price>15.20</price>
  </stock>
</portfolio>

The first line of Sample 1 states the XML version number, which is 1; and lets the processor know that the encoding scheme to be used is "UTF-8".

Although this is a simple document, it contains useful information that can be processed easily since it is well structured. For example, the stock server may want to sort the portfolio, in a specific order, based on the price of stocks.

Presenting XML Documents

XML documents contain portable data. This means that the example in Sample 1 can be processed for output to different browsers (desktop browser for the PC, microbrowser for the handheld device). In other words, an XML document can be transformed into HTML or WML or any other markup language.

If you load the stocks.xml document in a browser that supports XML (such as Microsoft's IE), you would see something similar to Figure 1.

Figure 1: stocks.xml in a browser

Basically, the browser has parsed the document and displayed it in a structured manner. But, this is not really useful from a user's point of view. Users want to see data displayed as useful information in a way that is easy to navigate.

One way to display XML documents nicely is to apply a transformation on the XML document, either to extract the data or create a new format (such as transforming XML data to HTML). This transformation can be done using a transformation language such as the Extensible Stylesheet Language Transformation (XSLT), which is part of XSL. XSL allows you to write XML vocabulary for specifying formatting semantics. In other words, there are two parts to XSL, which is part of the World Wide Web Consortium (W3C) Style Activity:

• Transformation language (XSLT)
• Formatting language (XSL formatting objects)

The XSL stylesheet in Sample 2 performs the required transformation for the portfolio element. It generates HTML markup and extracts data from the elements in the stocks.xml document.

Sample 2: stocks.xsl

<?xml version="1.0"?>

<xsl:stylesheet version="1.0" xmlns:xsl=
"http://www.w3.org/TR/WD-xsl">

<xsl:template match="/">
<html>
<head>
<title>Stocks</title>
</head>
<body bgcolor="#ffffcc" text="#0000ff">
<xsl:apply-templates/>
</body>
</html>
</xsl:template>

<xsl:template match="portfolio">

<table border="2" width="50%">
<tr>
<th>Stock Symbol</th>
<th>Company Name</th>
<th>Price</th>
</tr>
<xsl:for-each select="stock">
&lttr>
 <td>
   <i><xsl:value-of select=
   "symbol"/></i>
 </td>
<td&