标准标签库（JSTL）
JSP1.2规范开始
JSTL的组成
完整的JSTL应包含Sun公司提供的jstl.jar包和Web容器商提供的JSTL实现包，以 Apache 小组提供的JSTL实现包为例，完整的JSTL包含 jstl.jar、standard.jar和xalan.jar三个jar包。Sun将jstl.jar封装了JSTL所要求的一些API接口类，Apache小组编写的JSTL API实现类封装在standard.jar包中。由于在JDK1.5才引入了XPath API，所以Apache小组在JSTL中使用的是他们自己开发的XPath API，这些API封装在xalan.jar包中。
要在JSP文件中使用JSTL，首先就需要使用taglib指令导入所需要使用的JSTL标签库， taglib指令的uri属性必须为相应标签库的TLD文件中的<uri>元素的值，taglib指令的prefix属性可以自己随意指定，但最好是采用上表中的建议前缀。
核心标签库
将内容输出到pageContext对象当前保存的“out”对象中。会自动对HTML特殊字符进行转义，如 <、>、'、"、&等，默认将它们分别转义成了<、>、&、'、"
1、没有标签体：
<c:out value="value" [escapeXml="{true|false}"] [default="defaultValue"] />
2、有标签体时，在标签体中指定输出的默认值：
<c:out value="value" [escapeXml="{true|false}"] >
default Value
</c:out>
如果没有指定默认值，则默认为空字符串。如果value属性的值不为null，即使标签体部分不为空，标签体的内容也不会被输出。
如果value属性不是指向一个java.io.Reader对象，<c:out>标签将调用这个对象的toString()方法，然后输出获得的字符串内容。如果value属性指向一个java.io.Reader对象，<c:out>标签将从这个Reader对象中读取数据后进行输出。
设置各种Web域中的属性，或者设置Web域中的java.util.Map类型的属性对象或JavaBean类型属性对象的属性。
1、 使用value属性设置指定域中的某个属性的值：
<c:set value="value" var="varName" [scope="{page|request|session|application}"] />
2、 在标签体中设置指定域中的某个属性的值：
<c:set var="varName" [scope="{page|request|session|application}"] >
body content
</c:set>
3、 使用value属性设置Web域中的一个属性对象的某个属性：
<c:set value="value" target="target" property="propertyName" />
4、 在标签体中设置Web域中的一个属性对象的某个属性：
<c:set target="target" property="propertyName" >
body content
</c:set>
如果使用第1种语法格式时的value属性值为null，或者使用第2种语法格式时的标签体内容为空，将从scope属性指定的域范围中删除var属性指定的属性。
在第3种语法格式和第4语法格式中，如果target属性的值是java.util.Map对象，property属性表示该map对象的关键字，如果Map对象没有指定的关键字，就给Map对象增加指定的关键字；如果target属性的值是JavaBean对象，property属性表示JavaBean对象的属性，如果value的类型与JavaBean属性的类型不匹配时，会根据EL的转换规则自动进行转换。当使用第3种语法格式或第4种语法格式时，如果target属性的值为null（即target属性指定的对象不存在），或者target属性的值是一个JavaBean对象，但该JavaBean中不存在property属性指定的属性，<c:set>标签将抛出异常。如果使用第3种语法格式时value属性的值为null，或者使用第4种语法格式时标签体的内容为空，如果target属性的值是一个java.util.Map对象，就从Map对象中删除property属性指定的关键字对应的项；如果target属性的值是一个JavaBewn对象，就将JavaBean的相应属性的值设置为null。
用于删除各种Web域中的属性：
<c:remove var="varName" [scope="{page|request|session|application}"] />
与上表一样，var与scope都不支持动态值，即EL表达式。<c:remove>与<c:set>标签第一种语法格式的value属性值为null时的作用相同。
用于捕获嵌套在标签体中的内容抛出的异常。
<c:catch [var="varName"]>
nested actions
</c:catch>
var属性用于标识<c:catch>标签捕获的异常对象，其值是一个静态的字符串，不支持态属性值。<c:catch>标签将捕获的异常对象以var指定的名称保存到page这个Web域中，如果没有指定var属性，则<c:catch>标签仅捕获异常，不在page域保存异常对象。如果<c:catch>标签体中的内容没有抛出异常，标签将从page域中删除var属性指定的属性。
<c:catch>标签可以捕获任何标签抛出的异常，并且可以同时处理多个标签抛出的异常，这样,可以对JSP页面的异常进行统一处理，显示给用户一个更友好的页面。JSP 处理异常的通用机制是出现重要异常后跳转到错误处理页面，建议尽量不要用<c:catch>标签来代替JSP的错误处理机制，只对一些次要异常才使用。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=gb2312" %>
<c:catch var="myex">
<%
int i = 0;
int j = 10;
out.println(j + "/" + i + "=" + j/i);
%>
</c:catch>
异常：<c:out value="${myex}" /><br />
异常 myex.getMessage：<c:out value="${myex.message}" /><br />
异常 myex.getCause：<c:out value="${myex.cause}" /><br />
异常 myex.getStackTrace：<c:out value="${myex.stackTrace}" />
可以构造简单的“if-then”结构的条件表达式。
1、 没有标签体的情况
<c:if test="testcondition" var="varName" [scope="{page|request|session|application}"] />
2、 有标签体的情况，在标签体中指定要执行的内容：
<c:if test="testcondition" [var="varName"] [scope="{page|request|session|application}"] >
body content
</c:if>
对于语法2，如果指定了<c:if>标签的scope属性，则必须指定var属性。
<c:if test="${user.visitCount == 1}">
这是您第一次访问本网站，欢迎您！
</c:if>
<c:choose>标签用于指定多个条件选择的组合边界，它必须与<c:when>和<c:otherwise>标签一起使用。使用<c:choose>, <c:when>和<c:otherwise>三个标签，可以构造类似“if-else if-else”的复杂条件判断结构。
<c:choose>标签没有属性，在它的标签体内只能嵌套一个或多个<c:when>标签和0个或一个<c:otherwise>标签，并且同一个<c:choose>标签中的所有<c:when>子标签必须出现在<c:otherwise>子标签之前。如果<c:choose>标签内嵌套一个<c:when>标签和<c:otherwis>标签，就相当于“if-else”的条件判断结构；如果<c:choose>标签内嵌套多个<c:when>标签和一个<c:otherwise>标签，就相当于“if-else if-else”标签。
<c:when>标签只有一个test属性，该属性的值为布尔类型。test属性支持动态值，其值可以是一个条件表达式，如果条件表达式的值为true，就执行这个<c:when>标签体的内容。<c:when>标签体的内容可以是任意的JSP代码。<c:othetwise>标签没有属性，它必须作为<c:choose>标签的最后分支出现。当JSP页面中使用<c:choose>标签时，嵌套在<c:choose>标签内的test条件成立的第一个<c:when>标签的标签体内容将被执行和输出。当且仅当所有的<c:when>标签的test条件都不成立时，才执行和输出<c:otherwise>标签的标签体内容。如果所有的<c:when>标签的test条件都不成立，并且<c:choose>标签内没有嵌套<c:otherwise>标签，则9不执行任何操作。
<c:choose>
<c:when test="${param.count == 0}">
对不起，没有符合您要求的记录。
</c:when>
<c:otherwise>
符合您要求的记录共有${count}条.
</c:otherwise>
</c:choose>
用于对一个集合对象中的元素进行循环迭代操作，或按指定的次数重复迭代执行标签体中的内容。
1、 在集合对象中迭代
<c:forEach [var="varName"]
items="collection"
[varStatus="varStatusName"]
[begin="begin"] [end="end"] [step="step"]>
body content
</c:forEach>
2、 迭代固定的次数：
<c:forEach [var="varName"]
[varStatus="varStatusName"]
begin="begin" end="end" [step="step"]>
body content
</c:forEach>
如果items属性的值为null，则要处理的集合对象为空，这时不执行迭代操作；
<c:forEach>标签的items属性的值支持下面的数据类型：
l 任意类型的数组
l java.util.Collection
l java.util.Iterator
l java.util.Enumeration
l java.util..Map
l java.lang.String
还支持与数据库有关的数据类型java.sql.ResultSet（包括javax.sql.RowSet）
1) 迭代Collection类型的集合对象
<%
Collection users = new ArrayList();
for(int i=0; i<6; i++)
{
UserBean user = new UserBean();
user.setUserName("user" + i);
user.setPassword("guess" + i);
users.add(user);
}
session.setAttribute("users", users);
%>
<c:forEach var="user" items="${users}" end="5" step="2">
<tr>
<td>${user.userName}</td><td>${user.password}</td>
</tr>
</c:forEach>
2) 迭代Map对象
使用<c:forEach>标签迭代Map类型的集合对象时，迭代出的每个元素的类型为Map.Entry。
由于EL中的requestScope隐含对象就是代表request作用域中的所有属性的Map对象，所以我们可以使用<c:forEach>标签迭代输出EL中的requestScope隐含对象中的所有元素。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%
request.setAttribute("attr1","value1");
request.setAttribute("attr2","value2");
%>
<c:forEach var="entry" items="${requestScope}">
<tr><td>${entry.key}</td><td>${entry.value}</td></tr>
</c:forEach>
3) 迭代指定的次数
<c:forEach var="i" begin="11" end="16" step="2">
${i}
</c:forEach>
4) 获取迭代的状态信息
<c:forEach>标签可以将代表当前迭代状态信息的对象保存到page域中，varStatus属性指定了这个对象保存在page域中的属性名称。代表当前状态信息的对象的类型为javax.servlet.jsp.jstl.core.LoopTagStatus，其中定义了如下一些方法：
public java.lang.Integer getBegin()
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<table border="1">
<tr><td>数值</td><td>index</td><td>count</td>
<td>first?</td><td>last?</td></tr>
<c:forEach var="i" varStatus="sta" begin="101" end="103">
<tr>
<td>${i}</td><td>${sta.index}</td><td>${sta.count}</td>
<td>${sta.first}</td><td>${sta.last}</td>
</tr>
</c:forEach>
</table>
<c:forTokens>专门用于实现类似java.util.StringTokenizer类的迭代功能，但它是以单个字符作为分隔符，同时可以指定多个字符作为多个并行的分隔符：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=gb2312" %>
使用"|"和","作为分隔符<br />
<c:forTokens var="token" items="spring,summer|||autumn,winter" delims="|," end="2">
${token}©
</c:forTokens><br />
<c:import>
<c:url>
<c:redirect>
<c:param>
在讲解上面某些标签时，要引用另一个JSP文件，这里先创建好这个JSP文件：
===============register.jsp===============
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
<%@ page contentType="text/html;charset=gb2312" %>
<%
String name = request.getParameter("name");
name = new String(name.getBytes("iso-8859-1"),"gb2312");
session.setAttribute("name",name);
String country = request.getParameter("country");
country = new String(country.getBytes("iso-8859-1"),"gb2312");
session.setAttribute("country",country);
%>
name=${name};
country=${country}<br/>
l <c:param>标签
在JSP页面进行URL的相关操作时，经常要在URL地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内，为这些标签所使用的URL地址附加参数。 <c:param>标签在为一个URL地址附加参数时，将自动对参数值进行URL编码，例如，如果传递的参数值为“中国”，则将其转换为“%d6%d0%b9%fa”后再附加到URL地址后面。
1、 使用value属性指定参数值：
<c:param name="name" value="value" />
2、 在标签体中指定参数的值
<c:param name="name">
parameter value
</c:parma>
l <c:url>标签
<c:url>标签用于在JSP页面中构造一个URL地址，其主要目的是实现URL重写。URL重写就是将会话标识号以参数形式附加在URL地址后面。
1、 没有标签体的情况：
<c:url value="value"
[context="context"]
[var="varName"]
[scope="{page|request|session|application}"]/>
2、 有标签体的情况，在标签体中指定构造的URL的参数：
<c:url value="value"
[context="context"]
[var="varName"]
[scope="{page|request|session|application}"]>
<c:param>标签
</c:url>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=gb2312" %>
使用绝对路径构造URL:
<c:url value="http://localhost:8080/myapp/register.jsp" var="myUrl1">
<c:param name="name" value="张三" />
<c:param name="country" value="${param.country}" />
</c:url>
<a href="${myUrl1}">Register1</a><hr />
使用相对当前JSP页面的路径构造URL:
<c:url value="register.jsp?name=wangwu&country=France" var="myUrl2" />
<a href="${myUrl2}">Register2</a><hr/>
使用相对当前WEB应用的路径构造URL:
<c:url value="/register.jsp?name=zhaoliu&country=England" var="myUrl3" />
<a href="${myUrl3}">Register3</a>
页面输出结果：
使用绝对路径构造URL:
<a href="http://localhost:8080/myapp/register.jsp?name=%d5%c5%c8%fd&country=">Register1</a><hr/>
使用相对当前JSP页面的路径构造URL:
<a href="register.jsp?name=王五&country=France">Register2</a><hr/>
使用相对当前WEB应用的路径构造URL:
<a href="/myapp/register.jsp?name=zhaoliu&country=England">Register3</a>
l <c:import>标签
用于在JSP页面中导入一个URL地址指向的资源内容，其作用有点类似<jsp:include>这个JSP标准标签，但功能更强大。
1、 将URL地址指向的资源内容以字符串形式输出或以字符串形式保存到一个变量中：
<c:import url="url"
[context="context"]
[var="varName"]
[scope="{page|request|session|application}"]
[charEncoding="charEncoding"]>
optional body content for <c:param> subtags
</c:import>
2、 将URL地址指向的资源内容保存到一个Reader对象中：
<c:import url="url"
[context="context"]
varReader="varReaderName"
[charEncoding="charEncoding"]>
body content where varReader is consumed by another action
</c:import>
使用第1种语法格式时，如果指定了var属性，导入的资源内容以字符串形式保存到一个变量，如果没有指定var属性，则直接输出。第1种还可以嵌套<c:param>标称来给导入的资源传递参数。
第2种语法中，varReader属性指定的变量只在标签内有效，因为在标签结事时将关闭Reader对象对应的输入流。此种语法中，标签体内中应该只能嵌套调用varReader属性指定的reader对象的其他标签。不能嵌套<c:param>标签，如果要给导入的资源传递参数，则必须在url属性值中设置好这些参数，这时可以使用<c:url>标签来创建一个带参数的URL地址，此时如果有必要，<c:import>标签将删除导入资源中的所有URL重写后产生的session id信息。
1、 使用相对URL导入其他资源文件
l 当被导入的外部资源文件与当前JSP文件属于同一个Web应用程序时，处理与<jsp:include>标签相同，这时路径可以以“/”字符开始，也可以以文件名或目录名开始。
l 当被导入的外部资源文件与当前JSP文件属于同一个服务器下的不同Web应用程序时，如果要使用相对路径，则路径必须以“/”开始，此时，<c:import>标签的context属性必须被设置被导入的资源文件所在的Web应用程序的名称。注意，从一个Web应用中通相对路径（以“/”开头的也叫相对，而不是以http开头）访问同一服务器下另一Web应用资源时，必须在 confserver.xml配置文件中将使用<c:import>标签的Web应用程序的<Context>元素的crossContext属性设置为true，如：
<Context path= "/JSTL" docBase= "JSTL" crossContext= "true" />
2、 使用绝对URL导入其他资源文件
使用绝对路径（以 http 开头的访问方式称绝对路径，注，以“/”开头的访问还是叫相对访问）导入外部资源文件时，即使被导入的文件与当前JSP文件属于同一个Web应用程序，被导入的资源文件不会共享当前JSP页面的request和session对象，这与上面使用相对URL导入同一Web应用中的资源是不一样的。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=gb2312" %>
使用相对路径导入同一个WEB应用中的资源:<br />
<c:import url="/register.jsp?name=zhangsan">
<c:param name="name" value="zxx" />
</c:import><hr />
使用相对路径导入同一个服务器下的不同WEB应用中的资源:<br />
<c:import url="/hello.jsp" context="/EL" /><hr />
使用绝对路径导入资源示例1:
<c:import url="http://localhost:8080/EL/hello.jsp" /><hr />
使用绝对路径导入资源示例2:
<c:import url="http://localhost:8080/JSTL/register.jsp" var="myImport"
charEncoding="gb2312">
<c:param name="name" value="${param.name}" />
<c:param name="country" value="中国" />
</c:import>
${myImport}
在浏览器中输出：http://localhost:8080/JSTL/c_import.jsp?name=zxx&country=China
l <c:redirect>标签
用于执行response.sendRedirect()方法的功能，将当前访问请求重定向到其他资源。
1、 没有标签体的情况：
<c:redirect url="value" [context="context"] />
2、 有标签体的情况，在标签体中指定重定向时的参数：
<c:redirect url="value" [context="context"] >
<c:para>subtags
</c:redirect>
url属性可以使用相对路径和绝对路径，具体细节与<c:import>标签的url属性相同。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=gb2312" %>
<c:url value="http://localhost:8080/JSTL/URL/register.jsp" var="myUrl">
<c:param name="name" value="张三" />
<c:param name="country" value="中国" />
</c:url>
<c:redirect url="${myUrl}" />
输出：name=张三; county=中国
国际化标签
这组标签封装了java.util和java.text这两个包中与国际化相关的API类的功能。
=============greetings.properties=================
org.it315.heading=The first WEB application
org.it315.welcome=Welcome to www.it315.org !
org.it315.okKey=Today is {0,date,full}, you have {1,number,currency} dollars.
=============greetings_zh.properties=================
org.it315.heading=第一个WEB应用程序
org.it315.welcome=欢迎访问www.it315.org网站!
org.it315.okKey=今天是{0,date,full}，你有{1,number,currency}元。
用于在JSP页面中地设置用户的本地化信息，并将设置的本地化信息以Local对象的形式保存在某个Web域中，他在Web域中的属性名称为“javax.servlet.jsp.jstl.local”。使用他设置本地化信息后，国际化标签库中的其他标签将使用该本地化信息，而忽略客户端浏览器传递过来的本地信息。
<fmt:setLocale value= "locale"
[variant= "variant"]
[scope="{page|request|session|application}"] />
如果value属性值为Null，标签将采用客户端传递过来的本地信息。
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
<fmt:setLocale value="${param.locale}" />
<fmt:setBundle basename="org.it315.greetings" var="greetings" />
<head>
<title><fmt:message bundle="${greetings}" key="org.it315.heading" /></title>
</head>
<jsp:useBean id="now" class="java.util.Date" />
<%
session.setAttribute("number", new Integer(8888888));
%>
<fmt:message bundle="${greetings}" key="org.it315.welcome" /><br />
<fmt:message bundle="${greetings}" key="org.it315.okKey">
<fmt:param value="${now}" />
<fmt:param value="${number}" />
</fmt:message>
地址栏中输出：http://localhost:8080/myapp/fmt_setLocale.jsp?locale=en_US
http://localhost:8080/myapp/fmt_setLocale.jsp?locale=zh_CN
根据<fmt:setLocale>标签设置的本地化信息创建一个资源包（ResourceBundle）实例对象，并将其绑定到一个Web域属性上：
<fmt:setBundle basename= "basename"
[var= "varname"]
[scope="{page|request|session|application}"] />
（1）如果basename属性的值为null或空字符串，或找不到basename属性指定的资源，<fmt:setBundle>标签保存到Web域中的属性的值为null。
（2）如果指定了var属性，<fmt:setBundle>标签将把ResourceBundle实例对象以var属性的值作为域属性名称保存到Web域中。
（3）如果没有指定var属性，<fmt:setBundle>标签将把ResourceBundle实例对象以域属性名javax.servlet.jsp.jstl.fmt.localizationContext保存到Web域中。所有没有嵌套在<fmt:bundle>标签中且未指定bundle属性的<fmt:formatDate>都将使用该标签创建的资源包。
与<fmt:setBundle>标签功能类似，但它创建的ResourceBundle实例对象只在其标签体内有效：
<fmt:bundle basename="basename"
[prefix="prefix"]>
Body content
</fmt:bundle>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
没有设置prefix属性的情况:<br />
<fmt:bundle basename="org.it315.greetings">
<fmt:message key="org.it315.heading" /><br />
<fmt:message key="org.it315.welcome" /><br /><hr />
</fmt:bundle>
设置prefix属性的情况:<br />
<fmt:bundle basename="org.it315.greetings" prefix="org.it315.">
<fmt:message key="heading" /><br />
<fmt:message key="welcome" />
</fmt:bundle>
1、没有标签体的情况：
<fmt:message key="messageKey"
[bundle="resourceBundle"]
[var="varName"]
[scope="{page|request|session|application}"] />
2、在标签体中指定格式化文本串中的占位符参数的情况：
<fmt:message key="messageKey"
[bundle="resourceBundle"]
[var="varName"]
[scope="{page|request|session|application}"] >
<fmt:param>subtags
</fmt:message>
3、在标签体中指定消息关键字和可选择的占位符参数：
<fmt:message [bundle="resourceBundle"]
[var="varName"]
[scope="{page|request|session|application}"] >
key
optional <fmt:param>subtags
</fmt:message>
如果没有指定var属性，<fmt:message>标签将直接输出格式化的结果；如果指定了var属性，则<fmt:message>标签将格式化的结果保存在scope属性指定的Web域中，保存在Web域中的属性名称为var属性指定的值。如果指定了scope属性，就必须指定var属性。
要输出的消息的关键字可以使用key属性指定，也可以在标签体中指定。如果<fmt:message>标签嵌套在<fmt:bundle>标签内，并且<fmt:bundle>标签设置了prefix属性，则该属性的值追加到<fmt:message>标签指定的关键字的前面。
可以通过在<fmt:message>标签内嵌套<fmt:param>标签来指定格式化文本串中的占位符的参数值，每个<fmt:param>标签分别设置一个参数，各个<fmt:param>标签的顺序与格式化字符串的参数相对应。如果对应的占位参数没有设置<fmt:param>标签，则输出原始形式。
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
<jsp:useBean id="now" class="java.util.Date" />
<%
session.setAttribute("number", new Integer(8888888));
%>
<fmt:setBundle basename="org.it315.greetings" var="greetings" />
<fmt:message>标签内嵌套<fmt:param>标签的情况：<br />
<fmt:message bundle="${greetings}">
org.it315.okKey
<fmt:param value="${now}"/>
<fmt:param value="${number}"/>
</fmt:message><br/><hr/>
<fmt:message>标签内没有嵌套<fmt:param>标签的情况，这里的占位参数会原样输出：<br />
<fmt:bundle basename="org.it315.greetings" prefix="org.it315.">
<fmt:message key="okKey"/>
</fmt:bundle>
用于为格式化文本串中的占位符设置参数值，它只能嵌套在<fmt:parma>标签中使用：
1、 用value属性指定参数值：
<fmt:param value="messageParameter"/>
2、 在标签体中指定参数的值的情况：
<fmt:param>
body content
</fmt:param>
value属性值支持动态属性，为Object类型。
设置请求消息的字符集编码，内部调用request.setCharacterEncoding()方法，将参数值按该编码转换成Unicode字符串返回。必须在获取任何请求参数之前使用。
<fmt:requestEncoding [value="charsetName"]
value属性用于指定请求消息的字符集编码，类型为String，支持动态属性。
如果没有设置 value 属性，标签首先采用请求消息Content-Type头中定义的字符集编码，如果不能从请求消息的Content-Type头中确定字符集编码，则采用session域中的javax.servlet.jsp.jstl.fmt.request.charset属性的值，否则采用ISO-8859-1字符编码。
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
<fmt:requestEncoding value="gb2312" />
我最喜欢的科目是:${param.favourite}<br />
<form method="POST">
你最喜欢学习的是什么科目?<br />
<input type="text" name="favourite" />
<input type="submit" value="OK" /><br/>
</form>
设置时区，但它的设置值只对其标签体部分有效。
<fmt:timeZone value="timeZone">
body content
</fmt:timeZone>
value属性支持动态属性，可以是一个命名时区的字符，也可是java.util.TimeZone类的一个实例对象。如果value为null或空字符串，标签体中的内容就使用GMT的0基准时区，如果使用的是表示时区名称的字符串，这个字符串通过java.util.TimeZone.getTimeZone()静态方法被解析为java.util.TimeZone类的实例对象。
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
<%@ page import="java.util.TimeZone" %>
<jsp:useBean id="now" class="java.util.Date" />
“GMT+1:00”时区：<br />
<fmt:timeZone value="GMT+1:00">
<fmt:formatDate value="${now}" type="both" dateStyle="full" timeStyle="full"/>
</fmt:timeZone><br /><hr />
<%
TimeZone tz = TimeZone.getDefault();
pageContext.setAttribute("tz", tz);
%>
默认的时区，value为java.util.TimeZone的一个实例：<br />
<fmt:timeZone value="${tz}">
<fmt:formatDate value="${now}" type="both" dateStyle="full" timeStyle="full"/>
</fmt:timeZone><br /><hr />
“America/Los_Angeles”时区：<br />
<fmt:timeZone value="America/Los_Angeles">
<fmt:formatDate value="${now}" type="both" dateStyle="full" timeStyle="full"/>
</fmt:timeZone>
输出：
“GMT+1:00”时区：
2010年8月14日 星期六 下午02时58分16秒 GMT+01:00
默认的时区，value为java.util.TimeZone的一个实例：
2010年8月14日 星期六 下午09时58分16秒 CST
“America/Los_Angeles”时区：
2010年8月14日 星期六 上午06时58分16秒 PDT
显示地设置时区，并将设置的时区信息以TimeZone对象的形式保存在某个Web域中。如果未指定var属性值，则域中属性名称为javax.servletjsp.jstl.fmt.timeZone，所有没有嵌套在其他<fmt:timeZone>标签中且未指定timezone属性的<fmt:formatDate>标签都将使用该域属性名关联的时区。
<fmt:setTimeZone value="timeZone"
[var="varname"]
[scope="{page|request|session|application}"] />
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
<jsp:useBean id="now" class="java.util.Date" />
<fmt:setTimeZone value="America/Los_Angeles"/>
“America/Los_Angeles”时区的现在时间是:<br />
<fmt:formatDate value="${now}" type="both" /><hr />
“GMT+1:00”时区的现在时间是:<br />
<fmt:timeZone value="GMT+1:00">
<fmt:formatDate value="${now}" type="both" />
</fmt:timeZone>
输出：
“America/Los_Angeles”时区的现在时间是:
2010-8-15 0:06:34
“GMT+1:00”时区的现在时间是:
2010-8-15 8:06:34
用于对日期和时间按本地化信息进行格式化，或按用户指定的格式进行格式化。
<fmt:formatDate value="date"
[type="{time|date|both}"]
[dateStyle="{default|short|medium|long|full}"]
[timeStyle="{default|short|medium|long|full}"]
[pattern="customPattern"]
[timeZone="timeZone"]
[var="varName"]
[scope="{page|request|session|application}"] />
如果没有指定var属性，则将直接输出格式化结果，否则保存在scope指定的作用域对象中。
如果value属性的值为null，则不输出任何内容，如果此时指定了var和scope属性，将scope属性指定的web域中的var属性指定域属性删除。
如果指定了pattern属性设置自定义的日期格式，这时将忽略type、dateStyle、timeStyle、等属性。pattern属性的值必须符合java.text.SimpleDateFormat类的日期模式的语法。
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
<%@ page import="java.util.TimeZone" %>
<jsp:useBean id="now" class="java.util.Date" />
格式化当前日期、时间：
<fmt:formatDate value="${now}" type="both" timeStyle="medium" dateStyle="long"/>
<hr/>
<%
session.setAttribute("tz", TimeZone.getTimeZone("GMT+10"));
%>
指定时区为“GMT+10”：
<fmt:formatDate value="${now}" type="both" timeZone="${tz}" /><hr />
指定自定义的格式，月.日.年:
<fmt:formatDate value="${now}" pattern="MM.dd.yyyy" /><hr />
格式化用字符串表示的日期：
<fmt:parseDate value="7/31/05" pattern="MM/dd/yy" var="parsed" />
<fmt:formatDate value="${parsed}" />
输出：
格式化当前日期、时间： 2010年8月15日 15:29:53
指定时区为“GMT+10”： 2010-8-15 17:29:53
指定自定义的格式，月.日.年: 08.15.2010
格式化用字符串表示的日期： 2005-7-31
与<fmt:formateDate>标签正好相反，将一个表示日期和时间的字符串解析成java.util.Date实例对象：
<fmt:parseDate value="dateString"
[type="{time|date|both}"]
[dateStyle="{default|short|medium|long|full}"]
[timeStyle="{default|short|medium|long|full}"]
[pattern="customPattern"]
[timeZone="timeZone"]
[parseLocale="parseLocale"]
[var="varName"]
[scope="{page|request|session|application}"] />
<fmt:parseDate [type="{time|date|both}"]
[dateStyle="{default|short|medium|long|full}"]
[timeStyle="{default|short|medium|long|full}"]
[pattern="customPattern"]
[timeZone="timeZone"]
[parseLocale="parseLocale"]
[var="varName"]
[scope="{page|request|session|application}"] >
date value to be parsed
<fmt:parseDate>
pattern属性的值必须符合java.text.SimpleDateFormat类的模式语法。
将数值、货币、百分数按本地化信息进行格式，或者按JSP页面作者指定的格式进行格式化。
<fmt:formatNumber value="numericValue"
[type="{number|currency|percent}"]
[pattern="customPattern"]
[currencyCode="currencyCode"]
[currencySymbol="currencySymbol"]
[groupingUsed="{true|false}"]
[maxIntegerDigits="maxIntegerDigits"]
[minIntegerDigits="minIntegerDigits"]
[maxFractionDigits="maxFractionDigits"]
[minFractionDigits="minFractionDigits"]
[var="varName"]
[scope="{page|request|session|application}"] />
<fmt:formatNumber [type="{number|currency|percent}"]
[pattern="customPattern"]
[currencyCode="currencyCode"]
[currencySymbol="currencySymbol"]
[groupingUsed="{true|false}"]
[maxIntegerDigits="maxIntegerDigits"]
[minIntegerDigits="minIntegerDigits"]
[maxFractionDigits="maxFractionDigits"]
[minFractionDigits="minFractionDigits"]
[var="varName"]
[scope="{page|request|session|application}"] >
要被格式化的数值
</fmt:formatNumber>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
<%@ page import="java.util.Currency,java.util.Locale"%>
将数值格式化为货币格式：
<fmt:formatNumber value="9876543.21" type="currency" /><hr />
将数值格式化为百分数格式：
<fmt:formatNumber value="12.3" type="percent" /><hr />
将数值格式化为自定义的格式：
<fmt:formatNumber value="12.3" pattern=".000" />；
<fmt:formatNumber value="123456.7891" pattern="#,#00.0#" /><hr />
<%
String code = Currency.getInstance(Locale.CHINA).getCurrencyCode();
String symbol = Currency.getInstance(Locale.US).getSymbol();
session.setAttribute("code", code);
session.setAttribute("symbol", symbol);
%>
同时指定currencyCode和currencySymbol属性，前者优先于后者：
<fmt:formatNumber value="1234567.11" type="currency" currencyCode="${code}"
currencySymbol="${symbol}" />
将数值格式化为货币格式： ￥9,876,543.21
将数值格式化为百分数格式： 1,230%
将数值格式化为自定义的格式： 12.300； 123,456.79
同时指定currencyCode和currencySymbol属性，前者优先于后者： ￥1,234,
与<fmt:formatNumber>正好相反，用于将一个按本地化方式被格式化后的数值、货币、或百分数解析为数值。
<fmt:parseNumber value="numericValue"
[type="{number|currency|percent}"]
[pattern="customPattern"]
[parseLocale="parseLocale"]
[integerOnly="{true|false}"]
[var="varName"]
[scope="{page|request|session|application}"] />
<fmt:parseNumber value="numericValue"
[type="{number|currency|percent}"]
[pattern="customPattern"]
[parseLocale="parseLocale"]
[integerOnly="{true|false}"]
[var="varName"]
[scope="{page|request|session|application}"] >
numeric value to be parsed
</fmt:parseNumber>
integerOnly：指定是否只解析数值字符串的整数部分
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ page contentType="text/html;charset=gb2312" %>
本地环境为“en_US”解析字符串“$123,456,789.00”：
<fmt:parseNumber value="$123,456,789.00" type="currency" parseLocale="en_US"/>
<hr/>
解析整个数值字符串“123,456,789%”：
<fmt:parseNumber value="123,456,789%" type="percent" /><hr />
只解析“123,456,789%”的整数部分：
<fmt:parseNumber value="123,456,789%" type="percent" integerOnly="true"/><hr />
同时设置type和pattern属性，后者优先于前者：
<fmt:parseNumber value="12.3" type="currency" pattern=".000" />
输出结果：
本地环境为“en_US”解析字符串“$123,456,789.00”： 123456789
解析整个数值字符串“123,456,789%”： 1234567.89
只解析“123,456,789%”的整数部分： 1234567
同时设置type和pattern属性，后者优先于前者： 12.3
数据库签库
--创建数据库
create database it315
--创建users表和account表
use it315
if object_id('users') is not null drop table users
create table users
(
id int identity primary key,
name varchar(10) not null,
birthday datetime,
address varchar(40)
)
if object_id('account') is not null drop table account
create table account
(
id int identity primary key,
name varchar(10) not null,
balance int
)
--向表中添加数据
insert into users values('zhangsan','1980-4-1','Beijing')
insert into users values('lisi','1977-9-10','Shanghai')
insert into users values('wangwu','1980-12-3','Shenzhen')
insert into users values('zhaoliu','1979-8-8','Xiamen')
insert into users values('sunqi','1978-4-9','Fuzhou')
insert into users values('qian','1977-7-7','Tianjin')
insert into users values('zhou','1974-9-9','Shanghai')
insert into users values('zheng','1975-6-1','Beijing')
insert into users values('fang','1976-1-1','Beijing')
insert into users values('lufang','1982-6-2','Chengdu')
insert into account values('zhangsan',20000)
insert into account values('lisi',50000)
设置数据源，并保存在指定的域中属性变量中，或者以javax.servlet.jsp.jstl.sql.dataSource属性名进行保存。
<sql:setDataSource
{dataSource="dataSource" | url="jdbcUrl"
[driver="driverClassName"]
[user="userName"]
[password="password"]}
[var="varName"]
[scope="{page|request|session|application}"] />
dataSource：可以是一个字符串或javax.sql.DataSource实例对象，如果是字符串，则表示JNDI数据源的名称；如果是DataSource实例对象，表示可获得的数据源对象。
如果在dataSource属性中指定的是JNDI数据源的名称，那么必须事先在服务器中配置好JNDI数据源。下面是在Tomcat中配置JNDI数据源，修改相应的<Context>元素：
<Context path="/JSTL" docBase="JSTL" crossContext="true" debug="0"
reloadable="true">
<Resource name="jdbc/testSQL" auth="Container" type="javax.sql.DataSource"
driverClassName="com.microsoft.jdbc.sqlserver.SQLServerDriver"
url="jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=it315"
username="sa" password="green" mazActive="100" maxIdle="30"
maxWait="10000"/>
</Context>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@ page contentType="text/html;charset=gb2312" %>
<!--使用JNDI数据源-->
<sql:setDataSource dataSource="jdbc/testSQL" var="JNDIDataSource" />
<!--使用普通方式创建数据源-->
<sql:setDataSource
url="jdbc:microsoft:sqlserver://127.0.0.1:1433;DatabaseName=it315"
driver="com.microsoft.jdbc.sqlserver.SQLServerDriver" user="sa" password="green" var="myDataSource1" />
1、 没有标签体
<sql:query sql="sqlQuery"
var="varName"
[scope="{page|request|session|application}"]
[dataSource="dataSource"]
[maxRows="maxRows"]
[startRow=" startRow "]/>
2、 在标签体中指定查询语句的参数值
<sql:query sql="sqlQuery"
var="varName"
[scope="{page|request|session|application}"]
[dataSource="dataSource"]
[maxRows="maxRows"]
[startRow=" startRow "]>
<sql:param> actions
</sql:query>
3、 在标签体中指定查询语句和查询语句的参数值
<sql:query var="varName"
[scope="{page|request|session|application}"]
[dataSource="dataSource"]
[maxRows="maxRows"]
[startRow=" startRow "]>
query
optional <sql:param> actions
</sql:query>
如果指定dataSource属性，<sql:query>标签就不能嵌套在<sql:transaction>标签内；同样地，如果<sql:query>标签嵌套在<sql:transaction>标签内，就不能指定dataSource属性，这时从其父标鉴<sql:transaction>获得数据源。
如果指定maxRows属性，其值必须大于或等于-l（表示返回所有）。
SQL查询语句中可以包含参数占位符“？”，参数的值通过嵌套在<sql:query>标签内的参数标签提供，例如<sql:param>。
返回的结果对象的类型为 javax.servlet.jsp.jstl.sql.Result：
public String[] getColumnNames()：返回结果集中的所有列名。
public int getRowCount()：返回结果集中的行数。
public SortedMap[] getRows()：返回结果集中的所有和地，每行分别以一个SortedMap对象表示，SortedMap对象中的每个关键字分别为各列的名称，每个关键字对应的值其对应的列的值。
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=gb2312" %>
<sql:setDataSource dataSource="jdbc/testSQL" var=" myDataSource" />
按“birthday”字段倒序从users表中查询年龄大于23的记录，从第二条记录开始显示5
条记录
<sql:query var="users" dataSource="${myDataSource}" maxRows="5" startRow="2">
select * from users where datediff(yyyy,birthday,getdate()) > ? order by
birthday desc
<sql:param>23</sql:param>
</sql:query>
<table border="1">
<tr><td>name</td><td>birthday</td><td>address</td></tr>
<c:forEach var="row" items="${users.rows}">
<tr>
<td>${row.name}</td><td>${row.birthday}</td><td>${row.address}</td>
</tr>
</c:forEach>
</table>
可执行insert、update、delete等SQL语句，也可执行DDL操作语句。调用JDBC的Statement.executeUpdate()方法，结果为SQL更新语句影响记录的行数。
1、 没有标签体
<sql:update sql="sqlUpdate"
[dataSource="dataSource"]
[var="varName"]
[scope="{page|request|session|application}"]/>
2、 在标签体中指定更新语句的参数值
<sql:update sql="sqlUpdate"
[dataSource="dataSource"]
[var="varName"]
[scope="{page|request|session|application}"]>
<sql:param> actions
</sql:update>
3、 在标签体中指定更新语句和查询语句的参数值
<sql:update [dataSource="dataSource"]
[var="varName"]
[scope="{page|request|session|application}"]>
update statemnt
optional <sql:param> actions
</sql:update>
如果该标签嵌套在<sql:transaction>标签内，它不能指定dataSource属性。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@ page contentType="text/html;charset=gb2312" %>
<sql:setDataSource dataSource="jdbc/testSQL" var="myDataSource" />
<sql:update dataSource="${myDataSource}" var="myCreate">
if object_id('student') is not null
drop table student
create table student(
id int identity primary key,
name varchar(10) not null,
address varchar(80)
)
</sql:update>
创建student表成功！<br />
<sql:update dataSource="${myDataSource}" var="myUpdate1">
insert into student values('wangwu','Beijing')
insert into student values('nation','Shanghai')
</sql:update>
向student表中添加记录数：${myUpdate1}<br />
<sql:update dataSource="${myDataSource}" var="myUpdate2">
update student set address=? where name='wangwu'
<sql:param value="${param.addr}" />
</sql:update>
更新记录的行数为：${myUpdate2}<br />
显示student表中的内容:
<sql:query var="student" dataSource="${myDataSource}" >
select * from student
</sql:query>
<div style="text-align:center"><table border="1">
<tr><td>name</td><td>address</td></tr>
<c:forEach var="row" items="${student.rows}">
<tr><td>${row.name}</td><td>${row.address}</td></tr>
</c:forEach>
</table></div>
用于声明事务处理的边界。
<sql:transaction [dataSource="dataSource"]
[isolation="isolationLevel"]>
<sql:query> and <sql:update> statements
</sql:update>
isolationLevel的取值：
read_committed、read_uncommitted、repeatable_read、serializable
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=gb2312" %>
<sql:setDataSource var="myDataSource" driver="com.mysql.jdbc.Driver"
url="jdbc:mysql://localhost:3306/it315" user="zxx" password="green" />
<div style="float:left">
转帐之前:
<sql:query var="myquery" dataSource="${myDataSource}">
select * from account
</sql:query>
<table border="1">
<tr><td>name</td><td>balance</td></tr>
<c:forEach var="row" items="${myquery.rows}">
<tr><td>${row.name}</td><td>${row.balance}</td></tr>
</c:forEach>
</table></div>
<sql:transaction dataSource="${myDataSource}" isolation="read_committed">
<sql:update>
update account set balance=balance-? where name=?
<sql:param value="${param.balance}" />
<sql:param value="${param.fromName}" />
</sql:update>
<sql:update>
update account set balance=balance+? where name=?
<sql:param value="${param.balance}" />
<sql:param value="${param.toName}" />
</sql:update>
</sql:transaction>
<div style="float:left; margin-left:20px">
${param.fromName}向${param.toName}转帐之后:
<sql:query var="myquery" dataSource="${myDataSource}">
select * from account
</sql:query>
<table border="1">
<tr><td>name</td><td>balance</td></tr>
<c:forEach var="row" items="${myquery.rows}">
<tr><td>${row.name}</td><td>${row.balance}</td></tr>
</c:forEach>
</table></div>
处理语句中的java.util.Date类型参数，可以设置数据库表中的DATE、TIME或TIMESTAMP类型字段的值。
<sql:dateParam value="value" [type="{timestamp|time|date}"]/>
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
<%@ page contentType="text/html;charset=gb2312" %>
<sql:setDataSource var="myDataSource" dataSource="jdbc/testSQL" />
<fmt:parseDate value="1975/1/1" pattern="yyyy/MM/dd" var="parsed" />
<fmt:formatDate value="${parsed}" var="birth" />
<sql:update dataSource="${myDataSource}">
update users set birthday=? where name=?
<sql:dateParam value="${birth}" />
<sql:param value="${param.name}" />
</sql:update>
已将“${param.name}”的 birthday 更新为“${birth}”！
XML标签
为了在Xpath表达式中能够方便地访问Web应用中的数据，Xpath引擎提供了对各Web域的支持，这些Web域与EL中定义的隐含对象完全相同。Xpath表达式与获得各Web域中域属性的值的方法的映射关系如下：
XML标签库中的所有标签都是通过select属性指定XPath表达式。
<?xml version="1.0" encoding="gb2312" ?>
<书架>
<书 id="001">
<书名>Java就业培训教程</书名>
<作者>张孝祥</作者>
<售价>39.00元</售价>
</书>
<书 id="002">
<书名>JavaScript网页开发</书名>
<作者>张孝祥</作者>
<售价>28.00元</售价>
</书>
</书架>
解析XML源数据，并将解析的结构对象保存在各种Web域中的某个属性中。不执行任何DTD验证或Schema验证。
1、 解析由String或Reader对象指定的XML文档
<x:parse {doc="xmlDocument" | xml="xmlDocument"}
{var="var" [scope="scope"] | varDom="var" [scopeDom="scope"]}
[systemId="systemId"]
[filter="filter"] />
2、 解析在标签体中指定的XML文档
<x:parse {var="var" [scope="scope"] | varDom="var" [scopeDom="scope"]}
[systemId="systemId"]
[filter="filter"] />
XML Document to parse
</x:parse>
scope：page、request、session、application
xml属性是为XML规范保留的，建议尽量不要使用该属性，而是使用doc属性。
如果filter属性为null，则不对XML源文档进行过滤，直接进行解析。
JSTL规范中没有定义var属性值的对象类型，允许XML解析器使用任意适当的类型。varDom属性的值是一个DOM文档。通过var和varDome暴露的对象都可以用使用设置XPath表达式的上下文。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@ page contentType="text/html;charset=gb2312" %>
<c:import url="book.xml" charEncoding="gb2312" var="doc" />
解析从外部导入的XML文档，
<x:parse xml="${doc}" varDom="parsedDoc" />
输出指定的元素：<br />
<x:out select="$parsedDoc//书[@id=$param:bookid]" /><hr />
<!--使用<c:set>标签设置XML源文档-->
<c:set var="xmlText">
<a>
<b>
test1
</b>
</a>
</c:set>
解析用<c:set>设置的DOM文档<br />
<x:parse var="myxml" doc="${xmlText}" />
输出“a”元素：<x:out select="$myxml/a" /><br />
输出“b”元素：<x:out select="$myxml//b" /><hr />
http://localhost:8080/myapp/x_parse.jsp?bookid=001：
解析从外部导入的XML文档， 输出指定的元素：
Java就业培训教程 张孝祥 39.00元
--------------------------------------------------------------------------------
解析用<c:set>设置的DOM文档
输出“a”元素： test1
输出“b”元素： test1
与<c:out>标签类似，会对HTML特殊字符进行转换。
<x:out select="xmpathExpression" [escapeXml="{true|fase}"] />
select属性指定的表达式必须符合XPath的语法，表达式的计算结果被转换成一个字符串。如果XPath表达式匹配XML源文档中的某个元素，<x:out>标签就输出该元素内嵌套的文本内容及其所有子元素内嵌套的文本内容，但不输出这个元素的属性的值。
计算Xpath表达式的值，并将计算结果保存到Web域中的属性中。
<x:set select="xmpathExpression"
var="varName"
[scope="{page|request|session|application}"] />
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@ page contentType="text/html;charset=gb2312" %>
<c:import url="book.xml" charEncoding="gb2312" var="doc" />
<x:parse doc="${doc}" var="parsedDoc" />
<x:set select="$parsedDoc//书/书名" var="parsedPath" />
<书名>元素的字符串值为：
<x:out select="$parsedPath" /><br /><hr />
<x:set select='$parsedDoc//书[@id="002"]' var="parsedPath2" />
属性id="002"的<书>元素的字符串值为：<br />
<x:out select="$parsedPath2" />
<书名>元素的字符串值为： Java就业培训教程
--------------------------------------------------------------------------------
属性id="002"的<书>元素的字符串值为：
JavaScript网页开发 张孝祥 28.00元
如果Xpath表达式的结果是一个数值，且不是0或NaN时，为真。
如果Xpath表达式的结果是一个节点，存在时为真。
如果Xpath表达式的结果是一个字符串，不为空时为真。
如果Xpath表达式的结果为真就执行标签体部分的内容。
<x:if select= "xpathExpression" var= "varName" [scope="{page|request|session|application}"] />
<x:if select= "xpathExpression" var= "varName" [scope="{page|request|session|application}"] >
body content
</x:if>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@ page contentType="text/html;charset=gb2312" %>
<c:import url="book.xml" charEncoding="gb2312" var="doc" />
<x:parse doc="${doc}" var="parsedDoc" />
<x:if select='$parsedDoc//书[@id="002"]' var="result" >
id属性值为“002”的<书>元素的字符串值：<br />
<x:out select="$parsedDoc//书[@id='002']" /><hr />
<x:if>标签的select属性的值为：
<c:out value="${result}" />
</x:if>
id属性值为“002”的<书>元素的字符串值：
JavaScript网页开发 张孝祥 28.00元
--------------------------------------------------------------------------------
<x:if>标签的select属性的值为： true
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@ page contentType="text/html;charset=gb2312" %>
<x:parse var="customer">
<customers>
<customer>
<name>zhangsan</name>
</customer>
</customers>
</x:parse>
<x:choose>
<x:when select="$customer//name">
Hello <x:out select="$customer//name" />
</x:when>
<x:otherwise>
Hello my friend
</x:otherwise>
</x:choose>
输出：Hello zhangsan
计算一个Xpath表达式的值，并以这个Xpath表达式的结果作为上下文环境来迭代处理其标签体内容。
<x:forEach [var="varName"]
select= "xpathExpression"
[varStatus= "varStatusName"]
[begin="begin"] [end= "end"] [step= "step"]>
body content
</x:forEach>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@ page contentType="text/html;charset=gb2312" %>
<c:import url="book.xml" charEncoding="gb2312" var="doc" />
<x:parse doc="${doc}" var="parsedDoc" />
迭代著书作者为张孝祥的所有<书>元素并获取迭代状态信息
<table border="1">
<tr><td>书ID号</td><td>书名</td><td>售价</td><td>count</td>
<td>first?</td><td>last?</td></tr>
<x:forEach select="$parsedDoc//书[作者='张孝祥']" varStatus="status">
<tr><td><x:out select="@id" /></td><td><x:out select="书名"/></td>
<td><x:out select="售价"/></td><td>${status.count}</td>
<td>${status.first}</td><td>${status.last}</td>
</tr>
</x:forEach>
</table>
迭代著书作者为张孝祥的所有<书>元素并获取迭代状态信息
|
书ID号 |
书名 |
售价 |
count |
first? |
last? |
|
001 |
Java就业培训教程 |
39.00元 |
1 |
true |
false |
|
002 |
JavaScript网页开发 |
28.00元 |
2 |
false |
true |
根据指定的XSLT样式表对XML源文档进行转换。
1、 没有标签体的情况
<x:transform
{doc="XMLDocument" | xml="XMLDocument"} xslt="XSLTStylesheet"
[{docSystemId="XMLSystemId" | xmlSystemId="XMLSystemID"}]
[xsltSystemId="XSLTSystemId"]
[{var="varName" [scope="scopeName"] | result="resultObject"}]/>
2、 在标签体中指定转换的参数
<x:transform
{doc="XMLDocument" | xml="XMLDocument"} xslt="XSLTStylesheet"
[{docSystemId="XMLSystemId" | xmlSystemId="XMLSystemID"}]
[xsltSystemId="XSLTSystemId"]
[{var="varName" [scope="scopeName"] | result="resultObject"}]>
<x:param> actions
<x:transform>
3、 在标签体中指定XML文档和转换的参数
<x:transform
xslt="XSLTStylesheet"
[{docSystemId="XMLSystemId" | xmlSystemId="XMLSystemID"}]
xsltSystemId="XSLTSystemId"
[{var="varName" [scope="scopeName"] | result="resultObject"}]>
XML Document to parse
Optional <x:param> actions
<x:transform>
xslt：String、reader或javax.xml.transform.source 指定转换的XSLT样式表档
xsltSystemId：指定要转换的XSLT样式表的系统标识符（URI）
var：指定将转换的结果Document对象保存在Web域中的属性名称。
result：指定将转换结果保存到一个javax.xml.transform.Result实例对象。
转换XSLT样式表文档：
<?xml version="1.0" encoding="gb2312"?>
<xsl:stylesheet version="1.0" xmlns:xsl="http://www.w3.org/1999/XSL/Transform">
<xsl:template match="/">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=gb2312"/>
<title>显示外观1</title>
</head>
<body>
<table border="1">
<tr align="center"><td>书ID号</td><td>书名</td>
<td>作者</td><td>价格</td></tr>
<xsl:for-each select="书架/书">
<tr align="center">
<td><xsl:value-of select="@id"/></td>
<td><xsl:value-of select="书名"/></td>
<td><xsl:value-of select="作者"/></td>
<td><xsl:value-of select="售价"/></td>
</tr>
</xsl:for-each>
</table>
</body>
</html>
</xsl:template>
</xsl:stylesheet>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
<%@ page contentType="text/html;charset=gb2312" %>
<%@ page import="javax.xml.transform.stream.StreamResult" %>
<c:import url="book.xml" charEncoding="gb2312" var="doc" />
<c:import url="book2.xsl" charEncoding="gb2312" var="xslt" />
将转换结果直接输出到当前JSP页面：
<x:transform doc="${doc}" xslt="${xslt}" /><br />
设置var属性，输出转换结果的<body>元素的字符串值：<br />
<x:transform doc="${doc}" xslt="${xslt}" var="trans" />
<x:out select="$trans//body" /><hr />
设置result属性，将转换的结果输出到指定文件中
<%
//设置保存转换结果的文件
String path = getServletContext().getRealPath("/");
StreamResult streamResult = new StreamResult(new String(path + "book.html"));
session.setAttribute("streamResult", streamResult);
%>
<x:transform doc="${doc}" xslt="${xslt}" result="${streamResult}" />
将转换结果直接输出到当前JSP页面：
|
书ID号 |
书名 |
作者 |
价格 |
|
001 |
Java就业培训教程 |
张孝祥 |
39.00元 |
|
002 |
JavaScript网页开发 |
张孝祥 |
28.00元 |
设置var属性，输出转换结果的<body>元素的字符串值：
书ID号书名作者价格001Java就业培训教程张孝祥39.00元002JavaScript网页开发张孝祥28.00元
设置result属性，将转换的结果输出到指定文件中
用于嵌套在<x:transform>标签内设置转换的参数。
<x:param name="name" value="value" />
<x:param name="name" value="value" >
parameter value
</x:param>
JSTL函数
JSTL中提供的EL自定函数必须在EL表达式中使用。
转换小写：${fn:toLowerCase("Www.IT315.org")}返回“www.it315.org”
删除字符首尾空格。
将字符串中的需要进行转换的HTML特殊字符进行HTML编码转换，这样可以在浏览器中显示出HTML特殊字符。
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
${fn:escapeXml('<meta http-equiv="refresh"
content="0;url=http://www.it315.org"/>')}
上面的结果是页面不会自动跳转了，而是直接输出。
返回一个集合或数组对象中包含的元素的个数，或返回一个字符串中包含的字符的个数。其参数可以是<c:forEach>标签的items属性支持的任何类型，包括任意类型的数组、java.util.Collection、java.util.Iterator、java.util.Enumeration、java.util.Map等类型的实例对象和字符串。
如果参数为null或是元素个数为0的集合或数组或空字符串时，返回0。
第一个参数表示要分割的字符串，第二个参数表示作为分隔符的字符串。
fn:split("www.it315.org" ,".")[1] 返回值为“it315”
fn:split("" ,".")[0] 返回空字符串
fn:split("www.it315.org" ,"")[1] 返回值为“www.it315.org”
以一个字符串作为分隔符，将一个字符串数组中的所有元素合并为一个字符串。第一个参数是要操作的字符串数组，第二个参数是作为分隔符的字符串。
fn:join(fn:split("www ,it315 ,org" ," ,") , " .") 返回“www.it315.org”
返回指定字符串在一个字符串第一次出现的索引值。未包含时返回-1。如果第二个参数为空字符串时，总是返回0。
fn:indexOf("www.it315.org" , "t3")返回值为5
fn:indexOf("www.it315.org" , "")返回值为0
如果第二个参数的值为空字符串，总返回true，实际上，fn:contains(string,substring)等价于fn:indexOf(string ,substring)!=-1
与fn:contains函数相同，只是不区别大小写。
fn:containsIgnoreCase(string, substring)等价于fn:contains (fn:toUpperCase(string), fn:toUpperCase(substring))
检测一个字符串是否以指定字符串开始的。如果第二个参数为空字符串，总是返回true。
fn:startsWith(string , prefix) 等价于表达式fn:indexOf(string , prefix)==0
是否以指定字符串结尾。如果第二个参数为空字符串，则总返回true。
第一个为源字符串，第二个表示源子符串中要被替换的子字符串，第三个参数表示要被替换成的字符串。
如果第二个参数是空字符串，则不执行任何替换操作。
第一个参数为源字符串，第二个参数为开始索引，第三个参数为结束索引。
截取并返回一个字符串中的指定子字符串第一次出现之后的子字符串。
fn:substringAfter("www.it315.org", ".")返回“it315.org”
fn:substringAfter("www.it315.org", ".")返回“www”