5.1 主动对象

　　那么到底什么是主动对象呢？传统上，所有的对象都是被动的代码段，对象中的代码是在对它发出方法调用的线程中执行的。也就是，调用线程（calling threads）被“借出”，以执行被动对象的方法。

　　例如，设想对象“A”已在你的程序的main()函数中被实例化。当你的程序启动时，OS创建一个线程，以从main()函数开始执行。如果你调用对象A的任何方法，该线程将“流过”那个方法，并执行其中的代码。一旦执行完成，该线程返回调用该方法的点并继续它的执行。但是，如果”A”是主动对象，事情就不是这样了。在这种情况下，主线程不会被主动对象借用。相反，当”A”的方法被调用时，方法的执行发生在主动对象持有的线程中。另一种思考方法：如果调用的是被动对象的方法（常规对象），调用会阻塞（同步的）；而另一方面，如果调用的是主动对象的方法，调用不会阻塞（异步的）。

         DynaBean car = new LazyDynaBean();
         car.set("carNo",1);
         car.set("owner","张三");
         out.print(car.get("carNo"));

         看着像一个map,只不过多了反射的功能，所以支持那些使用反射来获取属性的场合。

         但是因为他没有car.getCarNo()这样的函数，只能用car.get("carNo")，所以也就不支持JSTL里面<c: out value="{car.carNo}">这样的语法，因为JSTL是默认转回car.getCarNo()的。
而且几经讨论,JSTL不支持 car.userFunction(),理由是不希望代码里有java代码:(

         因此，还是写<%=car.get("carNo")>好了，如果是陷在JSTL的一个循环结构里，就要用从pageContext里面把bean拿出来，
        又或者自己写的tag，幸亏也很简单，用BeanUtils.getProperty(bean,property)函数就可以了，
        又或者，用Velocity和Freemarker。

       最后，如果car.set("carNo",null)，会得到一个莫名其妙的Object对象，如果要使它为Null,需要先定义他的类型。
       因此，对于可能为Null的列，需要用LazyClass定义类型，幸亏也很Lazy, 不可能为Null的值可以不管。

      LazyDynaClass lc = new LazyDynaClass();
      lc.add("owner",String.class); // 指定null converter String
      DynaBean car = new LazyDynaBean(lc);
      car.set("carNo",1);
      car.set("owner",null);

JavaServer Pages (JSP) technology makes it easy to embed bits of Java code (or scriptlets) in HTML documents. This solution, however, may not be suitable for all HTML content developers, perhaps because they do not know Java and they do not care to learn its syntax. While JavaBeans can be used to encapsulate much of the Java code, using them in JSP pages still requires content developers to have some knowledge of Java syntax.

JSP technology allows you to introduce new custom tags through the tag library facility. As a Java developer, you can extend JSP pages by introducing custom tags that can be deployed and used in an HTML-like syntax. Custom tags also allow you to provide better packaging by improving the separation between business logic and presentation logic.

This article presents a brief overview of custom tags, then it shows:

• 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)

Finally, some programming guidelines are also provided.

Overview of Tags

If you have experience with HTML, you already know about the types of tags that can be used. Basically there are two types of tags, and both can have attributes (information about how the tag should do its job):

• 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"/>
  

  Bodyless tags are used to represent certain functions, such as presenting an input field, or displaying an image. Here is an example of a bodyless tag in HTML:

  <IMG SRC="/developer/technicalArticles/xml/WebAppDev3/fig10.gif">

• 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>

  
  

  Tags with a body are used to perform operations on the body content, such as formatting. Here is an example of a tag with a body in HTML:

  <H2>Custom Tags</H2>

JSP Custom Tags

JSP custom tags are merely Java classes that implement special interfaces. Once they are developed and deployed, their actions can be called from your HTML using XML syntax. They have a start tag and an end tag. They may or may not have a body. A bodyless tag can be expressed as:

<tagLibrary:tagName />

And, a tag with a body can be expressed as:

<tagLibrary:tagName>
   body
</tagLibrary:tagName>

Again, both types may have attributes that serve to customize the behavior of a tag. The following tag has an attribute called name, which accepts a String value obtained by evaluating the variable yourName:

<mylib:hello name="<%= yourName %>" />

Or, it can be written as a tag with a body as:

<mylib:hello>
  <%= yourName %>
</mylib:hello>

Note: Any data that is a simple string, or can be generated by evaluating a simple expression, should be passed as an attribute and not as body content.

Benefits of Custom Tags

A very important thing to note about JSP custom tags is that they do not offer more functionality than scriptlets, they simply provide better packaging, by helping you improve the separation of business logic and presentation logic. Some of the benefits of custom tags are:

• 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.

In short, you can use custom tags to accomplish complex tasks the same way you use HTML to create a presentation.

Defining a Tag

A tag is a Java class that implements a specialized interface. It is used to encapsulate the functionality from a JSP page. As we mentioned earlier, a tag can be bodyless or with a body. To define a simple bodyless tag, your class must implement the Tag interface. Developing tags with a body is discussed later. Sample 1 shows the source code for the Tag interface that you must implement:

Sample 1: Tag.java

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();
}

All tags must implement the Tag interface (or one of its subinterfaces) as it defines all the methods the JSP runtime engine calls to execute a tag. Table 1 provides a description of the methods in the Tag interface.

My First Tag

Now, let's look at a sample tag that when invoked prints a message to the client.

There are a few steps involved in developing a custom tag. These steps can be summarized as follows:

1. Develop the tag handler
2. Create a tag library descriptor
3. Test the tag

1. Develop the Tag Handler

A tag handler is an object invoked by the JSP runtime to evaluate a custom tag during the execution of a JSP page that references the tag. The methods of the tag handler are called by the implementation class at various points during the evaluation of the tag. Every tag handler must implement a specialized interface. In this example, the simple tag implements the Tag interface as shown in Sample 2.

Sample 2: HelloTag.java

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;
   }
}

The two important methods to note in HelloTag are doStartTag and doEndTag. The doStartTag method is invoked when the start tag is encountered. In this example, this method returns SKIP_BODY because a simple tag has no body. The doEndTag method is invoked when the end tag is encountered. In this example, this method returns SKIP_PAGE because we do not want to evaluate the rest of the page; otherwise it should return EVAL_PAGE.

To compile the HelloTag class, assuming that Tomcat is installed at: c:\tomcat:

• 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
  

2. Create a Tag Library Descriptor

The next step is to specify how the tag will be used by the JSP runtime that executes it. This can be done by creating a Tag Library Descriptor (TLD), which is an XML document. Sample 3 shows a sample TLD:

Sample 3: mytaglib.tld

<?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>

First we specify the tag library version and JSP version. The <shortname> tag specifies how we are going to reference the tag library from the JSP page. The <uri> tag can be used as a unique identifier for your tag library.

In this TLD, we only have one tag named hello whose class is specified using the <tagclass> tag. However, a tag library can have as many tags as you like. The <bodycontent> tells us that this tag will not have a body; otherwise an error will be produced. On the other hand, if you like to evaluate the body of the tag, that value would be:

• 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.

Save mytaglib.tld in the directory: c:\tomcat\webapps\examples\web-inf\jsp.

3. Test the Tag

The final step is to test the tag we have developed. In order to use the tag, we have to reference it, and this can be done in three ways:

1. Reference the tag library descriptor of an unpacked tag library. For example:

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

2. Reference a JAR file containing a tag library. For example:

   <@ taglib uri="/WEB-INF/myJARfile.jar" 
   prefix='first" %>
   

3. Define a reference to the tag library descriptor from the web-application descriptor (web.xml) and define a short name to reference the tag library from the JSP. To do this, open the file: c:\tomcat\webapps\examples\web-inf\web.xml and add the following lines before the end line, which is <web-app>:

   <taglib> <taglib-uri>mytags</taglib-uri> <taglib-location>/WEB-INF/jsp/ mytaglib.tld</taglib-location> </taglib>

   
   

Now, write a JSP and use the first syntax. Sample 4 shows an example:

Sample 4: Hello.jsp

<%@ 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>

The taglib is used to tell the JSP runtime where to find the descriptor for our tag library, and the prefix specifies how we will refer to tags in this library. With this in place, the JSP runtime will recognize any usage of our tag throughout the JSP, as long as we precede our tag name with the prefix first as in <first:hello/>.

Alternatively, you can use the second reference option by creating a JAR file. Or, you can use the third reference option simply by replacing the first line in Sample 4 with the following line:

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

Basically, we have used the mytags name, which was added to web.xml, to reference the tag library. For the rest of the examples in this article, this reference will be used.

Now, if you request Hello.jsp from a browser, you would see something similar to Figure 1.

Figure 1: First Custom Tag

The custom tag developed in Sample 4 is a simple tag, the goal of it was just to give you a flavor of the effort involved in developing custom tags. You may have noticed that even this simple tag required us to implement a number of methods, some of which have very simple implementations. To minimize the effort involved, the JSP designers provided a template to be used for implementing simple tags. The template is the TagSupport abstract class. It is a convenience class that provides default implementations for all the methods in the Tag interface.

Therefore, an easier way to write simple tags is to extend the TagSupport class rather than implementing the Tag interface. You can think of the TagSupport abstract class as an adapter. Having said that, the HelloTag class in Sample 4 can be easily written as shown in Sample 5.

Sample 5: Extending the TagSupport class

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;
   }
}

Parameterized Tags

We have seen how to develop simple tags. Now, let's see how to develop parameterized tags--tags that have attributes. There are two new things that that need to be added to the previous example to handle attributes:

1. Add a set method
2. Add a new tag to mytagslib.tld

Adding a set method and changing the output message results in Sample 5.

Sample 5: A tag with an attribute

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;
   }
}

The next thing we need to do is add a new tag to mytaglib.tld. The new tag is shown in Sample 6. This snippet of code should be added to mytaglib.tld right before the last line, </taglib>:

Sample 6: revising mytaglib.tld

<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>

We have added a new tag named helloparam. Notice the new <attribute> tag, which specifies that the helloparam tag accepts an attribute whose name is name. The <required> tag is set to false, meaning that the attribute is optional; the <rtexprvalue> tag is set to false specifying that no run time evaluation will be done.

Nothing needs to be added to the web.xml web-application descriptor file since we are using the same tag library: mytaglib.tld.

Now, we can test the new tag. The source code in Sample 7 shows how to test it using a name attribute "JavaDuke".

Sample 7: HelloTagParam.jsp

<%@ 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>

If you request HelloTagParam.jsp from a web browser, you would see an output similar to that in Figure 2.

Figure 2: Testing a parameterized tag

Tag Libraries

A tag library is a collection of JSP custom tags. The Jakarta Taglibs Project provides several useful tag libraries for XML parsing, transformations, email, databases, and other uses. They can be easily downloaded and used.

Here we develop our tag library. As an example, we develop a simple math library that provides two tags, one for adding two numbers, and the other for subtracting one number from another number. Each tag is represented by one class. The source code for the two classes, Add.java and Subtract.java, is shown in Sample 8.

Sample 8: Add.java and Subtract.java

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;
   }
}

The source code is easy to understand. Notice one thing we have repeated in Add.java and Subract.java is the call to pageContext.getOut.print. A better way to do this would be to get a JspWriter object then then use it to print to the client:

JspWriter out = pageContext.getOut();
out.print("first line");
out.print("second line");

The next step is to revise the tag library descriptor file, mytaglib.tld, and add descriptions to the two new tags. Sample 9 shows the description for the new tags. Add the following snippet of XML to mytaglib.tld, right before the last line.

Sample 9: revising mytaglib.tld

  <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>

As you can see, each tag requires two attributes that must be named num1 and num2.

Now, we can test our math tag library using the test driver shown in Sample 10.

Sample 10: math.jsp

<%@ 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>

If you request math.jsp from a web browser, you would see an output that is similar to Figure 3.

Figure 3: Testing the math tag library

Tags with a Body

A tag handler for a tag with a body is implemented differently depending on whether the body needs to be evaluated once or multiple times.

• 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.

Single Evaluation

Here is an example of single evaluation where we extend the BodyTagSupport class. This example reads the body content, converts it to lowercase, then writes the output back to the client. Sample 11 shows the source code. The body content is retrieved as a string, converted to lowercase, then written back to the client.

Sample 11: ToLowerCaseTag.java

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;
   }
}

The next step is to add a tag to the tag library descriptor file, mytaglib.tld. The new tag descriptor is:

<tag>
  <name>tolowercase</name>
  <tagclass>tags.ToLowerCaseTag</tagclass>
  <bodycontent>JSP</bodycontent>
  <info>To lower case tag</info>
</tag>

Note that when you write a tag with a body, the <bodycontent> tag's value must be either JSP or jspcontent, as discussed earlier.

A test driver for this example is shown in Sample 12.

Sample 12: lowercase.jsp

<%@ 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>

If you request lowercase.jsp from a web browser, you would see something similar to Figure 4.

Figure 4: Testing the lowercase tag

Multiple Evaluations

Let's now see an example of a body tag evaluated multiple times. The example accepts a string and prints the string as many times as indicated in the JSP. The source code is shown in Sample 13:

Sample 13: LoopTag.java

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;
   }
}

In this example, the methods implemented play the following roles:

• 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.

Similarly to previous examples, the next step is to add a new tag descriptor to mytaglib.tld. The following lines show what needs to be added:

<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>

Note that the <rtexprvalue> tag specifies that evaluations will be performed at runtime.

A test driver is shown in Sample 14.

Sample 14: loops.jsp

<%@ 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>

Finally, if you request loops.jsp from a browser, you would see output similar to that in Figure 5.

Figure 5: Testing loops.jsp

Programming Guidelines

Here are a few guidelines to keep in mind when developing JSP tag libraries:

• 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.

Conclusion

In Web Application Development with JSP and XML Part II: JSP with XML in mind, we have seen how to parse XML documents. But even the untrained eye would have noticed that we have embedded lots of the parsing (or logic) code in JSP. Even though we have used JavaBeans to encapsulate much of the Java code, we still ended up with JavaServer Pages mixing program logic with presentation.

Custom tags help you improve the separation of program logic (parsing and iteration in Part II), and presentation. The various examples in this article show how to develop and deploy simple and advanced custom tags. As an exercise, you may want to rewrite the SAX and DOM examples in Part II as tag libraries. Also, you may wish to look at what the Jakarta Taglibs Project has to offer for XML parsing and XSL transformations. It provides tag libraries for other things as well.

For more information

Javaserver Pages, Dynamically Generated Web Content
Javaserver Pages Tag Libraries
Jakarta Taglibs Project
The Jakarta Taglibs Project--Part I
A Standard Tag Library for JavaServer Pages

About the author

Qusay H. Mahmoud provides Java consulting and training services. He has published dozens of articles on Java, and is the author of Distributed Programming with Java (Manning Publications, 1999).

 public static void main(String[] args) {
  
  Parent parent = new Parent();
  Child child = new Child();
  
  if (child instanceof Child){
   System.out.println("child instanceof Child is true!");
  } else {
   System.out.println("child instanceof Child is false!");
  }
  if (child instanceof Parent){
   System.out.println("child instanceof Parent is true!");
  } else {
   System.out.println("child instanceof Parent is false!");
  }
  if (child instanceof Person){
   System.out.println("child instanceof Person is true!");
  } else {
   System.out.println("child instanceof Person is false!");
  }
  
  if (Child.class.isInstance(child)){
   System.out.println("Child.class.isInstance(child) is true!");
  } else {
   System.out.println("Child.class.isInstance(child) is false!");
  }
  if (Parent.class.isInstance(child)){
   System.out.println("Parent.class.isInstance(child) is true!");
  } else {
   System.out.println("Parent.class.isInstance(child) is false!");
  }
  if (Person.class.isInstance(child)){
   System.out.println("Person.class.isInstance(child) is true!");
  } else {
   System.out.println("Person.class.isInstance(child) is false!");
  }
  
  if (Child.class.isAssignableFrom(Child.class)){
   System.out.println("Child.class.isAssignableFrom(Child.class) is true!");
  } else {
   System.out.println("Child.class.isAssignableFrom(Child.class) is false!");
  }
  if (Child.class.isAssignableFrom(Parent.class)){
   System.out.println("Child.class.isAssignableFrom(Parent.class) is true!");
  } else {
   System.out.println("Child.class.isAssignableFrom(Parent.class) is false!");
  }
  if (Child.class.isAssignableFrom(Person.class)){
   System.out.println("Child.class.isAssignableFrom(Person.class) is true!");
  } else {
   System.out.println("Child.class.isAssignableFrom(Person.class) is false!");
  }
  //Parent class implemented the Interface 'Person'
  if (Parent.class.isAssignableFrom(Person.class)){
   System.out.println("Parent.class.isAssignableFrom(Person.class) is true!");
  } else {
   System.out.println("Parent.class.isAssignableFrom(Person.class) is false!");
  }
  
  
  if (Child.class.isAssignableFrom(Child.class)){
   System.out.println("Child.class.isAssignableFrom(Child.class) is true!");
  } else {
   System.out.println("Child.class.isAssignableFrom(Child.class) is false!");
  }
  if (Parent.class.isAssignableFrom(Child.class)){
   System.out.println("Parent.class.isAssignableFrom(Child.class) is true!");
  } else {
   System.out.println("Parent.class.isAssignableFrom(Child.class) is false!");
  }
  if (Person.class.isAssignableFrom(Child.class)){
   System.out.println("Person.class.isAssignableFrom(Child.class) is true!");
  } else {
   System.out.println("Person.class.isAssignableFrom(Child.class) is false!");
  }
  //Parent class implemented the Interface 'Person'
  if (Person.class.isAssignableFrom(Parent.class)){
   System.out.println("Person.class.isAssignableFrom(Parent.class) is true!");
  } else {
   System.out.println("Person.class.isAssignableFrom(Parent.class) is false!");
  }
  
  
  
  
 }
}





public class Child extends Parent {

 public static void main(String[] args) {
 }
}



public class Parent implements Person {

 public static void main(String[] args) {
 }
}



public interface Person {

}

    java.lang.String类对大家来说最熟悉不过了，我们写java程序很少能不用String的。本文讲述如何正确的使用String，内容主要涉及初始化、串联和比较等操作。 

    首先我们必须清楚的一点是String类是final类型的，因此你不可以继承这个类、不能修改这个类。我们使用String的时候非常简单，通常都是String s = "hello"，但是Java API中同时提供了一个构造函数为String(String s)，因此你也可以这样使用String s = new String("hello")，对于后面这样初始化一个String的方式是不推荐的，因为new操作符意味着将会在heap上生成一个新的对象，如果这样的操作发生在一个循环中，那么代价是惨重的。比如
for(int i = 0;i<1000;i++)
{
    String s = new String("hello");
}
    这将会创建1000个String类型的对象，由于String类是final的，因此这样的操作事实上是每次都生成了一个新的String对象的。如果你使用String s = "hello";那么就可以实现复用了，为什么可以复用呢，下面会有解释。

    当我们使用"+"实现串联操作的时候，比如String s = "hello"+"world";其实是通过StringBuffer类的append()方法实现的，最后返回String给s。如果有兴趣的话，你可以写一个简单的例子，然后用javap看看虚拟机是如何工作的。在使用串联的时候我们同样应该注意String是final类，如果你需要多次串联比如：
String sql = "xxx";
sql = "xxxx";
sql = "ssssss";
那么为了提高效率节省空间，我们应该自己用StringBuffer来替代"+";

    通常对String的比较有两种情况，一个是使用==，另一个是使用equals()方法，注意==是对对象的地址进行比较的，而String中的equals()方法是覆盖了Object类的方法，并且实现为对String对象的内容的比较。所以String s1 = new String("hello");String s2 = new String("hello")，我们对s1和s2进行上述比较的时候，前者应该返回false,因为使用new生成的是两个不同的对象。后者应该返回true因为他们的内容是一样的，都是"hello"。那么如果我们还有一个String s3 = "hello";他和s1的比较应该是什么样子的呢，答案是s1==s3为false，equals的比较位true。事实上String类是维持着一个String池的，这个池初始化为空的，当我们String x = "hello"的时候，hello就会被放入这个池中，当我们再次String y = "hello"的时候，他首先去检查池中是否存在一个和hello内容一样的对象，如果存在的话就会把这个引用返回给y,如果不存在的话，就会创建一个并放入到池中。这样就实现了复用。在String有一个方法intern()他可以把String的对象放入到池冲并返回池中的对象。如果我们对s1(String s1 = new String("hello"))调用intern,s1 = s1.intern()这时候，我们再把s1和s3进行“==”的判断，你会发现结果返回true!
    看下面的例子

public class StringTest
{

    public static void main(String[] args)
    {
        String s1 = "hello";
        String s2 = new String("hello");
        String s3 = new String("hello");
       
        testString(s1,s2,s3);
        s2 = s2.intern();
        System.out.println("after s2.intern");
        testString(s1,s2,s3);   

     }
       private static void testString(String s1,String s2,String s3)
    {
        System.out.println("s1 = s2 is "+(s1==s2));
        System.out.println("s2 = s3 is "+(s2==s3));
        System.out.println("s1.equals(s2) is "+s1.equals(s2));
        System.out.println("s2.equals(s3) is "+s2.equals(s3));
    }
}
输出结果为
s1 = s2 is false
s2 = s3 is false
s1.equals(s2) is true
s2.equals(s3) is true
after s2.intern
s1 = s2 is true
s2 = s3 is false
s1.equals(s2) is true
s2.equals(s3) is true

Digester学习笔记(二)

http://www.infomall.cn/cgi-bin/mallgate/20040310/http://hedong.3322.org/archives/000336.html

　　为便于理解，将笔记的内容结构作了一些调整。

对象栈

1. clear(),清空栈的内容
   
2. peek(),返回对栈顶对象的引用
   
3. pop(),将栈顶对象弹出并返回
   
4. push(),将一个新的对象压入栈顶

日志(logging)

1. SAX相关的信息，被送往org.apache.commons.digester.Digester.sax记录器，记录了Digester收到的SAX的事件的信息。
2. 其它的所有信息，都被送往org.apache.commons.digester.Digester记录器，这个记录器在调试Digester时打开而在产品中常将其关闭

Digester包中的例子

http://java.sun.com/webservices/docs/1.0/tutorial/doc/Servlets4.html#64218

Servlet Life Cycle

The life cycle of a servlet is controlled by the container in which the servlet has been deployed. When a request is mapped to a servlet, the container performs the following steps.

1. If an instance of the servlet does not exist, the Web container
   1. Loads the servlet class.
   2. Creates an instance of the servlet class.
   3. Initializes the servlet instance by calling the init method. Initialization is covered in Initializing a Servlet.
2. Invokes the service method, passing a request and response object. Service methods are discussed in Writing Service Methods.

If the container needs to remove the servlet, it finalizes the servlet by calling the servlet's destroy method. Finalization is discussed in Finalizing a Servlet.

Handling Servlet Life Cycle Events

You can monitor and react to events in a servlet's life cycle by defining listener objects whose methods get invoked when life cycle events occur. To use these listener objects you must define the listener class and specify the listener class.

Defining The Listener Class

You define a listener class as an implementation of a listener interface. Servlet Life Cycle Events lists the events that can be monitored and the corresponding interface that must be implemented. When a listener method is invoked, it is passed an event that contains information appropriate to the event. For example, the methods in the HttpSessionListener interface are passed an HttpSessionEvent, which contains an HttpSession.

The listeners.ContextListener class creates and removes the database helper and counter objects used in the Duke's Bookstore application. The methods retrieve the Web context object from ServletContextEvent and then store (and remove) the objects as servlet context attributes.

import database.BookDB;
import javax.servlet.*;
import util.Counter;

public final class ContextListener
  implements ServletContextListener {
  private ServletContext context = null;
  public void contextInitialized(ServletContextEvent event) {
    context = event.getServletContext();
    try {
      BookDB bookDB = new BookDB();
      context.setAttribute("bookDB", bookDB);
    } catch (Exception ex) {
      System.out.println(
        "Couldn't create database: " 
        + ex.getMessage());
    }
    Counter counter = new Counter();
    context.setAttribute("hitCounter", counter);
    context.log("Created hitCounter"
      + counter.getCounter());
    counter = new Counter();
    context.setAttribute("orderCounter", counter);
    context.log("Created orderCounter"
      + counter.getCounter());
  }

  public void contextDestroyed(ServletContextEvent event) {
    context = event.getServletContext();
    BookDB bookDB = context.getAttribute(
      "bookDB");
    bookDB.remove();
    context.removeAttribute("bookDB");
    context.removeAttribute("hitCounter");
    context.removeAttribute("orderCounter");
  }
}
 

Specifying Event Listener Classes

To specify an event listener class, you add a listener element to the Web application deployment descriptor. Here is the listener element for the Duke's Bookstore application:

<listener>
  <listener-class>listeners.ContextListener</listener-class>
</listener>
 

You specify a listener class for a WAR in the deploytool Event Listeners inspector (see Event Listeners).

Handling Errors

Any number of exceptions can occur when a servlet is executed. The Web container will generate a default page containing the message A Servlet Exception Has Occurred when an exception occurs, but you can also specify that the container should return a specific error page for a given exception. To specify such a page, you add an error-page element to the Web application deployment descriptor. These elements map the exceptions returned by the Duke's Bookstore application to errorpage.html:

<error-page>
  <exception-type>
    exception.BookNotFoundException
  </exception-type>
  <location>/errorpage.html</location>
</error-page>
<error-page>
  <exception-type>
    exception.BooksNotFoundException
  </exception-type>
  <location>/errorpage.html</location>
</error-page>
<error-page>
  <exception-type>exception.OrderException</exception-type>
  <location>/errorpage.html</location>
</error-page>
 

You specify error pages for a WAR in the deploytool File Refs inspector (see Error Mappings).

元素listener

标签库可以指定一些类——事件监听类。（参照处理servlet生命周期事件）。这些监听类都作为listener元素列于TLD中，网络容器将实例化监听类并通过与在WAR中定义的监听类类似的方法来注册。不像WAR级的监听类，，标签库中注册的监听类没有定义顺序。Listener元素的唯一子元素是listener-class，它必须包含监听类名的全称。
http://www.leftworld.net/online/j2ee/13.htm

带属性的标签

在标签handler中定义属性

对于每一个标签属性，都必须在标签handler中定义一个属性以及符合JavaBean结构规范的get和set方法。例如，logic:present标签的标签handler

<logic:present parameter="Clear">

包含下列声明和方法：

protected String parameter = null;
public String getParameter() {
  return (this.parameter);
}
public void setParameter(String parameter) {
  this.parameter = parameter;
}

注意，如果属性命名为id并且标签handler继承自TagSupport类，那么就不需要定义属性和set和get方法，因为它们已经由TagSupport定义了。

值为String的标签属性可以指定标签handler可用的隐式对象的一个属性。通过向隐式对象的[set|get]Attribute方法传递标签属性值可以访问一个隐式对象属性。这是将脚本变量名传递给标签handler的好方式，在这里脚本变量与储存在页面上下文中的对象相关联(见隐式对象)。

attribute元素

对于每一个标签属性，都必须在attribute元素中指定这个属性是否是必需的、其值是否可以由表达式确定、还可能指定属性的类型。对于静态值，类型总是java.lang.String。如果rtexprvalue元素是true或者yes，那么type元素定义会将任何指定的表达式的预期返回类型指定为属性的值。

<attribute>
  <name>attr1</name>
  <required>true|false|yes|no</required>
  <rtexprvalue>true|false|yes|no</rtexprvalue>
  <type>fully_qualified_type</type>
</attribute>

如果tag属性不是必需的，那么标签handler应该提供一个默认值。

logic:present标签的tag元素声明parameter属性不是必需的(因为标签还可以测试是否存在其它实体，如bean属性)以及其值可以由运行时表达式设置。

<tag>
  <name>present</name>
  <tag-class>org.apache.struts.taglib.
    logic.PresentTag</tag-class>
  <body-content>JSP</body-content>
  ...
  <attribute>
    <name>parameter</name>
    <required>false</required>
    <rtexprvalue>true</rtexprvalue>
  </attribute>
  ...
</tag>

属性验证

标签库的文档应该描述标签属性的有效值。在转换JSP页面时，Web容器将强制应用每一个属性的TLD元素中包含的限制。

在转换时还用从TagExtraInfo派生的类的isValid方法验证传递给标签的属性。这个类也用于提供有关标签定义的脚本变量的信息(见提供有关脚本变量的信息)。

用TagData对象向isValid方法传递属性信息，它包含每一个标签属性的属性-值元组。因为验证在转换时发生，所以在请求时计算的属性值将设置为TagData.REQUEST_TIME_VALUE。

<tt:twa attr1="value1"/>标签有下列TLD attribute元素：

<attribute>
  <name>attr1</name>
  <required>true</required>
  <rtexprvalue>true</rtexprvalue>
</attribute>

这个声明表明attr1的值可以在运行时确定。

下面的isValid方法检查attr1的值是否为有效的布尔值。注意由于的attr1值可以在运行时计算，所以isValid必须检查标签用户是否选择了提供运行时值。

public class TwaTEI extends TagExtraInfo {
  public boolean isValid(Tagdata data) {
    Object o = data.getAttribute("attr1");
    if (o != null && o != TagData.REQUEST_TIME_VALUE) {
      if (((String)o).toLowerCase().equals("true") ||
        ((String)o).toLowerCase().equals("false") )
        return true;
      else
        return false;
    }
    else
      return true;   }
}

带正文的标签

标签handler

带正文的标签的标签handler根据标签handler是否需要与正文交互而有不同的实现。我们说的交互的意思是标签handler读取或者修改正文的内容。

标签handler不与正文交互

如果标签handler不需要与正文交互，那么标签handler应该实现Tag接口(或者从TagSupport派生)。如果需要对标签的正文进行判断，那么doStartTag方法就需要返回EVAL_BODY_INCLUDE，否则，它应该返回SKIP_BODY。

如果标签handler需要反复地判断正文，那么它就应该实现IterationTag接口或者从TagSupport派生。如果它确定需要再次评估正文，那么它应该从doStartTag和doAfterBody方法返回EVAL_BODY_AGAIN。

标签handler与正文交互

如果标签handler需要与正文交互，那么标签handler必须实现BodyTag (或者从BodyTagSupport派生)。这种处理器通常实现doInitBody和doAfterBody方法。这些方法与由JSP页面的servlet传递给tag handler的正文内容交互。

正文内容支持几种读取和写入其内容的方法。标签handler可以用正文内容的getString或者getReader方法从正文中提取信息，用writeOut(out)方法将正文内容写入一个输出流。为writeOut方法提供的writer是用标签handler的getPreviousOut方法得到的。用这个方法保证标签handler的结果对于其外围标签handler是可用的。

如果需要对标签的正文进行判断，那么doStartTag方法需要返回EVAL_BODY_BUFFERED，否则它就应该返回SKIP_BODY。

doInitBody 方法

在已经设置正文内容之后、但是对它进行判断之前调用doInitBody方法。一般用这个方法执行所有依赖于正文内容的初始化。

doAfterBody方法

doAfterBody方法在判断了正文内容之后调用。

像doStartTag方法一样，doAfterBody必须返回指明是否继续判断正文的指示。因此，如果应该再次判断正文，就像实现枚举标签的情况，那么doAfterBody应该返回EVAL_BODY_BUFFERED，否则doAfterBody应该返回SKIP_BODY。

Release方法

标签handler应该在release方法中重新设置其状态并释放所有私有资源。

下面的例子读取正文的内容(它包含一个SQL查询)并将它传递给一个执行这个查询的对象。因为不需要对正文再次判断，所以doAfterBody返回SKIP_BODY。

public class QueryTag extends BodyTagSupport {
  public int doAfterBody()
throws JspTagException {
    BodyContent bc = getBodyContent();
    // get the bc as string
    String query = bc.getString();
    // clean up     bc.clearBody();
    try {
      Statement stmt = connection.createStatement();
      result = stmt.executeQuery(query);
    } catch (SQLException e) {
      throw new JspTagException("QueryTag: " +
         e.getMessage());
    }
    return SKIP_BODY;
  }
}

body-content元素

对于有正文的标签，必须用body-content元素指定正文内容的类型：

<body-content>JSP|tagdependent</body-content>

正文内容包含自定义和核心标签、脚本元素以及属于JSP的HTML文字。这是为Struts logic:present标签声明的值。所有其它类型的正文内容——如传递给查询标签的SQL语句，都标记为tagdependent。

注意body-content元素的值不影响标签handler对正文的解读，这个元素只是由编写工具用于呈现正文内容。

定义脚本变量的标签

标签handler

标签handler负责创建脚本变量引用的对象并设置到页面可以访问的上下文中。它是用pageContext.setAttribute(name, value, scope)或者pageContext.setAttribute(name, value)方法完成这项工作的。通常传递给自定义标签的属性指定脚本变量对象的名字，通过调用在使用范围对象中描述的属性的get方法可以提取这个名字。

如果脚本变量的值依赖于在标签handler上下文中出现的一个对象，那么它可以用pageContext.getAttribute(name, scope)方法提取这个对象。

一般的通常过程是标签handler提取脚本变量、对对象执行一些处理、再用pageContext.setAttribute(name, object)方法设置脚本变量的值。

表16-4总结了对象可以有的作用域。作用域限制了对象的可访问性和寿命。

提供有关脚本变量的信息

在定义脚本变量的标签中描述的例子定义了用于访问图书信息的脚本变量：book

<bean:define id="book"
name="bookDB" property="bookDetails"
  type="database.BookDetails"/>
<font color="red" size="+2">
  <%=messages.getString("CartRemoved")%>
  <strong><jsp:getProperty name="book"
      property="title"/></strong>
<br>&nbsp;<br>
</font>

在转换包含这个标签的JSP页面时，Web容器会生成同步脚本变量与由变量引用的对象的代码。要生成这些代码，Web容器需要关于脚本变量的一些信息：

·  变量名

·  变量类

·  变量是否引用新的对象或者是现有对象

·  变量的可用性

有两种方法提供这种信息：指定variable TLD子元素或者定义tag extra info类并在TLD中包含tei-class元素。用variable元素更简单，但是灵活性要差一些。

variable 元素

variable元素有下列子元素：

·  name-given：变量名为常量

·  name-from-attribute：一个属性的名字，其转换时（translation-time）值将给出属性的名字

必须有name-given或者name-from-attribute之中的一个。下列子元素是可选的：

·  variable-class—变量的完全限定名。默认为java.lang.String。

·  declare—变量是否引用新对象。默认为True。

·  scope—定义的脚本变量的作用域。默认为NESTED。表16-5描述了脚本变量的可用性以及必须设置或者重新设置变量值的方法。

Struts bean:define标签的实现符合JSP规范版本1.1，它要求定义tag extra info类。JSP规范版本1.2增加了variable元素。可以为bean:define标签定义下面的variable元素：

<tag>
  <variable>
    <name-from-attribute>id</name-from-attribute>
    <variable-class>database.BookDetails</variable-class>
    <declare>true</declare>
    <scope>AT_BEGIN</scope>
  </variable>
</tag>

TagExtraInfo类

通过扩展类javax.servlet.jsp.TagExtraInfo定义tag extra info类。TagExtraInfo. A TagExtraInfo必须实现getVariableInfo方法以返回包含下列信息的VariableInfo对象数组：

·  变量名

·  变量类

·  变量是否引用新对象

·  变量可用性

Web容器向getVariableInfo方法传递包含每一个标签属性的属性-值元组的名为data的参数。这些属性可以用于为VariableInfo对象提供脚本变量名和类。

Struts标签库提供有关由DefineTei tag extra info类中的bean:define标签创建的脚本变量的信息。由于脚本变量的name (book)和class (database.BookDetails)作为标签属性传递，所以可以用data.getAttributeString方法提取它们，并用于填充VariableInfo构造函数。要使脚本变量book用于页面的其他地方，book的作用域设置为AT_BEGIN。

public class DefineTei extends TagExtraInfo {
  public VariableInfo[] getVariableInfo(TagData data) {
  String type = data.getAttributeString("type");
    if (type == null)
      type = "java.lang.Object";
    return new VariableInfo[] {
      new VariableInfo(data.getAttributeString("id"),
        type,
        true,
        VariableInfo.AT_BEGIN)
    };
  }
}

为脚本变量定义的tag extra info类的完全限定名必须在tag元素的tei-class子元素的TLD中声明。因此，DefineTei的tei-class元素像下面这样：

<tei-class>
  org.apache.struts.taglib.bean.DefineTagTei
</tei-class>

标签协同操作

标签通过共享对象实现合作。JSP技术支持两种类型的对象共享。

第一种类型要求在页面上下文中命名和储存共享的对象(JSP页面和标签handler都可以访问的一种隐式对象)。要访问由另一个标签创建和命名的对象，标签handler使用pageContext.getAttribute(name, scope)方法。

在第二种对象共享类型中，由一组嵌入标签中的外围标签handler创建的对象可以被所有内部标签handler访问。这种形式的对象共享的优点是它对对象使用私有命名空间，因此减少了潜在的命名冲突。

要访问由外围标签创建的对象，标签handler必须首先用静态方法TagSupport.findAncestorWithClass(from, class)或者TagSupport.getParent方法获得其外围标签。在不能保证有特定的嵌入标签handler时应该使用前一个方法。一旦获取了上级，那么标签handler就可以访问所有静态或动态创建的对象了。静态创建的对象是父标签的成员。私有对象也可以动态创建。这种对象可以用setValue方法储存在标签 handler中，并用getValue方法获取它。

下面的例子展示了同时支持命名的和私有对象方式共享对象的标签handler。在这个例子中，查询标签的handler检查名为connection的属性是否已在doStartTag方法中设置。如果属性已经设置，那么handler就从页面上下文中获取连接对象。否则，标签handler首先获取外围标签的标签handler，然后从那个handler中获取连接对象。

public class QueryTag extends BodyTagSupport {
  private String connectionId;
  public int doStartTag()
throws JspException {
    String cid = getConnection();
    if (cid != null) {
    // there is a connection id, use it
      connection =(Connection)pageContext.
        getAttribute(cid);
    } else {
      ConnectionTag ancestorTag =
        (ConnectionTag)findAncestorWithClass(this,
          ConnectionTag.class);
      if (ancestorTag == null) {
        throw new JspTagException("A query without
          a connection attribute must be nested
          within a connection tag.");
      }
      connection = ancestorTag.getConnection();
    }
  }
}

由这个标签 handler实现的查询标签可以以下面任何一种方式使用：

<tt:connection id="con01" ....>
...
</tt:connection>
<tt:query id="balances" connection="con01">
  SELECT account, balance FROM acct_table
    where customer_number = <%= request.getCustno()%>
</tt:query>
  <tt:connection ...>
  <x:query id="balances">
    SELECT account, balance FROM acct_table
      where customer_number = <%= request.getCustno()%>
  </x:query>
</tt:connection>

标签handler的TLD必须用下面声明指明connection属性是可选的：

<tag>
  ...
  <attribute>
    <name>connection</name>
    <required>false</required>
  </attribute>
</tag>

示例

本节中描述的自定义标签展示了在开发JSP应用程序时会经常遇到的两个问题的解决方法：尽可能减少JSP页面中的Java编程以及保证整个应用程序的共同外观。在这个过程中，展示了本章前面讨论过的许多类型的标签。

迭代（Iteration）标签

构建依赖于动态生成的数据的页面内容通常需要使用流控制脚本语句。通过将流控制逻辑转换到标签handler中，流控制标签减少了在JSP页面中需要的脚本量。

Struts logic:iterate标签从储存在JavaBeans组件中的集合中获取对象并将它们指定给脚本变量。标签的正文从脚本变量中提取信息。如果集合中仍有元素，则iterate标签会再次对正文进行判断。

JSP页面

两个Duke's Bookstore应用程序页面catalog.jsp和showcart.jsp使用了logic:iterate标签以迭代对象的集合。下面展示了catalog.jsp的一部分。JSP页面用bookDB bean集合(由property属性命名)初始化iterate标签。iterate标签在对集合上的每一次迭代中设置book脚本变量。book变量的bookId属性作为另一个脚本变量公开。两个变量的属性都用于动态生成一个包含到其他页面的图书目录信息的链接的表。

<logic:iterate name="bookDB" property="books"
  id="book" type="database.BookDetails">
  <bean:define id="bookId" name="book" property="bookId"
    type="java.lang.String"/>

    <tr>
  <td bgcolor="#ffffaa">
  <a href="<%=request.getContextPath()%>
    /bookdetails?bookId=<%=bookId%>">
    <strong><jsp:getProperty name="book"
    property="title"/>&nbsp;</strong></a></td>

    <td bgcolor="#ffffaa" rowspan=2>
  <jsp:setProperty name="currency" property="amount"
    value="<%=book.getPrice()%>"/>
  <jsp:getProperty name="currency" property="format"/>
  &nbsp;</td>     <td bgcolor="#ffffaa" rowspan=2>
  <a href="<%=request.getContextPath()%>
    /catalog?Add=<%=bookId%>">
    &nbsp;<%=messages.getString("CartAdd")%>
    &nbsp;</a></td></tr>

    <tr>
  <td bgcolor="#ffffff">
  &nbsp;&nbsp;<%=messages.getString("By")%> <em>
    <jsp:getProperty name="book"
      property="firstName"/>&nbsp;
    <jsp:getProperty name="book"
      property="surname"/> </em> </td> </tr>
</logic:iterate>

标签handler

Struts logic:iterate标签的实现符合JSP版本1.1规范的要求，它需要扩展BodyTagSupport类。JSP版本1.2规范添加了简化迭代性地对正文判断的编程标签的功能(在不与正文交互的标签handler中描述)。下面的讨论是使用这些功能的实现。

logic:iterate标签以几种方式支持集合初始化：用作为标签属性而提供的集合，或者用作为bean或者bean属性集合而提供的集合。我们的例子使用后一种方法。doStartTag中的大多数代码是关于构建对于一个对象集合的迭代器的。方法首先检查是否设置了handler的集合属性，如果没有，则进一步检查bean和property属性。如果name和property属性都设置了，则doStartTag调用使用JavaBean自省方法的工具方法来获取集合。一旦确定了集合对象，方法就构建迭代器。

如果迭代器中还有元素，那么doStartTag就设置脚本变量的值为下一个元素，然后表明要对这个正文进行判断，否则就返回SKIP_BODY结束迭代。

在判断完正文后，doAfterBody方法提取正文内容并将它写入输出流。然后清除正文内容对象以便为另一次正文判断作准备。如果迭代器还包含元素，那么doAfterBody就再次设置脚本变量的值为下一个元素并返回EVAL_BODY_AGAIN以表明应该再次对正文进行判断。这样会再次执行doAfterBody。如果没有剩余元素了，那么就返回SKIP_BODY终止这个过程。

public class IterateTag extends TagSupport {
  protected Iterator iterator = null;
  protected Object collection = null;
  protected String id = null;
  protected String name = null;
  protected String property = null;
  protected String type = null;
  public int doStartTag() throws JspException {
    Object collection = this.collection;
    if (collection == null) {
      try {
        Object bean = pageContext.findAttribute(name);
        if (bean == null) {
          ... throw an exception
        }
        if (property == null)
          collection = bean;
        else
          collection =
            PropertyUtils.
              getProperty(bean, property);
        if (collection == null) {
          ... throw an exception
        }
      } catch
        ... catch exceptions thrown
          by PropertyUtils.getProperty
      }
    }
    // Construct an iterator for this collection
    if (collection instanceof Collection)
      iterator = ((Collection) collection).iterator();
    else if (collection instanceof Iterator)
    iterator = (Iterator) collection;
    ...
    }
    // Store the first value and evaluate,
    // or skip the body if none
    if (iterator.hasNext()) {
      Object element = iterator.next();
      pageContext.setAttribute(id, element);
      return (EVAL_BODY_AGAIN);
    } else
      return (SKIP_BODY);   
}
  public int doAfterBody() throws JspException {  
   if (bodyContent != null) {
      try {
        JspWriter out = getPreviousOut();
        out.print(bodyContent.getString());
        bodyContent.clearBody();
      } catch (IOException e) {
        ...
      }
    }
    if (iterator.hasNext()) {
      Object element = iterator.next();
      pageContext.setAttribute(id, element);
      return (EVAL_BODY_AGAIN);
    } else
      return (SKIP_BODY);
    }
  }
}

标签额外信息类

有关脚本变量的信息是在IterateTei标签额外信息类中提供的。脚本变量的名字和类以标签属性的形式传入，并用于加入VariableInfo构造函数。

public class IterateTei extends TagExtraInfo {
  public VariableInfo[] getVariableInfo(TagData data) {
  String type = data.getAttributeString("type");
  if (type == null)
    type = "java.lang.Object";

    return new VariableInfo[] {
    new VariableInfo(data.getAttributeString("id"),
      type,
      true,
      VariableInfo.AT_BEGIN)     };
  }
}

模板标签库

模板提供了一种将应用程序中每一屏幕都会出现的共用元素与每一屏幕都会改变的元素分离开来的方法。将所有公共元素一起放到一个文件中更容易进行维护，并可以加强所有屏幕的外观一致性。它还使每一屏幕的开发更容易了，因为开发者只要注重于该屏幕特定的那部分内容就可以了，模板会负责公共部分。

模板是JSP页面，在每一屏幕需要改变的地方有占位符。每一个占位符称为模板的参数。例如，一个简单的模板可能包含在生成的屏幕顶部的一个标题参数和JSP页面的正文参数以设定屏幕的定制内容。

模板使用嵌入的标签——definition、screen和parameter——定义屏幕定义表并使用标签将屏幕定义插入到特定应用程序屏幕。

JSP页面

下面展示Duke's Bookstore例子的模板template.jsp。这一页面包括一个创建屏幕定义、并用insert标签将定义中的参数插入应用程序屏幕的JSP页面。

<%@ taglib uri="/tutorial-template.tld" prefix="tt" %>
<%@ page errorPage="errorpage.jsp" %>
<%@ include file="screendefinitions.jsp" %><html>
  <head>
    <title>
      <tt:insert definition="bookstore"
        parameter="title"/>
    </title>   </head>
    <tt:insert definition="bookstore"
      parameter="banner"/>
    <tt:insert definition="bookstore"
      parameter="body"/>
  </body>
</html>

screendefinitions.jsp根据请求属性selectedScreen创建屏幕定义：

<tt:definition name="bookstore"
  screen="<%= (String)request.
    getAttribute(\"selectedScreen\") %>">
  <tt:screen id="/enter">
    <tt:parameter name="title"
      value="Duke's Bookstore" direct="true"/>
    <tt:parameter name="banner"
      value="/banner.jsp" direct="false"/>
    <tt:parameter name="body"
      value="/bookstore.jsp" direct="false"/>
  </tt:screen>
  <tt:screen id="/catalog">
    <tt:parameter name="title"
    value="<%=messages.getString("TitleBookCatalog")%>"
    direct="true"/>
    ...
</tt:definition>

模板由Dispatcher servlet实例化。Dispatcher首先得到所请求的屏幕并将它储存为请求的属性。这是必要的，因为在向template.jsp转发请求时，请求URL不包含原来的请求(如/bookstore3/catalog)，而是反映转发布页面的路径(/bookstore3/template.jsp)。最后，servlet将请求分发给template.jsp：

public class Dispatcher extends HttpServlet {
  public void doGet(HttpServletRequest request,
      HttpServletResponse response) {
    request.setAttribute("selectedScreen",
      request.getServletPath());
    RequestDispatcher dispatcher =
      request.getRequestDispatcher("/template.jsp");
    if (dispatcher != null)
      dispatcher.forward(request, response);
  }   public void doPost(HttpServletRequest request,
        HttpServletResponse response) {
    request.setAttribute("selectedScreen",
      request.getServletPath());
    RequestDispatcher dispatcher =
      request.getRequestDispatcher("/template.jsp");
    if (dispatcher != null)
      dispatcher.forward(request, response);
  }
}

标签handler

模板标签库包含四个标签handler——DefinitionTag、ScreenTag、ParameterTag和InsertTag，它们展示了协同操作标签的使用。DefinitionTag、ScreenTag和ParameterTag组成了一组嵌入的标签handler，它们共享公共（public）和私有（private）对象。DefinitionTag创建由InsertTag使用的名为definition的公共对象，

在doStartTag中，DefinitionTag创建一个名为screens的公共对象，它包含屏幕定义的一个哈希表。屏幕定义包含屏幕标识符和一组与该屏幕相关联的参数。

public int doStartTag() {
  HashMap screens = null;
  screens = (HashMap) pageContext.getAttribute("screens",
    pageContext.APPLICATION_SCOPE);
  if (screens == null)
    pageContext.setAttribute("screens", new HashMap(),
      pageContext.APPLICATION_SCOPE);
  return EVAL_BODY_INCLUDE; }

ScreenTag和ParameterTag用作为这些标签属性提供的文字填充屏幕定义表。表16-6显示了Duke's Bookstore应用程序的屏幕定义哈希表的内容。

.

在doEndTag中，DefinitionTag创建Definition类的一个公共对象，根据在请求中传递的URL从screens对象中选择一个屏幕定义，并用它初始化Definition对象。

public int doEndTag()throws JspTagException {
  try {
    Definition definition = new Definition();
    HashMap screens = null;
    ArrayList params = null;
    TagSupport screen = null;
    screens = (HashMap)
      pageContext.getAttribute("screens",
        pageContext.APPLICATION_SCOPE);
    if (screens != null)
      params = (ArrayList) screens.get(screenId);
    else
      ...
    if (params == null)
      ...
    Iterator ir = null;
    if (params != null)
      ir = params.iterator();
    while ((ir != null) && ir.hasNext())
      definition.setParam((Parameter) ir.next());
      // put the definition in the page context
    pageContext.setAttribute(
      definitionName, definition);
  } catch (Exception ex) {
    ex.printStackTrace();
  }   return EVAL_PAGE;
}

如果在请求中传递的URL是/enter，那么Definition包含表16-6中第一行的项目：

URL /enter的定义如表16-7所示。这个定义指定Title参数的值Duke's Bookstore应该直接插队入到输出流中，但是Banner和Body的值应该动态地加入。

InsertTag使用Definition将屏幕定义的参数插入响应中。在doStartTag方法中，它从页面上下文中获取定义对象。

public int doStartTag() {
  // get the definition from the page context
  definition = (Definition) pageContext.
    getAttribute(definitionName);
  // get the parameter
  if (parameterName != null && definition != null)
    parameter = (Parameter)definition.
      getParam(parameterName);
  if (parameter != null)
    directInclude = parameter.isDirect();
  return SKIP_BODY;
}

doEndTag方法插入参数值。如果参数是直接的，那么就直接将它插入响应中，否则，请求就被发送给参数，而其响应则被动态地包含进整个响应中。

public int doEndTag()throws JspTagException {
  try {
    if (directInclude && parameter != null)
      pageContext.getOut().print(parameter.getValue());
    else {
      if ((parameter != null) &&
        (parameter.getValue() != null))
        pageContext.include(parameter.getValue());
    }
  } catch (Exception ex) {
    throw new JspTagException(ex.getMessage());
  }
  return EVAL_PAGE;
}

如何调用标签handler？

Tag接口定义了标签handler与JSP页面的servlet之间的基本协议。它定义了生命周期以及在遇到开始和结束标签时要调用的方法。

JSP页面的servlet在调用doStartTag之前调用setPageContext、setParent和属性设置方法。JSP页面的servlet还保证在结束页面之前调用标签handler的release。

下面是典型的标签handler方法调用顺序：

A Tag t = new ATag();
t.setPageContext(...);
t.setParent(...);
t.setAttribute1(value1);
t.setAttribute2(value2);
t.doStartTag();
t.doEndTag();
t.release();

BodyTag接口通过定义让标签handler访问其正文的其他方法扩展Tag。这个接口提供三个新方法：

·  setBodyContent—创建正文内容并添加给tag handler

·  doInitBody—在评估标签正文之前调用

·  doAfterBody—在评估标签正文之后调用

典型的调用顺序为：

t.doStartTag();
out = pageContext.pushBody();
t.setBodyContent(out);
// perform any initialization needed after body content is set t.doInitBody();
t.doAfterBody();
// while doAfterBody returns EVAL_BODY_BUFFERED we
// iterate body evaluation
...
t.doAfterBody();
t.doEndTag();
t.pageContext.popBody();
t.release();

Mark A. Kolb
软件工程师
2003 年 6 月 21 日

顾名思义，JSP 标准标记库（JSP Standard Tag Library，JSTL） core 库为一些基本功能（如，管理限定了作用域的变量和与 URL 交互等）和基本操作（如，迭代和条件化）提供了定制标记。这些标记不仅可以由页面设计人员直接利用，而且还为与其它 JSTL 库相结合从而提供更复杂的表示逻辑奠定了基础。Mark Kolb 在本文中继续对 JSTL 和 core 库进行探讨，研究用标记来协助流控制和 URL 管理。

通过阅读本系列的 第一篇文章，您对 JSTL 有了初步的了解。我们描述了使用其 表达式语言（EL）来访问数据和操作数据。正如您所了解的那样，EL 用来为 JSTL 定制标记的属性赋予动态值，因此，它所起的作用与 JSP 表达式一样，为内置操作及其它定制标记库指定请求时的属性值。

为了演示 EL 的用法，我们介绍了 core 库中的三个标记： <c:set> 、 <c:remove> 和 <c:out> 。 <c:set> 和 <c:remove> 用于管理限定了作用域的变量；而 <c:out> 用于显示数据，尤其是显示用 EL 计算出的值。在此基础上，接下来本文把注意力集中在 core 库的其余标记上，这些标记可以大致归为两大类别：流控制和 URL 管理。

示例应用程序
为了演示 JSTL 标记，我们将使用来自一个工作应用程序的示例，本系列中余下的文章都将使用此应用程序。由于基于 Java 的 Weblog 日渐流行及为人们所熟悉，因此我们将出于此目的使用一个简单的基于 Java 的 Weblog；参阅 参考资料以下载该应用程序的 JSP 页面和源代码。Weblog（也称为 blog）是一种基于 Web 的简短注释的日志，这些注释是有关 Weblog 的作者所感兴趣的主题，通常带有与 Web 上其它地方的相关文章及讨论的链接。图 1 中显示了该应用程序正在运行时的抓屏。

图 1. Weblog 应用程序

虽然完整的实现需要二十四个 Java 类，但在表示层中却只涉及 Weblog 应用程序中的两个类， Entry 和 UserBean 。这样，对于理解 JSTL 示例而言，只有这两个类比较重要。图 2 显示了 Entry 和 UserBean 的类图。

图 2. Weblog 应用程序的类图

Entry 类表示 Weblog 中一个标有日期的项。其 id 属性用于在数据库中存储及检索该项，而 title 和 text 属性则表示该项的实际内容。 created 和 lastModified 属性引用了 Java 语言中 Date 类的两个实例，分别用来表示最初创建该项的时间和最后编辑该项的时间。 author 属性引用了标识该项的创建者的 UserBean 实例。

UserBean 类存储了有关应用程序的已认证用户的信息，如用户名、全名和电子邮件地址。该类还包含一个用于与相关数据库进行交互的 id 属性。其最后一个属性 roles 引用一列 String 值，这列值标识与相应用户相关的、特定于应用程序的角色。对于 Weblog 应用程序，相关的角色是“User”（所有应用程序用户常用的缺省角色）和“Author”（该角色指定可以创建和编辑 Weblog 项的用户）。

流控制
由于可以用 EL 替代 JSP 表达式来指定动态属性值，因此页面创作人员无需使用脚本编制元素。因为脚本编制元素可能是引起 JSP 页面中维护问题的主要原因，所以 JSTL 的主要优点就在于提供了这样简单（且标准）的替代方法。

EL 从 JSP 容器检索数据，遍历对象层次结构，然后对结果执行简单的操作。不过，除了访问和操作数据之外，JSP 脚本编制元素的另一个常见用法是流控制。尤其是，页面创作人员常借助 scriptlet 来实现迭代或条件内容。然而，因为这样的操作超出了 EL 的能力，所以 core 库提供了几个定制操作来管理流控制，其形式有 迭代、 条件化和 异常处理。

迭代
在 Web 应用程序环境中，迭代主要用于访存和显示数据集，通常是以列表或表中的一系列行的形式显示。实现迭代内容的主要 JSTL 操作是 <c:forEach> 定制标记。该标记支持两种不同样式的迭代：整数范围上的迭代（类似 Java 语言的 for 语句）和集合上的迭代（类似 Java 语言的 Iterator 和 Enumeration 类）。

进行整数范围迭代用到了清单 1 中所示的 <c:forEach> 标记的语法。 begin 和 end 属性要么是静态整数值，要么是可以得出整数值的表达式。它们分别指定迭代索引的初始值以及迭代索引的终止值。当使用 <c:forEach> 在整数范围内进行迭代时，这两个属性是必需的，而其它所有属性都是可选的。

<c:forEach var="
        name" varStatus="
        name"
    begin="
        expression" end="
        expression" step="
        expression">
  
        body content
</c:forEach>

      

当出现 step 时，它也必须是整数值。它指定每次迭代后索引的增量。这样，迭代索引从 begin 属性的值开始，以 step 属性的值为增量进行递增，在迭代索引超过 end 属性的值时停止迭代。注：如果省略了 step 属性，那么步长缺省为 1。

如果指定了 var 属性，那么将会创建一个带有指定名称的并限定了作用域的变量，并将每次迭代的当前索引值赋给该变量。这一限定了作用域的变量具有嵌套式可视性 ― 只可以在 <c:forEach> 标记体内对其进行访问。（我们很快将讨论可选属性 varStatus 的用法。）清单 2 显示了对一组固定整数值进行迭代的 <c:forEach> 操作示例。

<table>
<tr><th>Value</th>
    <th>Square</th></tr>
<c:forEach var="x" begin="0" end="10" step="2">
  <tr><td><c:out value="${x}"/></td>
      <td><c:out value="${x * x}"/></td></tr>
</c:forEach>
</table>

如图 3 中所示，上面的示例代码生成了一张表，显示前五个偶数及其平方。这是通过将 begin 和 step 属性值指定为 2，而将 end 属性值指定为 10 实现的。此外，用 var 属性创建用于存储索引值的限定了作用域的变量， <c:forEach> 标记体内引用了该变量。尤其是，使用了一对 <c:out> 操作来显示索引及其平方，其中索引的平方是使用一个简单的表达式计算得来的。

图 3. 清单 2 的输出

在对集合的成员进行迭代时，用到了 <c:forEach> 标记的另一个属性： items 属性，清单 3 中显示了该属性。当使用这种形式的 <c:forEach> 标记时， items 属性是唯一必需的属性。 items 属性的值应该是一个集合，对该集合的成员进行迭代，通常使用 EL 表达式指定值。如果变量名称是通过 <c:forEach> 标记的 item 属性指定的，那么对于每次迭代该已命名变量都将被绑定到集合后续元素上。

<c:forEach var="
        name" items="
        expression" varStatus="
        name"
    begin="
        expression" end="
        expression" step="
        expression">
  
        body content
</c:forEach>

      

<c:forEach> 标记支持 Java 平台所提供的所有标准集合类型。此外，您可以使用该操作来迭代数组（包括基本类型数组）中的元素。表 1 列出了 items 属性所支持的所有值。正如表的最后一行所指出的那样，JSTL 定义了它自己的接口 javax.servlet.jsp.jstl.sql.Result ，用来迭代 SQL 查询的结果。（我们将在本系列后面的文章中详细讨论这一功能。）

表 1. <c:forEach> 标记的 items 属性所支持的集合

items 的值	所产生的 item 值
java.util.Collection	调用 iterator() 所获得的元素
java.util.Map	java.util.Map.Entry 的实例
java.util.Iterator	迭代器元素
java.util.Enumeration	枚举元素
Object 实例数组	数组元素
基本类型值数组	经过包装的数组元素
用逗号定界的 String	子字符串
javax.servlet.jsp.jstl.sql.Result	SQL 查询所获得的行

可以使用 begin 、 end 和 step 属性来限定在迭代中包含集合中哪些元素。和通过 <c:forEach> 进行数字迭代的情形一样，在迭代集合中的元素时同样要维护一个迭代索引。 <c:forEach> 标记实际上只处理那些与索引值相对应的元素，这些索引值与指定的 begin 、 end 和 step 值相匹配。

清单 4 显示了用来迭代集合的 <c:forEach> 标记。对于该 JSP 代码段， entryList 这一限定了作用域的变量被设置成了 Entry 对象列表（确切的说， ArrayList ）。 <c:forEach> 标记依次处理列表中的每个元素，将其赋给一个限定了作用域的变量 blogEntry ，然后生成两个表行 ― 一个用于 Weblog 项的 title ，另一个则用于该项 text 。这些特性是通过一对带有相应 EL 表达式的 <c:out> 操作从 blogEntry 变量检索得到的。注：由于 Weblog 项的标题和文本都可能包含 HTML 标记，因此这两个 <c:out> 标记的 escapeXml 属性都被设置成了 false。图 4 显示了结果。

<table>
  <c:forEach items="${entryList}" var="blogEntry">
    <tr><td align="left" class="blogTitle">
      <c:out value="${blogEntry.title}" escapeXml="false"/>
    </td></tr>
    <tr><td align="left" class="blogText">
      <c:out value="${blogEntry.text}" escapeXml="false"/>
    </td></tr>
  </c:forEach>
</table>

图 4. 清单 4 的输出

不论是对整数还是对集合进行迭代， <c:forEach> 剩余的属性 varStatus 所起的作用相同。和 var 属性一样， varStatus 用于创建限定了作用域的变量。不过，由 varStatus 属性命名的变量并不存储当前索引值或当前元素，而是赋予 javax.servlet.jsp.jstl.core.LoopTagStatus 类的实例。该类定义了一组特性，它们描述了迭代的当前状态，表 2 中列出了这些特性。

表 2. LoopTagStatus 对象的特性

特性	Getter	描述
current	getCurrent()	当前这次迭代的（集合中的）项
index	getIndex()	当前这次迭代从 0 开始的迭代索引
count	getCount()	当前这次迭代从 1 开始的迭代计数
first	isFirst()	用来表明当前这轮迭代是否为第一次迭代的标志
last	isLast()	用来表明当前这轮迭代是否为最后一次迭代的标志
begin	getBegin()	begin 属性值
end	getEnd()	end 属性值
step	getStep()	step 属性值

清单 5 显示了关于如何使用 varStatus 属性的一个示例。这个示例修改了清单 4 中的代码，将 Weblog 项的编号添加到显示 Weblog 标题（title）的表行。它是通过为 varStatus 属性指定一个值，然后访问所生成的限定了作用域的变量的 count 特性来实现这一点的。结果显示在图 5 中。

<table>
  <c:forEach items=
    "${entryList}" var="blogEntry" varStatus="status">
    <tr><td align="left" class="blogTitle">
      <c:out value="${status.count}"/>.
      <c:out value="${blogEntry.title}" escapeXml="false"/>
    </td></tr>
    <tr><td align="left" class="blogText">
      <c:out value="${blogEntry.text}" escapeXml="false"/>
    </td></tr>
  </c:forEach>
</table>

图 5. 清单 5 的输出

除 <c:forEach> 以外， core 库还提供了另一个迭代标记： <c:forTokens> 。JSTL 的这个定制操作与 Java 语言的 StringTokenizer 类的作用相似。清单 6 中显示的 <c:forTokens> 标记除了比 <c:forEach> 的面向集合版本多一个属性之外，其它属性都相同。对于 <c:forTokens> 而言，通过 items 属性指定要标记化的字符串，而通过 delims 属性提供用于生成标记的一组定界符。和 <c:forEach> 的情形一样，可以使用 begin 、 end 和 step 属性将要处理的标记限定为那些与相应索引值相匹配的标记。

<c:forTokens var="
        name" items="
        expression"
    delims="
        expression" varStatus="
        name"
    begin="
        expression" end="
        expression" step="
        expression">
  
        body content
</c:forTokens>

      

条件化
对于包含动态内容的 Web 页面，您可能希望不同类别的用户看到不同形式的内容。例如，在我们的 Weblog 中，访问者应该能够阅读各项，也许还应该能够提交反馈，但只有经过授权的用户才能公布新项，或编辑已有内容。

在同一个 JSP 页面内实现这样的功能，然后使用条件逻辑来根据每条请求控制所显示的内容，这样做常常能够改善实用性和软件维护。 core 库提供了两个不同的条件化标记 ― <c:if> 和 <c:choose> ― 来实现这些功能。

<c:if> 是这两个操作中较简单的一个，它简单地对单个测试表达式进行求值，接下来，仅当对表达式求出的值为 true 时，它才处理标记的主体内容。如果求出的值不为 true ，就忽略该标记的主体内容。如清单 7 所示， <c:if> 可以通过其 var 和 scope 属性（它们所起的作用和在 <c:set> 中所起的作用一样）选择将测试结果赋给限定了作用域的变量。当测试代价非常高昂时，这种能力尤为有用：可以将结果高速缓存在限定了作用域的变量中，然后在随后对 <c:if> 或其它 JSTL 标记的调用中检索该结果。

<c:if test="
        expression" var="
        name" scope="
        scope">
  
        body content
</c:if>

      

清单 8 显示了与 <c:forEach> 标记的 LoopTagStatus 对象的 first 特性一起使用的 <c:if> 。如图 6 中所示，在这种情况下，只在 Weblog 项的第一项上显示这组项的创建日期，而不在任何其它项前面重复该日期。

<table>
  <c:forEach items=
    "${entryList}" var="blogEntry" varStatus="status">
    <c:if test="${status.first}">
      <tr><td align="left" class="blogDate">
            <c:out value="${blogEntry.created}"/>
      </td></tr>
    </c:if>
    <tr><td align="left" class="blogTitle">
      <c:out value="${blogEntry.title}" escapeXml="false"/>
    </td></tr>
    <tr><td align="left" class="blogText">
      <c:out value="${blogEntry.text}" escapeXml="false"/>
    </td></tr>
  </c:forEach>
</table>

图 6. 清单 8 的输出

如清单 8 所示， <c:if> 标记为条件化内容的一些简单情形提供了一种非常简洁的表示法。对于需要进行互斥测试来确定应该显示什么内容的情况下，JSTL core 库还提供了 <c:choose> 操作。清单 9 中显示了 <c:choose> 的语法。

<c:choose>
  <c:when test="
        expression">
    
        body content
  </c:when>
  ...
  <c:otherwise>
    
        body content
  </c:otherwise>
</c:choose>

      

每个要测试的条件都由相应的 <c:when> 标记来表示，至少要有一个 <c:when> 标记。只会处理第一个其 test 值为 true 的 <c:when> 标记体内的内容。如果没有一个 <c:when> 测试返回 true ，那么会处理 <c:otherwise> 标记的主体内容。注：尽管如此， <c:otherwise> 标记却是可选的； <c:choose> 标记至多可有一个嵌套的 <c:otherwise> 标记。如果所有 <c:when> 测试都为 false ，而且又没有给出 <c:otherwise> 操作，那么不会处理任何 <c:choose> 标记的主体内容。

清单 10 显示了运用 <c:choose> 标记的示例。在这里，检索请求对象而获得协议信息（通过 EL 的 pageContext 隐式对象），并用简单的字符串比较对协议信息进行测试。根据这些测试的结果，会显示相应的文本消息。

<c:choose>
  <c:when test="${pageContext.request.scheme eq 'http'}">
    This is an insecure Web session.
  </c:when>
  <c:when test="${pageContext.request.scheme eq 'https'}">
    This is a secure Web session.
  </c:when>
  <c:otherwise>
    You are using an unrecognized Web protocol. How did this happen?!
  </c:otherwise>
</c:choose>

异常处理
最后一个流控制标记是 <c:catch> ，它允许在 JSP 页面内进行初级的异常处理。更确切地说，在该标记的主体内容中产生的任何异常都会被捕获并被忽略（即，不会调用标准的 JSP 错误处理机制）。然而，如果产生了一个异常并且已经指定了 <c:catch> 标记的可选属性 var ，那么会将异常赋给（具有页面作用域的）指定的变量，这使得能够在页面自身内部进行定制错误处理。清单 11 显示了 <c:catch> 的语法（稍后在 清单 18中给出一个示例）。

<c:catch var="
        name">
  
        body content
</c:catch>

      

URL 操作
JSTL core 库中的其余标记主要是关于 URL。这些标记中的第一个被适当地命名为 <c:url> 标记，用于生成 URL。尤其是， <c:url> 提供了三个功能元素，它们在为 J2EE Web 应用程序构造 URL 时特别有用：

• 在前面附加当前 servlet 上下文的名称
• 为会话管理重写 URL
• 请求参数名称和值的 URL 编码

清单 12 显示了 <c:url> 标记的语法。 value 属性用来指定基本 URL，然后在必要时标记对其进行转换。如果这个基本 URL 以一个斜杠开始，那么会在它前面加上 servlet 的上下文名称。可以使用 context 属性提供显式的上下文名称。如果省略该属性，那么就使用当前 servlet 上下文的名称。这一点特别有用，因为 servlet 上下文名称是在部署期间而不是开发期间决定的。（如果这个基本 URL 不是以斜杠开始的，那么就认为它是一个相对 URL，这时就不必添加上下文名称。）

<c:url value="
        expression" context="
        expression"
    var="
        name" scope="
        scope">
  <c:param name="
        expression" value="
        expression"/>
  ...
</c:url>

      

URL 重写是由 <c:url> 操作自动执行的。如果 JSP 容器检测到一个存储用户当前会话标识的 cookie，那么就不必进行重写。但是，如果不存在这样的 cookie，那么 <c:url> 生成的所有 URL 都会被重写以编码会话标识。注：如果在随后的请求中存在适当的 cookie，那么 <c:url> 将停止重写 URL 以包含该标识。

如果为 var 属性提供了一个值（还可以同时为 scope 属性提供一个相应的值，这是可选的），那么将生成的 URL 赋值给这个限定了作用域的指定变量。否则，将使用当前的 JspWriter 输出生成的 URL。这种直接输出其结果的能力允许 <c:url> 标记作为值出现，例如，作为 HTML <a> 标记的 href 属性的值，如清单 13 中所示。

<a href="<c:url value='/content/sitemap.jsp'/>">View sitemap</a>

最后，如果通过嵌套 <c:param> 标记指定了任何请求参数，那么将会使用 HTTP GET 请求的标准表示法将它们的名称和值添加到生成的 URL 后面。此外，还进行 URL 编码：为了生成有效的 URL，将对这些参数的名称或值中出现的任何字符适当地进行转换。清单 14 演示了 <c:url> 的这种行为。

<c:url value="/content/search.jsp">
  <c:param name="keyword" value="${searchTerm}"/>
  <c:param name="month" value="02/2003"/>
</c:url>

清单 14 中的 JSP 代码被部署到一个名为 blog 的 servlet 上下文，限定了作用域的变量 searchTerm 的值被设置为 "core library" 。如果检测到了会话 cookie，那么清单 14 生成的 URL 将类似于清单 15 中的 URL。注：在前面添加上下文名称，而在后面附加请求参数。此外， keyword 参数值中的空格和 month 参数值中的斜杠都被按照 HTTP GET 参数的需要进行了编码（确切地说，空格被转换成了 + ，而斜杠被转换成了 %2F 序列）。

/blog/content/search.jsp?keyword=foo+bar&month=02%2F2003

当没有会话 cookie 时，生成的结果如清单 16 中所示。同样，servlet 上下文被添加到了前面，而 URL 编码的请求参数被附加到了后面。不过，除此以外还重写了基本 URL 以包含指定的会话标识。当浏览器发送用这种方式重写的 URL 请求时，JSP 容器自动抽取会话标识，并将请求与相应的会话进行关联。这样，需要会话管理的 J2EE 应用程序就无需依赖由应用程序用户启用的 cookie 了。

/blog/content/search.jsp;jsessionid=233379C7CD2D0ED2E9F3963906DB4290
  ?keyword=foo+bar&month=02%2F2003

导入内容
JSP 有两种内置机制可以将来自不同 URL 的内容合并到一个 JSP 页面： include 伪指令和 <jsp:include> 操作。不过，不管是哪种机制，要包含的内容都必须属于与页面本身相同的 Web 应用程序（或 servlet 上下文）。两个标记之间的主要区别在于： include 伪指令在页面编译期间合并被包含的内容，而 <jsp:include> 操作却在请求处理 JSP 页面时进行。

从本质上讲， core 库的 <c:import> 操作是更通用、功能更强大的 <jsp:include> 版本（好像是 <jsp:include> “服用了兴奋剂”的）。和 <jsp:include> 一样， <c:import> 也是一种请求时操作，它的基本任务就是将其它一些 Web 资源的内容插入 JSP 页面中。如清单 17 中所示，它的语法非常类似于 <c:url> 的语法。

<c:import url="
        expression" context="
        expression"
    charEncoding="
        expression" var="
        name" scope="
        scope">
  <c:param name="
        expression" value="
        expression"/>
  ...
</c:import>

      

通过 url 属性指定将要导入内容的 URL，这个属性是 <c:import> 的唯一一个必选属性。这里允许使用相对 URL，并且根据当前页面的 URL 来解析这个相对 URL。但是，如果 url 属性的值以斜杠开始，那么它就被解释成本地 JSP 容器内的绝对 URL。如果没有为 context 属性指定值，那么就认为这样的绝对 URL 引用当前 servlet 上下文内的资源。如果通过 context 属性显式地指定了上下文，那么就根据指定的 servlet 上下文解析绝对（本地）URL。

但 <c:import> 操作并不仅仅限于访问本地内容。也可以将包含协议和主机名的完整 URI 指定为 url 属性的值。实际上，协议甚至不仅局限于 HTTP。 <c:import> 的 url 属性值可以使用 java.net.URL 类所支持的任何协议。清单 18 中显示了这种能力。

其中， <c:import> 操作用来包含通过 FTP 协议访问的文档内容。此外，还使用了 <c:catch> 操作，以便在本地处理 FTP 文件传送期间可能发生的任何错误。错误处理是这样实现的：使用 <c:catch> 的 var 属性为异常指定一个限定了作用域的变量，然后使用 <c:if> 检查其值。如果产生了异常，那么就会对那个限定了作用域的变量进行赋值：如清单 18 中的 EL 表达式所显示的那样，该变量的值将 不会为空。由于 FTP 文档的检索将会失败，因此会显示有关这种情况的错误消息。

<c:catch var="exception">
  <c:import url="ftp://ftp.example.com/package/README"/>
</c:catch>
<c:if test="${not empty exception}">
  Sorry, the remote content is not currently available.
</c:if>

<c:import> 操作的最后两个（可选的）属性是 var 和 scope 。 var 属性会导致从指定 URL 获取的内容（作为 String 值）被存储在一个限定了作用域的变量中，而不是包含在当前 JSP 页面中。 scope 属性控制该变量的作用域，缺省情况下是页面作用域。如同我们在今后的文章中将要看到的那样，JSTL xml 库中的标记利用了 <c:import> 这种能力，即将整个文档存储在一个限定了作用域的变量中。

还要注意的是，可以使用（可选的）嵌套的 <c:param> 标记来为正在导入的 URL 指定请求参数。与在 <c:url> 中嵌套 <c:param> 标记一样，必要时也要对参数名称和参数值进行 URL 编码。

请求重定向
最后一个 core 库标记是 <c:redirect> 。该操作用于向用户的浏览器发送 HTTP 重定向响应，它是 JSTL 中与 javax.servlet.http.HttpServletResponse 的 sendRedirect() 方法功能相当的标记。清单 19 中显示了该标记的 url 和 context 属性，它们的行为分别等同于 <c:import> 的 url 和 context 属性的行为，是嵌套任何 <c:param> 标记的结果。

<c:redirect url="
        expression" context="
        expression">
  <c:param name="
        expression" value="
        expression"/>
  ...
</c:redirect>

      

清单 20 显示了 <c:redirect> 操作，它用一个到指定错误页面的重定向代替了清单 18 中的错误消息。在该示例中， <c:redirect> 标记的用法与标准 <jsp:forward> 操作的用法类似。不过请回忆一下：通过请求分派器进行转发是在服务器端实现的，而重定向却是由浏览器来执行的。从开发人员的角度来讲，转发比重定向更有效率，但 <c:redirect> 操作却更灵活一些，因为 <jsp:forward> 只能分派到当前 servlet 上下文内的其它 JSP 页面。

<c:catch var="exception">
  <c:import url="ftp://ftp.example.com/package/README"/>
</c:catch>
<c:if test="${not empty exception}">
  <c:redirect url="/errors/remote.jsp"/>
</c:if>

从用户的角度来看，主要区别在于重定向会更新浏览器所显示的 URL，并因此影响书签的设置。转发却不这样，它对最终用户是透明的。这样，选择 <c:redirect> 还是 <jsp:forward> 还取决于所期望的用户体验。

结束语
JSTL core 库含有多种通用的定制标记，广大的 JSP 开发人员都会使用这些标记。例如，URL 和异常处理标记很好地补充了现有的 JSP 功能，如 <jsp:include> 和 <jsp:forward> 操作、 include 伪指令以及 page 伪指令的 errorpage 属性。迭代和条件操作使得无需脚本编制元素就能够实现复杂的表示逻辑，尤其在将变量标记（ <c:set> 和 <c:remove> ）与 EL 相结合使用时更是如此。

参考资料

• 您可以参阅本文在 developerWorks 全球站点上的 英文原文.
  
  
• 本系列的第一篇文章 JSTL 入门：表达式语言（ developerWorks，2003 年 2 月）介绍了 JSTL，并详细讨论了表达式语言及 core 库中的几个标记。
  
  
• 下载 Weblog 示例应用程序的 源代码。
  
  
• Sun 的 JSP 标准标记库产品页面是深入了解 JSTL 的不错的起点。
  
  
• JSTL 1.0 规范是 EL 和四个 JSTL 标记库的最权威的参考资料。
  
  
• Jakarta Taglibs项目是 JSTL 1.0 参考实现的主页。
  
  
• Shawn Bayern 撰写的 JSTL in Action （Manning，2002 年）出色地讨论了由参考实现领导编写的全部 JSTL 功能。
  
  
• David Geary 是一位很受欢迎的 Java 编程方面的作者，他还著有一部关于 JSTL 的书籍，名为 Core JSTL 。
  
  
• JSPTags.com是一个 JSP 参考资料目录，它尤其着重于定制标记库方面的内容。
  
  
• Sun 的 Java Web Services Tutorial的一部分也涉及到了对 JSTL 的讨论。
  
  
• 通过学习“ Using JSPs and custom tags within VisualAge for Java and WebSphere Studio”（ WebSphere 开发者园地），动手实践 WBOnline，这篇文章演示了如何使用 servlet、JSP 页面及定制标记库。
  
  
• 通过 Jeff Wilson 的优秀文章“ 使用定制标记控制 JSP 页面”（ developerWorks，2002 年 1 月）来学习关于定制标记库的全部内容。
  
  
• Noel Bergman 的文章“ JSP 标记库：着意设计的更好的可用性”（ developerWorks，2001 年 12 月）向您显示了声明性标记是如何帮助改善 JSP 页面的可用性。
  
  
• 在 developerWorksJava 技术专区 可以找到数百篇有关 Java 技术的参考资料。
  

import java.io.UnsupportedEncodingException;

/**
 * Classname :
 * ClassType :
 *
 * @version $Revision$
 * @author $author$
 */
public class HelloWorld {
    String sEnglish  = "Apple";
    String sChinese  = "苹果";
    String mixString = "Apple 苹果";

    /**
     * DOCUMENT ME!
     *
     * @param args DOCUMENT ME!
     * @throws UnsupportedEncodingException
     */
    public static void main(String[] args)
                     throws UnsupportedEncodingException {
        System.out.println("Hello, World!");

        HelloWorld hw = new HelloWorld();
        System.out.println("sEnglish String length: " + hw.sEnglish.length());
        System.out.println("sChinese String length: " + hw.sChinese.length());
        System.out.println("mixString String length: " + hw.mixString.length());
        System.out.println("********************************************************************");
        System.out.println("UTF-8 Bytes length: "
                           + hw.sEnglish.getBytes("UTF-8").length);
        System.out.println("UTF-8 Bytes length: "
                           + hw.sChinese.getBytes("UTF-8").length);
        System.out.println("UTF-8 Bytes length: "
                           + hw.mixString.getBytes("UTF-8").length);
        System.out.println("********************************************************************");
        System.out.println("GBK Bytes length: "
                           + hw.sEnglish.getBytes("GBK").length);
        System.out.println("GBK Bytes length: "
                           + hw.sChinese.getBytes("GBK").length);
        System.out.println("GBK Bytes length: "
                           + hw.mixString.getBytes("GBK").length);
        System.out.println("********************************************************************");
        System.out.println("UTF-16 Bytes length: "
                           + hw.sEnglish.getBytes("UTF-16").length);
        System.out.println("UTF-16 Bytes length: "
                           + hw.sChinese.getBytes("UTF-16").length);
        System.out.println("UTF-16 Bytes length: "
                           + hw.mixString.getBytes("UTF-16").length);
        System.out.println("********************************************************************");
        System.out.println("Unicode Bytes length: "
                           + hw.sEnglish.getBytes("Unicode").length);
        System.out.println("Unicode Bytes length: "
                           + hw.sChinese.getBytes("Unicode").length);
        System.out.println("Unicode Bytes length: "
                           + hw.mixString.getBytes("Unicode").length);
        System.out.println("********************************************************************");
        System.out.println("Default Bytes length: "
                           + hw.sEnglish.getBytes().length);
        System.out.println("Default Bytes length: "
                           + hw.sChinese.getBytes().length);
        System.out.println("Default Bytes length: "
                           + hw.mixString.getBytes().length);
    }
}


Result:


Hello, World!
sEnglish String length: 5
sChinese String length: 2
mixString String length: 8
********************************************************************
UTF-8 Bytes length: 5
UTF-8 Bytes length: 6
UTF-8 Bytes length: 12
********************************************************************
GBK Bytes length: 5
GBK Bytes length: 4
GBK Bytes length: 10
********************************************************************
UTF-16 Bytes length: 12
UTF-16 Bytes length: 6
UTF-16 Bytes length: 18
********************************************************************
Unicode Bytes length: 12
Unicode Bytes length: 6
Unicode Bytes length: 18
********************************************************************
Default Bytes length: 5
Default Bytes length: 4
Default Bytes length: 10

为了记忆，把demo的代码抄录：

<html>

<script language=JavaScript>



 

var ModalDialogWindow;

var ModalDialogInterval;

var ModalDialog = new Object;



ModalDialog.value = '';

ModalDialog.eventhandler = '';

 



function ModalDialogMaintainFocus()

{

  try

  {

    if (ModalDialogWindow.closed)

     {

        window.clearInterval(ModalDialogInterval);

        eval(ModalDialog.eventhandler);       

        return;

     }

    ModalDialogWindow.focus(); 

  }

  catch (everything) {   }

}

        

 function ModalDialogRemoveWatch()

 {

    ModalDialog.value = '';

    ModalDialog.eventhandler = '';

 }

        

 function ModalDialogShow(Title,BodyText,Buttons,EventHandler)

 {



   ModalDialogRemoveWatch();

   ModalDialog.eventhandler = EventHandler;



   var args='width=350,height=125,left=325,top=300,toolbar=0,';

       args+='location=0,status=0,menubar=0,scrollbars=1,resizable=0';  



   ModalDialogWindow=window.open("","",args); 

   ModalDialogWindow.document.open(); 

   ModalDialogWindow.document.write('<html>');

   ModalDialogWindow.document.write('<head>'); 

   ModalDialogWindow.document.write('<title>' + Title + '</title>');

   ModalDialogWindow.document.write('<script' + ' language=JavaScript>');

   ModalDialogWindow.document.write('function CloseForm(Response) ');

   ModalDialogWindow.document.write('{ ');

   ModalDialogWindow.document.write(' window.opener.ModalDialog.value = Response; ');

   ModalDialogWindow.document.write(' window.close(); ');

   ModalDialogWindow.document.write('} ');

   ModalDialogWindow.document.write('</script' + '>');        

   ModalDialogWindow.document.write('</head>');   

   ModalDialogWindow.document.write('<body onblur="window.focus();">');

   ModalDialogWindow.document.write('<table border=0 width="95%" align=center cellspacing=0 cellpadding=2>');

   ModalDialogWindow.document.write('<tr><td align=left>' + BodyText + '</td></tr>');

   ModalDialogWindow.document.write('<tr><td align=left><br></td></tr>');

   ModalDialogWindow.document.write('<tr><td align=center>' + Buttons + '</td></tr>');

   ModalDialogWindow.document.write('</body>');

   ModalDialogWindow.document.write('</html>'); 

   ModalDialogWindow.document.close(); 

   ModalDialogWindow.focus(); 

   ModalDialogInterval = window.setInterval("ModalDialogMaintainFocus()",5);



 }





</script>



<script language=JavaScript>





  function YesNoCancel(BodyText,EventHandler)

  {

     var Buttons=''; 

     Buttons = '<a href=javascript:CloseForm("Yes");>Yes</a>  ';

     Buttons += '<a href=javascript:CloseForm("No");>No</a>  ';

     Buttons += '<a href=javascript:CloseForm("Cancel");>Cancel</a>  ';

     ModalDialogShow("Dialog",BodyText,Buttons,EventHandler);

  }



  function YesNoMaybe(BodyText,EventHandler)

  {

     var Buttons=''; 

     Buttons = '<a href=javascript:CloseForm("Yes");>Yes</a>  ';

     Buttons += '<a href=javascript:CloseForm("No");>No</a>  ';

     Buttons += '<a href=javascript:CloseForm("Maybe");>Maybe</a>  ';

     ModalDialogShow("Dialog",BodyText,Buttons,EventHandler);

  }

 

 function YesNoCancelReturnMethod()

 {

   document.getElementById('modalreturn1').value =  ModalDialog.value;

   ModalDialogRemoveWatch();

 }



 function YesNoMaybeReturnMethod()

{

    document.getElementById('modalreturn2').value = ModalDialog.value;

    ModalDialogRemoveWatch();

}





</script>

 

<BODY >



  <table border=1 cellpadding=2 cellspacing=2 align=center width="60%">

    <tr><td align=left></td></tr>

    <tr><td align=left></td></tr>



    <tr><td align=left></td></tr>

    <tr>

	   <td align=left><a href="javascript:YesNoCancel('Yes, no, or cancel me','YesNoCancelReturnMethod()');">Show Modal #1</a>   

          1. <input type=text id=modalreturn1 name=modalreturn1 value=''></td>



  	</tr>

    <tr>

	   <td align=left><a href="javascript:YesNoMaybe('Yes, no, or maybe me','YesNoMaybeReturnMethod()');">Show Modal #2</a>   

         2. <input type=text id=modalreturn2 name=modalreturn2 value=''></td>



  	</tr>

 

  </table>



</BODY>

</HTML>

问题的源头

• 集合：对象的容器与数据结构

• 无序集、有序集、映射

JCF的全家福

    好啦好啦，这些我们都知道，又不是在上数学课，说了这么多废话，怎么还没扯到正题上来？JCF的影子我还没看见呢！列位看官别急，这就给您道来。其实上面的概念对理解JCF非常重要。
    JCF是个颇有点规模的家族，看看它的类层次关系图就知道了，下面这张图（图1）摘自著名的Thinking in Java：

                                         图1 JCF层次结构

    哇，这么多接口和类，真有点让人无从下手的感觉。其实我们真正需要记住的只是这么一个超超easy的结构（图2）：


                                        图2

    这张图看起来舒服多了吧？但它又能说明什么问题呢？它怎么就能够把握整个JCF呢？我们把Collection接口置于最顶上，意思是想说：Collection其实是整个JCF家族中的“祖宗”，几乎所有的JCF成员都源自该接口，或者和它有密切的关系，Collection提供关于集合的一些通用操作的接口，包括插入（add()方法）、删除（remove()方法）、判断一个元素是不是其成员（contains()方法）、遍历（iterator()方法）等等。注意了，前面的“废话”在这里将得到体现：Set接口体现的是“无序集”的概念，它是不允许有重复元素出现的；List接口代表“有序集”；而Map接口则是“映射”（在早期的Java版本中并不叫Map，我们在后面会看到），其实Map.Entry接口就是代表一个“元素对”我们可以通过Map的entrySet()方法得到这样一个由“元素对”组成的Set对象。我们注意到Set和List都是从“祖宗”Collection派生的，而Map不是，毕竟对一对元素的操作与对单个元素的操作还是有区别的，但是如果你仔细对照一下Collection和Map的源代码，以及它们的直接后代AbstractCollection和AbstractMap的源代码，你将会发现很多相似的地方，所以我们仍然可以把Map看成是和Collection有着血缘关系的接口，而和Set，List一起处于并列的位置。
    有了“无序集”，“有序集”和“映射”，我们就可以定义各种各样的抽象数据结构了，譬如图1所示的向量，链表，堆栈，哈希表，平衡二叉树等。但我们需要记住的，仅仅是图2，置于其它的成员，在用到的时候查一下API手册不就行了？不过一般初学者还是比较容易用到一些类，像Vector、ArrayList、HashMap，我在这里列了一张表，显示了常见的JCF成员及其关系：

集合框架的祖宗： Collection					历史集合	新集合
无序集： Set		有序集： List			映射：Dictionary	映射：Map
AbstractSet	SortedSet	AbstractList		AbstractSequentialList	Hashtable	AbstractMap			SortedMap
		历史集合	新集合	LinkedList		WeakHashMap	IdentityHashMap	HashMap	TreeMap
HashSet	TreeSet	Vector	ArrayList
LinkedHashSet		Stack			Properties			LinkedHashMap

    可能有的概念您还不是太了解，譬如什么叫“历史集合”，Hashtable、HashMap、TreeMap三者之间有什么区别和联系，怎样实现对一个特定集合的快速遍历、元素查找或者排序，没关系，我们在下面将逐一进行研究。

细节考虑：目标与效率

    有了JCF的层次还不够，重要的是对集合所容纳的对象的具体操作，以前我们学数据结构的时候可能老师总会让你计算一个算法的时间复杂度，可能你会对这个O(f(n))很不耐烦，但事实上算法效率是一个重要的因素。

1. 侧重点：遍历 vs. 查找

    对集合的有两个主要的应用：我需要知道集合有哪些元素；根据条件找到一个特定的元素。在算法上通常称为“遍历”和“查找”。不要以为我们生活中不常用哦！譬如CCTV的“幸运52”里面，李咏让参赛者报出一款PDA的准确价位，他会怎么做？“2000”“高了”“1000”“低了”“1500”“低了”……直到答对为止。可能有很多人都会选择这个策略，无论他是不是计算机专业出身的，也不知道他是不是了解“数据结构”和“折半查找”，更不用说他是不是知道还有比在无初始代价下O(log n)的时间复杂度更快的算法了，但我们经常会自然而然地用这样的方法，这和一个人的行业无关，除非这个人的rp超强，呵呵……
    又讲了一堆题外话了，遍历和修改似乎是一对矛盾，一个可以高效率插入删除元素的数据结构通常遍历的性能并不是最优。于是JCF在这里根据用户的目标实现了两种定制的数据结构：哈希表（包括HashSet和HashMap）和平衡二叉树（包括TreeSet和TreeMap）。由于可排序性是一种独特的要求，所以引入了SortedSet和SortedMap，它们分别是AbstractSet和AbstractMap的子接口，而TreeSet和TreeMap又分别是他们的一种实现。熟悉数据结构的人可能比较了解，哈希表在进行插入、删除、查找这样的操作是很快的，其时间复杂度是常数级O(1)；平衡二叉树虽然插入、删除操作比较麻烦（需要O(log n)的代价），但进行遍历和排序却很快。选择完全在于用户的侧重点，但由于类型转换的方便性，通常我们用哈希表构造一个集合以后，再把它转换成相应的树集进行遍历，以获得较好的效果。

Set set1 = new HashSet(); set1.add(elem1);// 通过插入元素构造集合 set1.add(elem2); set1.add(elem3); Set set2 = new TreeSet(set); Iterator all = set2.iterator(); while (all.hasNext()) {// 遍历集合 all.next(); ... }

2. 历史实现 vs. 新实现

3. 同步 vs. 不同步

4. 容易遗忘的工具：Collections和Arrays

5. 泛型

小结

    我这里走马观花一样把JCF的一些主要概念罗嗦了一下，Java的老手们可能比较厌烦，新手们可能更觉得像回顾了一下高中的数学课和大学的数据结构，呵呵。这只是一个小小的例子，可见基础知识对现实当中的应用还是蛮有指导意义的。大师们看数学，觉得那是很唯美很艺术的一样东西，西方一直都把数学区别于其它自然科学，而认为它更靠近于哲学，像我等这样整天还在为找工作烦得要死的俗人还是没法入道啊，sigh……

参考资料

• IBM developerWorks教程： Java 集合框架
• J2SE Documentation: The Collections Framework
• The Java Tutorial
• JCF API