JSTL标签库

关注

转载最新推荐文章于 2026-09-19 12:42:24 发布 1.1k 阅读 AI 写同款· GEO 优化 ›

使用taglibs-i18n进行国际化处理范例文章代码博文链接：https://cyhcheng.iteye.com/blog/246344 立即下载

1、JSTL标签库概述：
     JSTL通常被认为是一种单标签库。但JSTL实际上有4个标签库。这些标签库被概括为如下：
    §核心标签库—包含一些Web应用的必要的标签。核心标签库的实例包括循环，表达式赋值和基本输入输出。.
    §格式化/国际化标签库—包括被用来解析数据的标签库。这种标签会解析数据，比如日期，不同的场所区域等。
    §数据库标签库—包含被用来访问SQL数据库的标签。这些标签通常仅仅只创建原形（prototype）程序。这个是因为大多数程序不会直接从JSP页面中来处理数据库访问。数据库访问应该被嵌入到能够被JSP页面所访问的EJB中。
    §XML标签库—包含被用来访问XML元素的标签。因为XML广泛使用于Web开发，XML的处理是JSTL的一个重要的特征。
2、安装使用JSTL1.1
    JSTL1.1支持Servlet2.4且是JSP2.0以上版本的容器中，可以到这儿下载jakarta-taglibs-standard-1.1.2.zip，解压后将lib目录中的jstl.jar、standard.jar复制到当前Web应用的“WEB-INF/lib”中，最好同时把tld文件的目录也复制到WEB-INF中，方便日后使用。
3、核心标签库，包含通用标签、条件标签、迭代标签、URL标签
    通用标签用于操作JSP页面创建存储在隐式对象中的变量；条件标签用于对JSP页面中的代码进行条件判断和处理；迭代标签用于循环遍历一个对象的集合；URL标签用于控制页面的跳转动作。
    要在JSP页面中使用核心标签库，首先需要导入核心标签的URI：
< % taglib uri="http://java.sun.com/jstl/core" prefix="c" %>
    1）通用标签（输入输出）：<c:set>、<c:out>、<c:remove>
    §<c:set>标签主要用来将变量储存至JSP隐式对象中或JavaBean的属性中，其语法为：
语法一：将value的值储存至范围为scope的VarName变量之中：
<c:set value="value" var="varName" [scope="{page|request|session|application}"]/>
语法二：将本体内容储存至范围为scope的VarName变量之中：
<c:set var="varName" [scope="{page|request|session|application}]">
本体内容
< /c:set>
value:要被储存的值
var:欲存入的变量名称
scope:指定变量的JSP范围
    §<c:out>w标签主要用来显示数据的内容，就像<%=JSP表达式%>一样，其语法为：
语法一：没有本体(body)内容:
<c:out value="value" [escapeXml="{true|false}" [default="defaultValue"]/>
语法二：有本体内容：
<c:out value="value" [escapeXml="{true|false}"/>
defaultValue
< /c:out>
value:需要显示出来的值。
Default:如果value的值为null，则显示default的值。
escapeXml:是否转换特殊字符，如：<转换成<。
    §<c:remove>标签主要用来移除变量，其语法为：
<c:remove var="varname" [scope="{page|request|session|application}"]/>
var:欲移除的变量名称。
scope:var变量的JSP范围。
    2）通用标签使用演示：
< %@ page contentType="text/html;charset=gbk" %>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
< c:set value="hello" var="sessionvar1" scope="session"/>
< c:set var="sessionvar2" scope="session">
world!
< /c:set>
存储后显示：<br>
< c:out value="${sessionScope.sessionvar1}"/>
< c:out value="${sessionScope.sessionvar2}"/><br>
< c:remove var="sessionvar2" scope="session"/>
删除后显示：<br>
< c:out value="${sessionScope.sessionvar1}"/>
< c:out value="${sessionScope.sessionvar2}"/>
    3）条件标签：<c:if>、<c:choose>、<c:when>、<c:otherwise>等。
    §<c:if>标签用于有条件地执行代码，如果test属性的值为true，则会执行<c:if>标签的标签体。这是一个容器标签，其语法为：
语法一：没有标签体内容（body）：
<c:if test="testCondition" var="varName" [scope="{page|request|session|application}"]/>
语法二：有标签体内容：
<c:if test="testCondition" [var="varName"] [scope="{page|request|session|application}"]>
< /c:if>
test:如果表示的结果为true，则执行标签体内容，false则相反。
var:用来存储test运算后的结果，即true或false。
scope:变量的JSP范围。
    §<c:choose>标签类似于java中的switch语句，它用于执行条件语句块。
<c:choose>
本体内容（<when>和<otherwise）
< /c:choose>
    §<c:when>标签的用途和switch语句中的case一样。
    §<c:otherwise>标签，相当于switch语句中的default。
    4）条件标签演示：
< %@ page contentType="text/html;charset=gbk" %>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
< %
int i=(int)(Math.random()*10);
pageContext.setAttribute("signalStrength",new Integer(i));
%>
< c:if test="${pageScope.signalStrength<5}" var="value1"/>
< c:if test="${pageScope.signalStrength>5}">
    <c:set var="value2" value="true" scope="page"/>
< /c:if>
< c:choose>
    <c:when test="${pageScope.value1 }">
        产生的随机数小于5.
    </c:when>
    <c:when test="${pageScope.value2 }">
        产生的随机数大于5.
    </c:when>
    <c:otherwise>
        产生的随机数等于5.
    </c:otherwise>
< /c:choose>
    5）迭代标签：<c:forEach>标签和<c:forTokens>标签等。
    §<c:forEach>标签为循环控制，它可以将集合中的成员循序浏览一遍，动作方式为当条件符合时，就会重复执行<c:forEach>标签的标签体内容。
<c:forEach [var="varName"] items="collection" [varStatus="varStatusName"] [begin="begin"] [end="end"] [step="step"]>
本体内容
< /c:forEach>
语法二：迭代指定的次数：
<c:forEach [var="varName"] [varStatus="varStatusName"] begin="begin" end="end" [step="step"]>
本体内容
< /c:forEach>
var:用来存放当前指到的成员。
items:被迭代的集合对象（包括：Arrays、Collection、Iterator、Enumeration、Map）。
varStatus:用来存放当前指到的相关成员信息。
begin:开始的位置，若有，其值必须大于等于0.
end:结束的位置，默认值最后一个成员，若有，end必须大于begin。
step:每次迭代的间隔数，若有，必须大于等于0。
    §<c:forTokens>标签用来浏览一字符串中所有的成员，其成员是由定义符号（delimiters)所分隔的。使用语法如下：
<c:forTokens items="stringOfTokens" delimes="delimiters" [var="varName"] [varStatus="varStatusName"] [begin="begin"] [end="end"] [step="step"]>
本体内容
< /c:forTokens>
var:用来存放现在指到的成员。
items:被迭代的字符串。
delims:定义用来分割字符串的字符。
varStatus:用来存放现在指到的相关成员信息。
begin:开始的位置，若有，必须大于等于0.
end:结束的位置，若有必须大于begin。
step:每次迭代的间隔数，若有，step必须大于等于0.
    6）迭代标签演示：
< %@ page contentType="text/html;charset=gbk" import="java.util.*"%>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
< %
    String[] fruits={"苹果","葡萄","雪梨","白桃","柿子"};
    pageContext.setAttribute("fruits",fruits);

    Vector books=new Vector();
    books.add("《西游记》");
    books.add("《水浒传》");
    books.add("《三国演义》");
    books.add("《红楼梦》");
    pageContext.setAttribute("books",books);

    String str="太阳、星星、月亮；地球|天空";
    pageContext.setAttribute("str",str);

%>
< h3>数组迭代</h3>
< c:forEach var="fruit" items="${fruits}">
< c:out value="${fruit}"/>
< /c:forEach>
< h3>集合类迭代</h3>
< c:forEach var="book" items="${books}">
< c:out value="${book}"/>
< /c:forEach>
< h3>自变量循环</h3>
< c:forEach var="i" begin="1" end="10" step="2">
< c:out value="${i}"/>
< /c:forEach>
< h3>字符串分隔</h3>
< c:forTokens items="${str}" delims="、；|" var="substr">
< c:out value="${substr}"/>
< /c:forTokens>
5）URL标签，包括<c:import>、<c:redirect>和<c:url>等。
    §<c:import>标签可以把其他静态或动态文件包含至本身JSP网页。它和JSP动作指令<jsp:include>最大的差别在于：<jsp:include>只能包含和自己同一个WEB应用下的文件；而<c:import>除了能包含和自己同一人WEB应用的文件外，也可以包含不同WEB应用或者是其他网站的文件。其语法如下：
语法一：
<c:import url="url" [context]="context" [var="varName"] [scope="{page|request|session|application}"] [charEncoding="charEncoding"]>
本体内容
< /c:import>
语法二：
<c:import url="url" [context="context"] varReader="varReader" [charEncoding="charEncoding"]>
本体内容
<c:import>
url:被包含文件的地址。
context:在相同web容器下，其他WEB应用必须以“/”开头。
var:储存被包含的文件内容（以String类型存入）。
scope:变量的JSP作用域。
charEncoding:被包含文件内容的编码格式。
varReader:储存被包含文件的内容。
例如：
<c:import url="http://www.163.com"/>的功能就是用<c:import>把http://www.163.com的内容加到网页中。
    §<c:url>标签主要用来产生一个URL。
语法一：没有标签体内容：
<c:url value="value" [context="context"] [var="varName"] [scope="{page|request|session|application}"]/>
语法二：有标签体内容，代表查询字符串参数：
value:执行的URL。
context:在相同WEB容器下，其他WEB应用必须以“/”开头。
var:储存被包含文件的内容（以String类型存入）。
scope:变量的JSP作用域。
例如：
<c:url value="http://dog.xiaonei.com/pet-profile.do">
< c:param name="portal" value="homeFootprint"/>
< c:param name="id" value="233227104"/>
< /c:url>
会产生一个到达我的校内的狗狗的链接地址。
    §<c:redirect>标签可以将客户端的请求从一个JSP网页导向到其它文件。语法如下：

1、I18N与格式化标签库
    国际化（I18N）与格式化标签库可用于创建国际化的WEB应用程序，它们对数字和日期、时间的输出进行了标准化。国际化的应用程序支持多种语言。在JSP页面导入国际化与格式化标签的语法是：
< %@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
常用的标签有：<fmt:setLocale>、<fmt:bundle>、<fmt:setBundle>、<fmt:message>等。
    1）<fmt:setLocale>标签用于重写客户端指定的区域设置。它将区域设置存储在javax.servlet.jsp.jstl.fmt配置变量中。setLocale是一个空标签，其使用用法为：
<fmt:setLocale value="setting" variant="variant" scope="page/request/session/application"/>
value:包含一个含有两个小写字母的语言代码和一个含有两个大写字母的国家或地区代码。语言和国家或地域代码应用连字符或下划线分隔，如：zh_CN.
variant:指定特定于浏览器的变量，它是可选的。
scope:指定配置变量的范围。
    2）<fmt:setLocale>标签使用演示：
< %@ page contentType="text/html; charset=GBK"%>
< %@ page import="java.util.*"%>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
< %@ taglib uri="http://java.sun.com/jsp/jstl/fmt" prefix="fmt" %>
< %
//获得本区域
String locale=request.getLocale().toString();
Date now=new Date();
pageContext.setAttribute("now",now);
%>
< h3>数字格式化示例：</h3>
< fmt:formatNumber value="999.9999" type="number" maxFractionDigits="4" />
< h3>货币格式化示例：</h3>
< c:set var="salary" value="12000"/>
本地格式化：
<fmt:formatNumber type="currency" value="${salary}"/>
；en_US格式化：
<fmt:setLocale value="en_US"/>
< fmt:formatNumber type="currency" value="${salary}"/>
< h3>日期格式化示例：</h3>
en_US格式化：
<fmt:formatDate value="${now}"/>
；本地格式化：
<fmt:setLocale value="${locale}"/>
< fmt:formatDate value="${now}"/>
    3）<fmt:bundle>标签，用于创建一个I18N本地化上下文，并将这的资源包加载到其中。资源包的名称由<fmt:bundle>标签的basename属性指定。其语法为：
<fmt:bundle basename="basename">
本体内容
< /fmt:bundle>
    4）<fmt:message>标签，用于给出资源包的输出值，其属性key指定消息的关键字。此标签的语法为：
<fmt:message key="messagekey">
    5）<fmt:bundle>标签与<fmt:message>标签的使用演示：
    首先定义好两个资源包，英文版input.properties，中文版input_zh_CN.properties，把两者拷贝到WEB应用下的“WEB-INF/classes”目录下。读取资源的JSP文件的源码如下：
< %@ page contentType="text/html; charset=GBK"%>
< %@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
< html>
< fmt:bundle basename="input">
    <head>
            <title><fmt:message key="title" /></title>
    </head>
        <h1>
            <fmt:message key="hello" />
        </h1>
< /fmt:bundle>
< /html>
    英文版input.properties的内容：
title=this is a fmtdemo
hello=welcome you to here!
    中文版input_zh_CN.properties的内容：
title=\u56fd\u9645\u6f14\u793a
hello=\u55ef\uff0c\u4e0d\u9519~\u52a0\u6cb9\uff01
   调试的时候，要设置浏览器的语言设置来调用不包的资源包。比如IE：工具-->internet选项-->语言，进行相应的设置。
    中文版input_zh_CN.properties的内容是经过nuicode编码后形成，这是因为java对于资源文件的处理只支持单字节，要作这样的处理。在JDK的bin目录下有一个native2ascii可以完成这个功能。首先用中文写一个资源文件china.properties，然后进行编译即可，代码如下：
native2ascii -encoding gb2312 china.properties input_zh_CN.properties
china.properties的内容：
title=国际演示
hello=嗯，不错~加油！
注：native2ascii可以解决乱码问题。
    6）<fmt:setBundle>创建一个I18N本地化的上下文，并将它存储在范围变量中。它是一个空标签，其语法如下：
<fmt:setBundle basename="basename" var="varName" scope="page/request/session/application"/>
basename:指定资源包的名称。
var:指定导出的范围变量的名称，它存储在I18N本地化上下文。
scope:指定var的范围。
    7）<fmt:setBundle>标签使用演示：
< %@ page contentType="text/html; charset=GBK"%>
< %@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt"%>
< html>
    <head>
        <fmt:setLocale value="zh_CN" scope="page" />
        <fmt:setBundle basename="input" scope="page" />
        <title><fmt:message key="title" /></title>
    </head>
    <body>
        <h1>
            <fmt:message key="hello" />
        </h1>
    </body>
< /html>
    采有这种方式导入包，即使改变浏览器的语言设置，也是始终按所设置的本地语言显示。
2、SQL标签库
    JSTL的SQL标签用于访问各种关系数据库，是为了基于WEB的小型应用程序而设计的。它提供的各种标签可以在JSP页面内直接访问数据库，在JSP页面中导入SQL标签库的语法是：
< %@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql" %>
    此处重点介绍<sql:setDataSource>、<sql:query>、<sql:update>、<sql:transaction>等几个常用标签的使用方法。
    1）<sql:setDataSource>标签用于为数据库设置数据源。它是一个空标签，其语法为：
<sql:setDataSource DataSource="datasource" url="jdbcrul" driver="driverclassdriver" user="username" password="usepwd" var="varname" scope="page|request|session|application"/>
DataSource:可以是Java命名和目录接口资源的路径或JDBC参数字符串。
url:是与数据库关联的URL。
driver:是一个JDBC参数，其值为驱动程序的类名。
user:是数据库的用户名。
password:是用户的密码。
var:是指定数据源的导出范围变量的名称。
scope:指定范围。
    注意，在<sql:setDataSource>中，如果使用了DataSource属性，则无法使用URI属性。
    2）<sql:query>标签用于搜索数据库并返回包含数据行的结果集。其语法为：
<sql:query var="varname" dataSource="datasource" scope="page|request|session|application" maxRows="maxrows" startRow="startRow">
要执行的SQL语句
<sql:param/>
< /sql:query>
var:为查询结果指定导出的范围变量的名称。
scope:指定变量的范围。
dataSource:指定与要查询的数据库关联的数据源。
maxRows:指定结果中所包含的数据的最大行数。
startRow:指定从指定索引开始的数据行。
    3）<sql:update>标签用于执行insert、update和delete语句。如果所有数据行都没有受到插入、更新或删除操作的影响，则会返回0。其语法为：
<sql:update datasource="datasource" var="varName" scope="page|request|session|application">
SQL语句
<sql:param/>
< /sql:update>
其中：
SQL语句：指定的update、insert、delete语句。
dataSource:是与要更新的数据库关联的数据源。
var：为数据库更新的结果指定导出的范围变量的名称。
scope:指定变量的范围。
    4）<sql:transaction>标签用于为<sql:query>标签和<sql:update>标签建立事务处理上下文。其语法为：
<sql:transaction dataSource="datasource" isolation="isoationLevel">
使用<sql:query>或<sql:update>语句
< /sql:transaction>
dataSource:设置SQL的数据源，它可以是字符串或一个DataSource对象。
isolation:设置事务处理的隔离级别。隔离级别可以是read_committed、read_uncommitted、repeatable_read或serializable。
    5）使用sql标签的实例演示：
< %@ page contentType="text/html; charset=GBK"%>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
< %@ taglib uri="http://java.sun.com/jsp/jstl/sql" prefix="sql"%>
< html>
    <head>
        <title>sqldemo</title>
    </head>
    <body bgcolor="#ffffff">
        <h1>
            使用 SQL 标签库
        </h1>
        <c:set var="valprice" value="1000" />
        <sql:setDataSource
            driver="oracle.jdbc.driver.OracleDriver"
            url="jdbc:oracle:thin:@127.0.0.1:1521:wzz"
            user="scott" password="tiger" var="conn" />
        <sql:transaction dataSource="${conn}">
            <sql:update var="newTable">
                create table PRODUCTDETAILS
                (
                  PRODUCTNAME NVARCHAR2(20) not null,
                  PRODUCTTYPE NVARCHAR2(15) not null,
                  PRICE       NVARCHAR2(5) not null,
                  BRAND       NVARCHAR2(25) not null,
                  DESCRIPTION NVARCHAR2(50) not null
                )
            </sql:update>
        </sql:transaction>
        <sql:update var="newrow" dataSource="${conn}">
            INSERT INTO ProductDetails(ProductName, ProductType,
            Price, Brand, Description)
            VALUES('JSP专家导学 ', '编程书籍', '1000', 'Lee', '适合大专院校的教材或参考书籍')
        </sql:update>
        <sql:query var="products" dataSource="${conn}">
            select * from ProductDetails
        </sql:query>

        <table border="1">
            <c:forEach items="${products.rows}" var="row">
                <tr>
                    <td>
                        ${row.ProductName}
                    </td>
                    <td>
                        ${row.ProductType}
                    </td>
                    <td>
                        ${row.Price}
                    </td>
                    <td>
                        ${row.Description}
                    </td>
                </tr>
            </c:forEach>
        </table>
    </body>
< /html>
    注：本实例连接的oracle，要将classes.jar导入到相应的目录下。
3、XML标签库
    JSTL提供了一些有关XML的标签，让开人员可不用深入了解SAX和DOM等API，就可以轻易地处理XML文件。在页面中导入XML标签库的语法：
< %@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
    1)<x:parse>标签用解析XML文件，其语法为：
<x: parse={var="var"[scope="{page|request|session|application}"]|varDom="var"[scopeDom="{page|request|session|application}"]}[systemId="systemId"[filter="filter"]>
需要解析的XML文档
< /x:parse>
var:储存解析后的XML文件。
scope:变量的JSP范围。
varDom:储存解析后的XML文件（类型为org.w3c.dom.Document）。
scopeDom:属性varDom指出变量的有效范围。
systemId:XML文件的URI。
filter:XMLFilter过滤器。
    2）<x:out>标签主要来取出XML中的节点数。其语法：
<x:out select="XpathExpression" [escapeXml="{true|false]"]/>
select:XPath语句。
escapeXml:是否转换特殊字符，例如：<转换成<
    3)<x:set>标签将从XML文件中取得的内容存储至JSP范围中，其语法为：
<x:set select="XPathExpression" var="var" [scope="{page|request|session|application}"]/>
select:XPath语句。
var:将XML文件中取得的内容储存至varName中。
scope:变量的JSP范围。
    4）XML标签实例：book.xml与readBook.jsp
book.xml的代码如下：
< ?xml version="1.0" encoding="GBK"?>
< books>
    <book lang="java">
        <title>《Java 编程思想》</title>
        <author>Bruce Eckel</author>
    </book>
    <book lang="java">
        <title>《JSP 专家导学》</title>
        <author>希赛顾问团</author>
    </book>
    <book lang=".net">
        <title>《专家导学.NET开发框架》</title>
        <author>希赛顾问团</author>
    </book>
< /books>
readBook.jsp的源代码如下：
< %@ page language="java" contentType="text/html; charset=GBK"%>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
< %@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>

< html>
<head>
    <title>XML标签示例程序</title>

</head>
<body>
    <x:parse var="sampleXml">
        <c:import charEncoding="GBK" url="Books.xml"/>
    </x:parse>
    <h3>装载XML文件成功</h3>
    <h3>显第一本书的标题：</h3>
    <x:out select="$sampleXml//title"/><br/>
    <h3>查找.net书：</h3>
    <x:set select="$sampleXml//book[@lang='.net']" var="DoNetBook" />
    <x:out select="$DoNetBook"/>
</body>
< /html>
注：使用XML标签时，Web应用环境中除了装载jstl.jar和standard.jar外还应加入xalan.jar和xercesImpl.jar两文件。

jsp程序设计：jstl之JSTL标签库(下)
Posted on 2008-10-26 23:37 梦与桥阅读(430) 评论(0) 编辑收藏所属分类: jsp程序设计
1、简单标签
    实现自定义标签的三个步骤：
    1）编写标签处理程序（java类）。
    2）编写标签库描述符（提供有关标签和库文件的元信息的XML文件）。
    3）JSP实现（包含自定义标签的JSP文件）。
2、开发简单的自定义标签
    1）标签处理程序wz.java的源代码如下：
package www.zzz;
import javax.servlet.jsp.tagext.*;
import java.io.*;
import java.util.*;
import javax.servlet.jsp.*;
public class wz extends SimpleTagSupport{
    private String name;
    private int age;
    public void setName(String name) {
        this.name = name;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public void doTag() throws JspException, IOException {
        JspWriter out = this.getJspContext().getOut();
        out.println("<h3>"+name+"的个人信息：</h3><br>");
        getJspContext().setAttribute("name","姓名："+name+"<br>");
        getJspContext().setAttribute("age", "年龄："+age+"<br>");
        getJspBody().invoke(null);
    }
}
    2）标签描述文件wz.tld的内容如下：
< ?xml version="1.0" encoding="UTF-8" ?>
< 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 http://java.sun.com/xml/ns/j2ee/web-jsptaglibrary_2_0.xsd"
    version="2.0">
    <description>
        A tag library exercising SimpleTag handlers.
    </description>
    <tlib-version>1.0</tlib-version>
    <short-name>SimpleTagLibrary</short-name>
    <uri>/SimpleTagLibrary</uri>
    <tag>
        <description>Outputs Hello, World</description>
        <name>wz</name>
        <tag-class>www.zzz.wz</tag-class>
        <body-content>scriptless</body-content>
        <attribute>
            <name>name</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
        <attribute>
            <name>age</name>
            <required>true</required>
            <rtexprvalue>true</rtexprvalue>
        </attribute>
    </tag>
< /taglib>
    3）引入标签的JSP页面的源码：
< %@ page contentType="text/html; charset=GBK"%>
< %@ taglib uri="/WEB-INF/tld/wz.tld" prefix="mytag"%>
< html>
    <body>
        <mytag:wz name="张三" age="15">
            ${name}
            ${age}
        </mytag:wz>
    </body>
< /html>
注：编译后的类文件放到WEB-INF/classes目录下，描述文件tld放到WEB-INF/tld目录下（似乎哪个目录下都行，也可直接放到WEB-INF目录下，因为有uri引用吧），tag文件保存到web应用的WEB-INF/tags目录下。
    4）对wz.tld文件的解释：
    tlib-version：是必须的元素，指定标记库函数的版本号。
    short-name：为标记库指定一个缩略名称，用它可以作为标记库的默认名字空间。
    info：用来描述标记的文档信息，默认值为空。
    uri：用来指定连接到标记的附加源文件，即tld的公共可用副本。
    tag：是标记描述文件中最重要的一个元素，有6个子元素：name、tagclass、teiclass、bodycontent、info、attribute。
            name：用户指定的标记名称。
            tag-class：指定标记处理类，写全名，即带包的类。
            bodycontent：说明标记体的类型，分为4种：empty、jsp、scriptless、tagdependent。
                        empty：表示没有标记体。
                        jsp：表示标记体可以为jsp代码。
                        scriptless：表示标记中不能用jsp脚本。
                        tagdependent：表示标签中的内容交给标记处理程序去进行处理。
            info：记录标记的描述信息。
            attribute：用来指定零个或者多个标记属性，有三个子元素：name、required、rtextprvalue。
                        name：必须设定，用来表示大小写敏感属性名称。
                        required：必须设定，标示属性是否一定要存在，默认为flase，即在标记处理程序中不会自动调用属性
                                                    的setAttribue方法。
                        rtextprvalue：用来说明属性是否可以是动态生成的，但设定为true时，属性即可以是一个常量值，也可
                                                    以由表达式生成。
3、标签文件，是JSP2.0新增的功能，目的是让JSP网页开发人员能够直接使用JSP语法来制作标签，而无须了解java语言。其扩展名都是.tag或.tagx。假如Tag File包含其他完整的或片段的Tag File，JSP2.0规范建议扩展名为.tagf。
    1）Tag File的7个隐式对象：request、response、out、jspContext、session、application、config。
    2）Tag File的指令：
                tag        如同JSP网页的page指令。
                taglib    如同JSP网页的taglib指令。
                include 如同JSP网页的include指令。
                attribute 用来设定自定义标签的属性。
                variable 用来设TagFile的变量，此变量可回传至JSP网页。
    3）新增的几个动作：
                <jsp:attribute>标签：用来指定自定义标签属性块，必要时可以作为代码段输出。
                <jsp:doBody>标签：告诉容器去处理body，并且将处理结果添加到response中，可以有选择地使用"var"属性，捕获处理的结果，并在下一步进行处理。
                <jsp:invoke>标签：对作为属性传递的特定参数进行操作。
    4）开发并使用一个日期标签：datetag.tag与datetag.jsp
    datetag.tag的代码如下：
< %@tag pageEncoding="GBK"%>
< %@tag import="java.util.*,java.text.*"%>
< %@variable name-given="fulldate" scope="AT_BEGIN"%>
< %
DateFormat fullformate = DateFormat.getDateInstance(DateFormat.FULL);
Date now = new Date();
jspContext.setAttribute("fulldate", fullformate.format(now));
%>
< jsp:doBody/>
    datetag.jsp的代码如下：
< %@ page contentType="text/html; charset=GBK"%>
< %@ taglib prefix="mytag" tagdir="/WEB-INF/tags/"%>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>

< html>
    <body>
        <h1>
            日期tag标签文件演示
        </h1>
        <mytag:datetag>
              标签体的输出:${fulldate}<br>
        </mytag:datetag>
        页面的输出:${fulldate}
    </body>
< /html>
    5）开发并使用一个求和标签：sumtag.tag与sumtag.jsp
    sumtag.tag的代码如下：
< %@tag pageEncoding="GBK"%>
< %@attribute name="items" required="true" rtexprvalue="true"%>
< %@attribute name="great" fragment="true"%>
< %@attribute name="less" fragment="true"%>
< %@taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
< %@variable name-given="sum" variable-class="java.lang.Object"%>
< c:if test="${not empty items}">
    <c:forEach items="${items}" var="item">
        <c:set var="sum" value="${item+sum}" />
    </c:forEach>

    <c:if test="${sum>=1000}">
        <jsp:invoke fragment="great" />
    </c:if>

    <c:if test="${sum<1000}">
        <jsp:invoke fragment="less" />
    </c:if>
< /c:if>
    sumtag.jsp的代码如下：
< %@ page contentType="text/html; charset=GBK"%>
< %@ taglib prefix="mytag" tagdir="/WEB-INF/tags/"%>
< %@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
< html>
    <body>
        <mytag:sumtag items="111,222,333">
            <jsp:attribute name="great">
                <font color="red"> SUM: ${sum}</font>
            </jsp:attribute>
            <jsp:attribute name="less">
                <font color="blue"> SUM: ${sum}</font>
            </jsp:attribute>
        </mytag:sumtag>
    </body>
< /html>
注：tag文件保存到web应用的WEB-INF/tags目录下。
4、JSP标记与JavaBean有何区别？
    答：JavaBean存在先天的不足，它只是可复用组件，独立于运行环境而包装了一些数据和业务逻辑功能，无法获得运行环境信息，无法与JSP页面进行更加深层次的交互。自定义标记机制解决了它的这种的缺陷，标记库的处理类不但具有JavaBean的功能，而且可以把JSP的环境住处传到类中间，不但能得到JSP传递过来的属性，还能与JSP共用页面环境，JSP页面中可以通过session、page与标记处理程序进行数据通信，这一点是 javaBean所不能实现的。