JSP2的自定义标签(简单，带属性，带标签体)

引用
在JSP规范的1.1版中增加了自定义标签库规范，自定义标签库是一种非常优秀的表现层组件技术。通过使用自定义标签库，可以在简单的标签中封装复杂的功能。


....在JSP1.1规范中开发自定义标签库比较复杂，JSP2规范简化了标签库的开发，在JSP2中开发标签库只需如下几个步骤：

开发自定义标签处理类；
建立一个*.tld文件，每个*.tld文件对应一个标签库，每个标签库对应多个标签；
在JSP文件中使用自定义标签。


....提示：标签库是非常重要的技术，通常来说，初学者、普通开发人员自己开发标签库的机会很少，但如果希望成为高级程序员，或者希望开发通用框架，就需要大量开发自定义标签了。所有的MVC框架，如Struts2、SpringMVC、JSF等都提供了丰富的自定义标签。

1 开发自定义标签类
....当我们在JSP页面使用一个简单的标签时，底层实际上由标签处理类提供支持，从而可以使用简单的标签来封装复杂的功能，从而使团队更好地协作开发（能让美工人员更好地参与JSP页面的开发）。
....自定义标签类都必须继承一个父类：javax.servlet.jsp.tagext.SimpleTagSupport除此之外，JSP自定义标签类还有如下要求。

如果标签类包含属性，每个属性都有对应的getter和setter方法。
重写doTag()方法，这个方法负责生成页面内容。

........下面开发一个最简单的自定义标签，该标签负责在页面上输出HelloWorld。

Java代码
//标签处理类，继承SimpleTagSupport父类   
public class HelloWorldTag extends SimpleTagSupport   
{   
//重写doTag方法，该方法在标签结束生成页面内容   
public void doTag()throws JspException,   
  IOException   
{   
  //获取页面输出流，并输出字符串   
  getJspContext().getOut().write("Hello World");   
}   
} 
//标签处理类，继承SimpleTagSupport父类
public class HelloWorldTag extends SimpleTagSupport
{
//重写doTag方法，该方法在标签结束生成页面内容
public void doTag()throws JspException,
  IOException
{
  //获取页面输出流，并输出字符串
  getJspContext().getOut().write("Hello World");
}
}


........上面这个标签处理类非常简单，它继承了SimpleTagSupport父类，并重写doTag()方法，而doTag()方法则负责输出页面内容。该标签没有属性，因此无须提供setter和getter方法。

2 建立TLD文件
........TLD是Tag Library Definition的缩写，即标签库定义，文件的后缀是tld，每个TLD文件对应一个标签库，一个标签库中可包含多个标签，TLD文件也称为标签库定义文件。
........标签库定义文件的根元素是taglib，它可以包含多个tag子元素，每个tag子元素都定义一个标签。通常我们可以到Web容器下复制一个标签库定义文件，并在此基础上进行修改即可。例如Tomcat6.0，在webapps\examples\WEB-INF\jsp2路径下包含了一个jsp2-example-taglib.tld文件，这就是示范用的标签库定义文件。
........将该文件复制到Web应用的WEB-INF/路径，或WEB-INF的任意子路径下，并对该文件进行简单修改，修改后的mytaglib.tld文件代码如下：

Java代码
<?xml version="1.0" encoding="GBK"?>   
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"  
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"  
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"  
version="2.0">   
<tlib-version>1.0</tlib-version>   
<short-name>mytaglib</short-name>   
<!-- 定义该标签库的URI -->   
<uri>http://www.leegang.org/mytaglib&lt;/uri>   
<!-- 定义第一个标签 -->   
<tag>   
  <!-- 定义标签名 -->   
  <name>helloWorld</name>   
  <!-- 定义标签处理类 -->   
  <tag-class>lee.HelloWorldTag</tag-class>   
  <!-- 定义标签体为空 -->   
  <body-content>empty</body-content>   
</tag>   
</taglib> 
<?xml version="1.0" encoding="GBK"?>
<taglib xmlns="http://java.sun.com/xml/ns/j2ee"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"
version="2.0">
<tlib-version>1.0</tlib-version>
<short-name>mytaglib</short-name>
<!-- 定义该标签库的URI -->
<uri>http://www.leegang.org/mytaglib&lt;/uri>
<!-- 定义第一个标签 -->
<tag>
  <!-- 定义标签名 -->
  <name>helloWorld</name>
  <!-- 定义标签处理类 -->
  <tag-class>lee.HelloWorldTag</tag-class>
  <!-- 定义标签体为空 -->
  <body-content>empty</body-content>
</tag>
</taglib>

........上面标签库定义文件也是一个标准的XML文件，该XML文件的根元素是taglib元素，因此我们每次编写标签库定义文件都直接添加该元素即可。

taglib下有三个子元素：

tlib-version：指定该标签库实现的版本，这是一个作为标识的内部版本号，对程序没有太大的作用。
short-name：该标签库的默认短名，该名称通常也没有太大的用处。
uri：这个属性非常重要，它指定该标签库的URI，相当于指定该标签库的唯一标识。如上斜体字代码所示，JSP页面中使用标签库时就是根据该URI属性来定位标签库的。

........除此之外，taglib元素下可以包含多个tag元素，每个tag元素定义一个标签，tag元素下至少应包含如下三个子元素：

name：该标签库的名称，这个属性很重要，JSP页面中就是根据该名称来使用此标签的。
tag-class：指定标签的处理类，毋庸置疑，这个属性非常重要，指定了标签由哪个Java类来处理。
body-content：这个属性也很重要，它指定标签体内容。该元素的值可以是如下几个：

tagdependent：指定标签处理类自己负责处理标签体。
empty：指定该标签只能作用空标签使用。
scriptless：指定该标签的标签体可以是静态HTML元素，表达式语言，但不允许出现JSP脚本。
JSP：指定该标签的标签体可以使用JSP脚本。
提示：因为JSP2规范不再推荐使用JSP脚本，所以JSP2自定义标签的标签体中不能包含JSP脚本。所以实际上body-content元素的值不可以是JSP。


........定义了上面的标签库定义文件后，将标签库文件放在Web应用的WEB-INF路径，或任意子路径下，Java Web规范会自动加载该文件，则该文件定义的标签库也将生效。

3 使用标签库
在JSP页面中确定指定标签需要2点：

标签库URI：确定使用哪个标签库。
标签名：确定使用哪个标签。

使用标签库分成以下两个步骤：

导入标签库：使用taglib编译指令导入标签库，就是将标签库和指定前缀关联起来。
使用标签：在JSP页面中使用自定义标签。

taglib的语法格式如下：

Java代码
<%@ taglib uri="tagliburi" prefix="tagPrefix" %> 
<%@ taglib uri="tagliburi" prefix="tagPrefix" %>

其中uri属性确定标签库的URI，这个URI可以确定一个标签库。而prefix属性指定标签库前缀，即所有使用该前缀的标签将由此标签库处理。
使用标签的语法格式如下：

Java代码
<tagPrefix:tagName tagAttribute=”tagValue” …>   
  <tagBody/>   
</tagPrefix:tagName> 
<tagPrefix:tagName tagAttribute=”tagValue” …>
  <tagBody/>
</tagPrefix:tagName>

如果该标签没有标签体，则可以使用如下语法格式：

Java代码
<tagPrefix:tagName tagAttribute=”tagValue” …/> 
<tagPrefix:tagName tagAttribute=”tagValue” …/>

........上面使用标签的语法里都包含了设置属性值，前面我们介绍的HelloWorldTag标签没有任何属性，所以使用该标签只需用<mytag:helloWorld/>即可。其中mytag是taglib指令为标签库指定的前缀，而helloWorld是标签名。
下面是使用helloWorld标签的JSP页面代码：

Java代码
<%@ page contentType="text/html; charset=GBK"%>   
<!-- 导入标签库，指定mytag前缀的标签，   
由http://www.leegang.org/mytaglib的标签库处理 -->   
<%@ taglib uri="http://www.leegang.org/mytaglib" prefix="mytag"%>   
<html>   
<head>   
<title>自定义标签示范</title>   
</head>   
<body bgcolor="#ffffc0">   
<h2>下面显示的是自定义标签中的内容</h2>   
<!-- 使用标签 ，其中mytag是标签前缀，根据taglib的编译指令，   
mytag前缀将由http://www.leegang.org/mytaglib的标签库处理 -->   
<mytag:helloWorld/><BR>   
</body>   
</html> 
<%@ page contentType="text/html; charset=GBK"%>
<!-- 导入标签库，指定mytag前缀的标签，
由http://www.leegang.org/mytaglib的标签库处理 -->
<%@ taglib uri="http://www.leegang.org/mytaglib" prefix="mytag"%>
<html>
<head>
<title>自定义标签示范</title>
</head>
<body bgcolor="#ffffc0">
<h2>下面显示的是自定义标签中的内容</h2>
<!-- 使用标签 ，其中mytag是标签前缀，根据taglib的编译指令，
mytag前缀将由http://www.leegang.org/mytaglib的标签库处理 -->
<mytag:helloWorld/><BR>
</body>
</html>
上面页面中第一行粗体字代码指定了http://www.leegang.org/mytaglib标签库的前缀为mytag，第二行粗体字代码表明使用mytag前缀对应标签库里的helloWorld标签。

4 带属性的标签
前面的简单标签既没有属性，也没有标签体，用法、功能都比较简单。实际上还有如下两种常用的标签：

带属性的标签。
带标签体的标签。

正如前面介绍的，带属性标签必须为每个属性提供对应的setter和getter方法。带属性标签的配置方法与简单标签也略有差别，下面介绍一个带属性标签的示例：

Java代码
public class QueryTag extends SimpleTagSupport   
{   
//标签的属性   
private String driver;   
private String url;   
private String user;   
private String pass;   
private String sql;   
//执行数据库访问的对象    
private Connection conn = null;   
private Statement stmt = null;   
private ResultSet rs = null;   
private ResultSetMetaData rsmd = null;   
//标签属性driver的setter方法   
public void setDriver(String driver) {   
  this.driver = driver;    
}   
     //标签属性url的setter方法   
public void setUrl(String url) {   
  this.url = url;    
}   
     //标签属性user的setter方法   
public void setUser(String user) {   
  this.user = user;    
}   
     //标签属性pass的setter方法   
public void setPass(String pass) {   
  this.pass = pass;    
}   
     //标签属性driver的getter方法   
public String getDriver() {   
  return (this.driver);    
}   
     //标签属性url的getter方法   
public String getUrl() {   
  return (this.url);    
}   
     //标签属性user的getter方法   
public String getUser() {   
  return (this.user);    
}   
     //标签属性pass的getter方法   
public String getPass() {   
  return (this.pass);    
}   
     //标签属性sql的getter方法   
public String getSql() {   
  return (this.sql);    
}   
     //标签属性sql的setter方法   
public void setSql(String sql) {   
  this.sql = sql;    
}   
public void doTag()throws JspException,   
  IOException   
{   
        try  
  {   
   //注册驱动   
   Class.forName(driver);   
   //获取数据库连接   
   conn = DriverManager.getConnection(url,user,pass);   
   //创建Statement对象   
   stmt = conn.createStatement();   
   //执行查询   
   rs = stmt.executeQuery(sql);   
   rsmd = rs.getMetaData();   
   //获取列数目   
   int columnCount = rsmd.getColumnCount();   
   //获取页面输出流   
   Writer out = getJspContext().getOut();   
   //在页面输出表格   
   out.write("<table border='1' bgColor='9999cc' width='400'>");   
   //遍历结果集   
   while (rs.next())   
   {   
    out.write("<tr>");   
    //逐列输出查询到的数据   
    for (int i = 1 ; i <= columnCount ; i++ )   
    {   
     out.write("<td>");   
     out.write(rs.getString(i));   
     out.write("</td>");   
    }   
    out.write("</tr>");   
   }   
  }   
  catch(ClassNotFoundException cnfe)   
  {   
   cnfe.printStackTrace();   
   throw new JspException("自定义标签错误" + cnfe.getMessage());   
  }   
  catch (SQLException ex)   
  {   
   ex.printStackTrace();   
   throw new JspException("自定义标签错误" + ex.getMessage());   
  }   
  finally  
  {   
   //关闭结果集   
   try  
   {   
    if (rs != null)   
     rs.close();   
    if (stmt != null)   
     stmt.close();   
    if (conn != null)   
     conn.close();   
   }   
   catch (SQLException sqle)   
   {   
    sqle.printStackTrace();   
   }   
  }   
}   
} 
public class QueryTag extends SimpleTagSupport
{
//标签的属性
private String driver;
private String url;
private String user;
private String pass;
private String sql;
//执行数据库访问的对象
private Connection conn = null;
private Statement stmt = null;
private ResultSet rs = null;
private ResultSetMetaData rsmd = null;
//标签属性driver的setter方法
public void setDriver(String driver) {
  this.driver = driver;
}
     //标签属性url的setter方法
public void setUrl(String url) {
  this.url = url;
}
     //标签属性user的setter方法
public void setUser(String user) {
  this.user = user;
}
     //标签属性pass的setter方法
public void setPass(String pass) {
  this.pass = pass;
}
     //标签属性driver的getter方法
public String getDriver() {
  return (this.driver);
}
     //标签属性url的getter方法
public String getUrl() {
  return (this.url);
}
     //标签属性user的getter方法
public String getUser() {
  return (this.user);
}
     //标签属性pass的getter方法
public String getPass() {
  return (this.pass);
}
     //标签属性sql的getter方法
public String getSql() {
  return (this.sql);
}
     //标签属性sql的setter方法
public void setSql(String sql) {
  this.sql = sql;
}
public void doTag()throws JspException,
  IOException
{
        try
  {
   //注册驱动
   Class.forName(driver);
   //获取数据库连接
   conn = DriverManager.getConnection(url,user,pass);
   //创建Statement对象
   stmt = conn.createStatement();
   //执行查询
   rs = stmt.executeQuery(sql);
   rsmd = rs.getMetaData();
   //获取列数目
   int columnCount = rsmd.getColumnCount();
   //获取页面输出流
   Writer out = getJspContext().getOut();
   //在页面输出表格
   out.write("<table border='1' bgColor='9999cc' width='400'>");
   //遍历结果集
   while (rs.next())
   {
    out.write("<tr>");
    //逐列输出查询到的数据
    for (int i = 1 ; i <= columnCount ; i++ )
    {
     out.write("<td>");
     out.write(rs.getString(i));
     out.write("</td>");
    }
    out.write("</tr>");
   }
  }
  catch(ClassNotFoundException cnfe)
  {
   cnfe.printStackTrace();
   throw new JspException("自定义标签错误" + cnfe.getMessage());
  }
  catch (SQLException ex)
  {
   ex.printStackTrace();
   throw new JspException("自定义标签错误" + ex.getMessage());
  }
  finally
  {
   //关闭结果集
   try
   {
    if (rs != null)
     rs.close();
    if (stmt != null)
     stmt.close();
    if (conn != null)
     conn.close();
   }
   catch (SQLException sqle)
   {
    sqle.printStackTrace();
   }
  }
}
}

上面这个标签稍微复杂一点，它包含了5个属性，如程序中粗体字代码所示，则程序需要为这5个属性提供setter和getter方法。
该标签输出的内容依然由doTag()方法决定，该方法会根据SQL语句查询数据库，并将查询结果显示在当前页面中。
对于有属性的标签，需要为tag元素增加attribute子元素，每个attribute子元素定义一个属性，attribue子元素通常还需要指定如下几个子元素：


name：设置属性名，子元素的值是字符串内容。
required：设置该属性是否为不需属性，该子元素的值是true或false。
fragment：设置该属性是否支持JSP脚本、表达式等动态内容，子元素的值是true或false。


为了配置上面的QueryTag标签，我们需要在mytaglib.tld文件中增加如下配置片段：

Java代码
<!-- 定义第二个标签 -->   
<tag>   
<!-- 定义标签名 -->   
<name>query</name>   
<!-- 定义标签处理类 -->   
<tag-class>lee.QueryTag</tag-class>   
<!-- 定义标签体为空 -->   
<body-content>empty</body-content>   
<!-- 配置标签属性:driver -->   
<attribute>   
  <name>driver</name>    
  <required>true</required>   
  <fragment>true</fragment>   
</attribute>   
<!-- 配置标签属性:url -->   
<attribute>   
  <name>url</name>    
  <required>true</required>   
  <fragment>true</fragment>   
</attribute>   
<!-- 配置标签属性:user -->   
<attribute>   
  <name>user</name>    
  <required>true</required>   
  <fragment>true</fragment>   
</attribute>   
<!-- 配置标签属性:pass -->   
<attribute>   
  <name>pass</name>    
  <required>true</required>   
  <fragment>true</fragment>   
</attribute>   
<!-- 配置标签属性:sql -->   
<attribute>   
  <name>sql</name>    
  <required>true</required>   
  <fragment>true</fragment>   
</attribute>   
</tag> 
<!-- 定义第二个标签 -->
<tag>
<!-- 定义标签名 -->
<name>query</name>
<!-- 定义标签处理类 -->
<tag-class>lee.QueryTag</tag-class>
<!-- 定义标签体为空 -->
<body-content>empty</body-content>
<!-- 配置标签属性:driver -->
<attribute>
  <name>driver</name>
  <required>true</required>
  <fragment>true</fragment>
</attribute>
<!-- 配置标签属性:url -->
<attribute>
  <name>url</name>
  <required>true</required>
  <fragment>true</fragment>
</attribute>
<!-- 配置标签属性:user -->
<attribute>
  <name>user</name>
  <required>true</required>
  <fragment>true</fragment>
</attribute>
<!-- 配置标签属性:pass -->
<attribute>
  <name>pass</name>
  <required>true</required>
  <fragment>true</fragment>
</attribute>
<!-- 配置标签属性:sql -->
<attribute>
  <name>sql</name>
  <required>true</required>
  <fragment>true</fragment>
</attribute>
</tag>

上面5行粗体字代码分别为该标签配置了driver、url、user、pass和sql等5个属性，并指定这5个属性都不需属性、而且属性值支持动态内容。
配置完毕后，就可在页面中使用标签，先导入标签库，然后使用标签。使用标签的JSP页面片段如下：

Java代码
<!-- 导入标签库，指定mytag前缀的标签，   
由http://www.leegang.org/mytaglib的标签库处理 -->   
<%@ taglib uri="http://www.leegang.org/mytaglib" prefix="mytag"%>   
...   
<!-- 其他HTML内容 -->   
<!-- 使用标签 ，其中mytag是标签前缀，根据taglib的编译指令，   
mytag前缀将由http://www.leegang.org/mytaglib的标签库处理 -->   
<mytag:query   
driver="com.mysql.jdbc.Driver"  
url="jdbc:mysql://localhost:3306/javaee"  
user="root"  
pass="32147"  
sql="select * from newsinf"/> 
<!-- 导入标签库，指定mytag前缀的标签，
由http://www.leegang.org/mytaglib的标签库处理 -->
<%@ taglib uri="http://www.leegang.org/mytaglib" prefix="mytag"%>
...
<!-- 其他HTML内容 -->
<!-- 使用标签 ，其中mytag是标签前缀，根据taglib的编译指令，
mytag前缀将由http://www.leegang.org/mytaglib的标签库处理 -->
<mytag:query
driver="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/javaee"
user="root"
pass="32147"
sql="select * from newsinf"/>

........在JSP页面中只需要使用简单的标签，即可完成“复杂”的功能：执行数据库查询，并将查询结果在页面上以表格形式显示。这也正是自定义标签库的目的——以简单的标签，隐藏复杂的逻辑。
........当然，并不推荐在标签处理类中访问数据库，因为标签库是表现层组件，它不应该包含任何业务逻辑实现代码，更不应该执行数据库访问，它只应该负责显示逻辑。
注意：JSTL是Sun提供的一套标签库，这套标签库的功能非常强大。另外，DisplayTag是Apache组织下的一套开源标签库，主要用于生成页面并显示效果。
5 带标签体的标签
........带标签体的标签，可以在标签内嵌入其他内容（包括静态的HTML内容和动态的JSP内容），通常用于完成一些逻辑运算，例如判断和循环等。下面以一个迭代器标签为示例，介绍带标签体标签的开发过程。
........一样先定义一个标签处理类，该标签处理类的代码如下：

Java代码
public class IteratorTag extends SimpleTagSupport   
{   
//标签属性，用于指定需要被迭代的集合   
private String collection;   
//标签属性，指定迭代集合元素，为集合元素指定的名称   
private String item;   
//collection属性的setter和getter方法   
public void setCollection(String collection)   
{   
  this.collection = collection;   
}   
public String getCollection()   
{   
  return this.collection;   
}   
//item属性的setter和getter方法   
public void setItem(String item)   
{   
  this.item = item;   
}   
public String getItem()   
{   
  return this.item;   
}   
//标签的处理方法，简单标签处理类只需要重写doTag方法   
public void doTag() throws JspException, IOException   
{   
  //从page scope中获取属性名为collection的集合   
  Collection itemList = (Collection)getJspContext().   
   getAttribute(collection);   
  //遍历集合   
  for (Object s : itemList)   
  {   
   //将集合的元素设置到page 范围   
   getJspContext().setAttribute(item, s );   
   //输出标签体   
   getJspBody().invoke(null);   
  }   
}   
} 
public class IteratorTag extends SimpleTagSupport
{
//标签属性，用于指定需要被迭代的集合
private String collection;
//标签属性，指定迭代集合元素，为集合元素指定的名称
private String item;
//collection属性的setter和getter方法
public void setCollection(String collection)
{
  this.collection = collection;
}
public String getCollection()
{
  return this.collection;
}
//item属性的setter和getter方法
public void setItem(String item)
{
  this.item = item;
}
public String getItem()
{
  return this.item;
}
//标签的处理方法，简单标签处理类只需要重写doTag方法
public void doTag() throws JspException, IOException
{
  //从page scope中获取属性名为collection的集合
  Collection itemList = (Collection)getJspContext().
   getAttribute(collection);
  //遍历集合
  for (Object s : itemList)
  {
   //将集合的元素设置到page 范围
   getJspContext().setAttribute(item, s );
   //输出标签体
   getJspBody().invoke(null);
  }
}
}

........上面标签处理类与前面处理类并没有太大的不同，该处理类包含2个属性，并为这两个属性提供了setter和getter方法。标签处理类的doTag方法首先从page范围内获取了指定名称的Collection对象，然后遍历Collection对象的元素，每次遍历都调用了getJspBody()方法，如程序中粗体字代码所示，该方法返回该标签所包含的标签体：JspFragment对象，执行该对象的invoke()方法，即可输出标签体内容。该标签的作用是：遍历指定集合，每遍历一个集合元素，即输出标签体一次。
........因为该标签的标签体不为空，配置该标签时指定body-content为scriptless，该标签的配置代码片段如下代码所示：

Java代码
<!-- 定义第三个标签 -->   
<tag>   
<!-- 定义标签名 -->   
<name>iterator</name>   
<!-- 定义标签处理类 -->   
<tag-class>lee.IteratorTag</tag-class>   
<!-- 定义标签体支持JSP脚本 -->   
<body-content>scriptless</body-content>   
<!-- 配置标签属性:collection -->   
<attribute>   
  <name>collection</name>    
  <required>true</required>   
  <fragment>true</fragment>   
</attribute>   
<!-- 配置标签属性:item -->   
<attribute>   
  <name>item</name>    
  <required>true</required>   
  <fragment>true</fragment>   
</attribute>   
</tag> 
<!-- 定义第三个标签 -->
<tag>
<!-- 定义标签名 -->
<name>iterator</name>
<!-- 定义标签处理类 -->
<tag-class>lee.IteratorTag</tag-class>
<!-- 定义标签体支持JSP脚本 -->
<body-content>scriptless</body-content>
<!-- 配置标签属性:collection -->
<attribute>
  <name>collection</name>
  <required>true</required>
  <fragment>true</fragment>
</attribute>
<!-- 配置标签属性:item -->
<attribute>
  <name>item</name>
  <required>true</required>
  <fragment>true</fragment>
</attribute>
</tag>

........上面配置片段中粗体字代码指定该标签的标签体可以是静态HTML内容，也可以是表达式语言。
........为了测试在JSP页面中使用该标签的效果，我们首先把一个List对象设置成page范围的属性，然后使用该标签来迭代输出List集合的全部元素。
JSP页面代码如下：

Java代码
<%@ page import="java.util.*"%>   
<%@ page contentType="text/html; charset=GBK"%>   
<!-- 导入标签库，指定mytag前缀的标签，   
由http://www.leegang.org/mytaglib的标签库处理 -->   
<%@ taglib uri="http://www.leegang.org/mytaglib" prefix="mytag"%>   
<html>   
<head>   
  <title>带标签体的标签-迭代器标签</title>   
</head>   
<body>   
  <h2>带标签体的标签-迭代器标签</h2>   
  <hr>   
  <%   
  //创建一个List对象   
  List<String> a = new ArrayList<String>();   
  a.add("hello");   
  a.add("world");   
  a.add("java");   
  //将List对象放入page范围内   
  pageContext.setAttribute("a" , a);   
  %>   
  <table border="1" bgcolor="aaaadd" width="300">   
  <!-- 使用迭代器标签，对a集合进行迭代 -->   
  <mytag:iterator collection="a" item="item">   
   <tr>   
    <td>${pageScope.item}</td>   
   <tr>   
  </mytag:iterator>   
  </table>   
</body>   
</html> 
<%@ page import="java.util.*"%>
<%@ page contentType="text/html; charset=GBK"%>
<!-- 导入标签库，指定mytag前缀的标签，
由http://www.leegang.org/mytaglib的标签库处理 -->
<%@ taglib uri="http://www.leegang.org/mytaglib" prefix="mytag"%>
<html>
<head>
  <title>带标签体的标签-迭代器标签</title>
</head>
<body>
  <h2>带标签体的标签-迭代器标签</h2>
  <hr>
  <%
  //创建一个List对象
  List<String> a = new ArrayList<String>();
  a.add("hello");
  a.add("world");
  a.add("java");
  //将List对象放入page范围内
  pageContext.setAttribute("a" , a);
  %>
  <table border="1" bgcolor="aaaadd" width="300">
  <!-- 使用迭代器标签，对a集合进行迭代 -->
  <mytag:iterator collection="a" item="item">
   <tr>
    <td>${pageScope.item}</td>
   <tr>
  </mytag:iterator>
  </table>
</body>
</html>

........上面页面代码中粗体字代码即可实现通过iterator标签来遍历指定集合。

从iteratorTag.jsp页面的代码来看，使用iterator标签遍历集合元素比使用JSP脚本遍历集合元素要优雅得多，这就是自定义标签的魅力。
提示：实际上JSTL标签库提供了一套功能非常强大标签，例如普通的输出标签，像我们刚刚便携的迭代器标签，还有用于分支判断的标签等等，JSTL都有非常完善的实现。