JSTL

概述

在JSP页面中，使用标签库代替传统的Java片段语言来实现页面的显示逻辑已经不是新技术了，然而，由自定义标签很容易造成重复定义和非标准的实现。鉴于此，出现了JSTL（JSP Standard Tag Library）。大多数JSP页面逻辑提供了实现的JSTL技术，该技术本身就是一个标签库。

Sun公司Java规范标准的JSTL由apache jakarta组织负责维护。作为开源的标准技术，它一直在不断地完善。JSTL的发布包有两个版本：Standard-1.0Taglib、Standard-1.1 Taglib，它们在使用时是不同的。

q Standard-1.0 Taglib（JSTL1.0）支持Servlet2.3和JSP1.2规范，Web应用服务器Tomcat4支持这些规范，而它的发布也在Tomcat 4.1.24测试通过了。

q Standard-1.1 Taglib（JSTL1.1）支持Servlet2.4和JSP2.0规范，Web应用服务器Tomcat5支持这些规范，它的发布在Tomcat 5.0.3测试通过了。

在本章的介绍中，将以由Sun发布的Standard-1.1 Taglib标签库为主，而apache jakarta组织发布的开源标签库，可以从http://jakarta.apache.org/taglibs/找到所需要的帮助。Sun发布的标准JSTL1.1标签库有以下几个标签：

▲ 核心标签库：包含Web应用的常见工作，比如：循环、表达式赋值、基本输入输出等。

▲ 国际化标签库：用来格式化显示数据的工作，比如：对不同区域的日期格式化等。

▲ 数据库标签库：可以做访问数据库的工作。

▲ XML标签库：用来访问XML文件的工作，这是JSTL标签库的一个特点。

▲ 函数标签库：用来读取已经定义的某个函数。

此外，JSTL还提供了EL表达式语言（Expression Language）来进行辅助的工作。

JSTL标签库由标签库和EL表达式语言两个部分组成。EL在JSTL 1.0规范中被引入，当时用来作为Java表达式来工作，而该表达式必须配合JSTL的标签库才能得到需要的结果。

说明：在JSTL 1.1规范中，JSP2.0容器已经能够独立的理解任何EL表达式。EL可以独立出现在JSP页面的任何角落。本文随后的内容将以JSTL 1.1规范作为介绍的重点。

9.2.1 JSTL EL表达式语言简介

EL是从JavaScript脚本语言得到启发的一种表达式语言，它借鉴了JavaScript多类型转换无关性的特点。在使用EL从scope中得到参数时可以自动转换类型，因此对于类型的限制更加宽松。Web服务器对于request请求参数通常会以String类型来发送，在得到时使用的Java语言脚本就应该是request.getParameter(“XXX”)，这样的话，对于实际应用还必须进行强制类型转换。而EL就将用户从这种类型转换的繁琐工作脱离出来，允许用户直接使用EL表达式取得的值，而不用关心它是什么类型。

下面的示例就是一个EL表达式，见例9.1。

例9.1：简单EL表达式

<%@ page contentType="text/html;charset=UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<body>

${sampleValue + 1}<br>

</body>

</html>

这个示例将在JSP页面显示为“1”，EL表达式必须以“${XXX}”来表示，其中“XXX”部分就是具体表达式内容，“${}”将这个表达式内容包含在其中作为EL表达式的定义。本示例可以在满足JSP2.0规范的任何Web应用服务器中使用。

9.2.2 EL表达式的默认变量

一个EL表达式包含变量和操作符两个内容。任何存在于JSP作用范围的JavaBean都可以被转化成EL表达式来使用，它所包含的默认变量如下：

1．默认变量pageScope、requestScope、sessionScope、applicationScope

这4个默认变量包含Scope作用范围的参数集合，相当于被保存在java.util.Map中的某个参数。下面看简单的示例9.2：

例9.2：使用sessionScope变量的EL表达式

<%request.getSession().setAttribute("sampleValue",new Integer(10));%>

${sessionScope.sampleValue}

取得保存在Session中参数的sessionScope变量的EL表达式，“.”是property访问操作符，在这里表示从Session中取得“键”为“sampleValue”的参数，并显示出来。显示结果为“10”。

2．默认变量param、paramValues

这两个默认变量包含请求参数的集合，param表明请求包含的参数为单一控件，paramValues表明请求包含的参数为控件数组。下面看一个简单示例9.3：

例9.3：提交请求的页面和接受的页面

<%@ page contentType="text/html;charset=UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<body>

<formaction="SampleJsp.jsp">

<inputtype="text" name="sampleValue" value="10">

<inputtype="text" name="sampleValue" value="11">

<inputtype="text" name="sampleValue" value="12">

<inputtype="text" name="sampleSingleValue"value="SingleValue">

<inputtype="submit" value="Submit">

</form>

</body>

</html>

在这个页面中定义了两组控件，控件名为“sampleValue”的是一套控件数组，控件名为“sampleSingleValue”的是单一控件，通过递交将请求参数传送到SampleJsp.jsp。

<%@ page contentType="text/html;charset=UTF-8"%>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<body>

${paramValues.sampleValue[2]}<br>

${param.sampleSingleValue} <br>

</body>

</html>

这是请求转发到的页面，通过EL表达式的paramValues变量得到控件数组中最后一个控件的递交参数，通过EL表达式的param变量得到单一控件的递交参数。控件数组参数的EL表达式使用“[]”来指定数组下标。本示例将显示控件数组中最后一个控件的值“12”和单一控件的值“SingleValue”。

3．默认变量header、headerValues

这两个默认变量包含请求参数头部信息的集合，header变量表示单一头部信息，headerValues则表示数组型的头部信息。

4．默认变量cookie

包含所有请求的cookie集合，集合中的每个对象对应javax.servlet.http.Cookie。

5．默认变量initParam

包含所有应用程序初始化参数的集合。

6．默认变量pageContext

等价于page环境类javax.servlet.jsp.PageContext的实例，用来提供访问不同的请求参数。

11个默认变量几乎包含了Web应用的所有基本操作，若一个表达式不使用这些变量而直接使用参数名，那么就采用就近原则。该表达式将使用最近取得的参数值。

9.2.3 EL表达式的操作符

EL表达式中还有许多操作符可以帮助完成各种所需的操作，之前的示例中“.”、“[]”就是其中的两个，下面将用表9.1来展示所有操作符及它们各自的功能。

表9.1 EL表达式的操作符

操作符	功能和作用
.	访问一个bean属性或者Map entry
[]	访问一个数组或者链表元素
()	对子表达式分组，用来改变赋值顺序
? :	条件语句，比如：条件?ifTrue:ifFalse 如果条件为真，表达式值为前者，反之为后者
+	数学运算符，加操作
-	数学运算符，减操作或者对一个值取反
*	数学运算符，乘操作
/或div	数学运算符，除操作
%或mod	数学运算符，模操作(取余)
==或eq	逻辑运算符，判断符号左右两端是否相等，如果相等返回true，否则返回false
!=或ne	逻辑运算符，判断符号左右两端是否不相等，如果不相等返回true，否则返回false
<或lt	逻辑运算符，判断符号左边是否小于右边，如果小于返回true，否则返回false
>或gt	逻辑运算符，判断符号左边是否大于右边，如果大于返回true，否则返回false
<=或le	逻辑运算符，判断符号左边是否小于或者等于右边，如果小于或者等于返回true，否则返回false
>=或ge	逻辑运算符，判断符号左边是否大于或者等于右边，如果大于或者等于返回true，否则返回false
&&或and	逻辑运算符，与操作赋。如果左右两边同为true返回true，否则返回false
\|\|或or	逻辑运算符，或操作赋。如果左右两边有任何一边为true返回true，否则返回false
!或not	逻辑运算符，非操作赋。如果对true取运算返回false，否则返回true
empty	用来对一个空变量值进行判断:null、一个空String、空数组、空Map、没有条目的Collection集合
func(args)	调用方法, func是方法名，args是参数，可以没有，或者有一个、多个参数.参数间用逗号隔开

这些操作符都是极其有用的，下面通过几个示例来演示它们的使用方法：

例9.4：几组操作符的示例

${pageScope.sampleValue + 12}<br> //显示12

${(pageScope.sampleValue + 12)/3}<br> //显示4.0

${(pageScope.sampleValue + 12) /3==4}<br> //显示true

${(pageScope.sampleValue + 12) /3>=5}<br> //显示false

<input type="text"name="sample1" value="${pageScope.sampleValue + 10}"> //显示值为10的Text控件

可以看到，对于这些示例，程序设计者完全无需管理它们的类型转换，在表达式内部都已经处理了。有了EL表达式，在JSP页面的编程变得更灵活，也更容易。

9.2.3 JSTL标签库介绍

在JSTL1.1中有以下这些标签库是被支持的：Core标签库、XML processing标签库、I18N formatting标签库、Database access标签库、Functions标签库。对应的标识符见表9.2所示：

表9.2标签库的标识符

标签库	URI	前缀
Core	http://java.sun.com/jsp/jstl/core	c
XML processing	http://java.sun.com/jsp/jstl/xml	x
I18N formatting	http://java.sun.com/jsp/jstl/fmt	fmt
Database access	http://java.sun.com/jsp/jstl/sql	sql
Functions	http://java.sun.com/jsp/jstl/functions	fn

下面看例9.5，简单使用标签库的示例。

例9.5：简单JSTL标签库示例

<%@ page contentType="text/html;charset=UTF-8"%>

<%@ taglib prefix="c"uri="http://java.sun.com/jsp/jstl/core" %>

<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN">

<html>

<body>

<c:forEachvar="i" begin="1" end="10" step="1">

${i}

<br/>

</c:forEach>

</body>

</html>

在该示例的JSP页面中声明了将使用Core标签库，它的URI为“http://java.sun.com/jsp/jstl/core”，前缀为“c”。之后，页面中<c:forEach>标签就是使用了JSTL的标签进行了工作。对于该标签的功能，这里暂时不作具体讲解，只是让读者能够有个简单的概念，了解怎样定义和使用标签库。

9.3 JSTL Core标签库

Core标签库，又被称为核心标签库，该标签库的工作是对于JSP页面一般处理的封装。在该标签库中的标签一共有14个，被分为了四类，分别是：

q 多用途核心标签：<c:out>、<c:set>、<c:remove>、<c:catch>。

q 条件控制标签：<c:if>、<c:choose>、<c:when>、<c:otherwise>。

q 循环控制标签：<c:forEach>、<c:forTokens>。

q URL相关标签：<c:import>、<c:url>、<c:redirect>、<c:param>。

以下是各个标签的用途和属性以及简单示例。

9.3.1 用于显示的<c:out>标签

<c:out>标签是一个最常用的标签，用于在JSP中显示数据。它的属性和描述如表9.3所示：

表9.3　<c:out>标签属性和说明

属性	描述
value	输出到页面的数据，可以是EL表达式或常量（必须）
default	当value为null时显示的数据（可选）
escapeXml	当设置为true时会主动更换特殊字符，比如“<,>,&”（可选，默认为true）

在JSTL1.0的时候，在页面显示数据必须使用<c:out>来进行。然而，在JSTL1.1中，由于JSP2.0规范已经默认支持了EL表达式，因此可以直接在JSP页面使用表达式。下面看一个示例。

<c:outvalue="${sessionScope.anyValue}" default="no value"escapeXml="false"/>

该示例将从Session查找名为“anyValue”的参数，并显示在页面，若没有找到则显示“no value”。

9.3.2 用于赋值的<c:set>标签

<c:set>标签用于为变量或JavaBean中的变量属性赋值的工作。它的属性和描述如表9.4所示：

表9.4　<c:set>标签属性和说明

属性	描述
value	值的信息，可以是EL表达式或常量
target	被赋值的JavaBean实例的名称，若存在该属性则必须存在property属性（可选）
property	JavaBean实例的变量属性名称（可选）
var	被赋值的变量名（可选）
scope	变量的作用范围，若没有指定，默认为page（可选）

当不存在value的属性时，将以包含在标签内的实体数据作为赋值的内容。下面看一个示例：

<c:set value="this is andy"var="oneString"/>

${oneString} <br>

该示例将为名为“oneString”的变量赋值为“this is andy”，其作用范围为page。

9.3.3 用于删除的<c:remove>标签

<c:remove>标签用于删除存在于scope中的变量。它的属性和描述如表9.5所示：

表9.5　<c:remove>标签属性和说明

属性	描述
var	需要被删除的变量名
scope	变量的作用范围，若没有指定，默认为全部查找（可选）

下面看一个示例：

<c:remove var="sampleValue"scope="session"/>

${sessionScope.sampleValue} <br>

该示例将存在于Session中名为“sampleValue”的变量删除。下一句EL表达式显示该变量时，该变量已经不存在了。

9.3.4 用于异常捕获的<c:catch>标签

<c:catch>标签允许在JSP页面中捕捉异常。它包含一个var属性，是一个描述异常的变量，改变量可选。若没有var属性的定义，那么仅仅捕捉异常而不做任何事情，若定义了var属性，则可以利用var所定义的异常变量进行判断转发到其他页面或提示报错信息。看一个示例。

<c:catch var="err">

${param.sampleSingleValue[9]== 3}

</c:catch>

${err}

当“${param.sampleSingleValue[9] == 3}”表达式有异常时，可以从var属性“err”得到异常的内容，通常判断“err”是否为null来决定错误信息的提示。

9.3.5 用于判断的<c:if>标签

<c:if>标签用于简单的条件语句。它的属性和描述如表9.6所示：

表9.6　<c:if>标签属性和说明

属性	描述
test	需要判断的条件
var	保存判断结果true或false的变量名，该变量可供之后的工作使用（可选）
scope	变量的作用范围，若没有指定，默认为保存于page范围中的变量（可选）

下面看一个示例：

<c:iftest="${paramValues.sampleValue[2] == 12}" var="visits">

It is 12

</c:if><br>

${visits} <br>

该示例将判断request请求提交的传入控件数组参数中，下标为“2”的控件内容是否为“12”，若为12则显示“It is 12”。判断结果被保存在page范围中的“visits”变量中。　　

9.3.6 用于复杂判断的<c:choose>、<c:when>、<c:otherwise>标签

这三个标签用于实现复杂条件判断语句，类似“if,elseif”的条件语句。

q <c:choose>标签没有属性，可以被认为是父标签，<c:when>、<c:otherwise>将作为其子标签来使用。

q <c:when>标签等价于“if”语句，它包含一个test属性，该属性表示需要判断的条件。

q <c:otherwise>标签没有属性，它等价于“else”语句。

下面看一个复杂条件语句的示例。

<c:choose>

<c:whentest="${paramValues.sampleValue[2] == 11}">

not12 not 13,it is 11

</c:when>

<c:whentest="${paramValues.sampleValue[2] == 12}">

not11 not 13,it is 12

</c:when>

<c:whentest="${paramValues.sampleValue[2] == 13}">

not11 not 12,it is 13

</c:when>

<c:otherwise>

not11、12、13

</c:otherwise>

</c:choose>

该示例将判断request请求提交的传入控件数组参数中，下标为“2”控件内容是否为“11”或“12”或“13”，并根据判断结果显示各自的语句，若都不是则显示“not 11、12、13”。

9.3.7 用于循环的<c:forEach>标签

<c:forEach>为循环控制标签。它的属性和描述如表9.7所示：

表9.7　<c:forEach>标签属性和说明

属性	描述
items	进行循环的集合（可选）
begin	开始条件（可选）
end	结束条件（可选）
step	循环的步长，默认为1（可选）
var	做循环的对象变量名，若存在items属性，则表示循环集合中对象的变量名（可选）
varStatus	显示循环状态的变量（可选）

下面看一个集合循环的示例。

<%ArrayList arrayList = newArrayList();

arrayList.add("aa");

arrayList.add("bb");

arrayList.add("cc");

<%request.getSession().setAttribute("arrayList",arrayList);%>

<c:forEachitems="${sessionScope.arrayList}" var="arrayListI">

${arrayListI}

</c:forEach>

该示例将保存在Session中的名为“arrayList”的ArrayList类型集合参数中的对象依次读取出来，items属性指向了ArrayList类型集合参数，var属性定义了一个新的变量来接收集合中的对象。最后直接通过EL表达式显示在页面上。下面看一个简单循环的示例。

<c:forEach var="i"begin="1" end="10" step="1">

${i}<br/>

</c:forEach>

该示例从“1”循环到“10”，并将循环中变量“i”显示在页面上。

9.3.8 用于分隔字符的<c:forTokens>标签

<c:forTokens>标签可以根据某个分隔符分隔指定字符串，相当于java.util.StringTokenizer类。它的属性和描述如表9.8所示：

表9.8　<c:forTokens>标签属性和说明

属性	描述
items	进行分隔的EL表达式或常量
delims	分隔符
begin	开始条件（可选）
end	结束条件（可选）
step	循环的步长，默认为1（可选）
var	做循环的对象变量名（可选）
varStatus	显示循环状态的变量（可选）

下面看一个示例。

<c:forTokensitems="aa,bb,cc,dd" begin="0" end="2"step="2" delims="," var="aValue">

${aValue}

</c:forTokens>

需要分隔的字符串为“aa,bb,cc,dd”，分隔符为“,”。begin属性指定从第一个“,”开始分隔，end属性指定分隔到第三个“,”，并将做循环的变量名指定为“aValue”。由于步长为“2”，使用EL表达式${aValue}只能显示“aa

9.3.9 用于包含页面的<c:import>

<c:import>标签允许包含另一个JSP页面到本页面来。它的属性和描述如表9.9所示：

表9.9　<c:import>标签属性和说明

属性	描述
url	需要导入页面的URL
context	Web Context该属性用于在不同的Context下导入页面，当出现context属性时，必须以“/”开头，此时也需要url属性以“/”开头（可选）
charEncoding	导入页面的字符集（可选）
var	可以定义导入文本的变量名（可选）
scope	导入文本的变量名作用范围（可选）
varReader	接受文本的java.io.Reader类变量名（可选）

下面看一个示例。

<c:import url="/MyHtml.html"var="thisPage" />

<c:import url="/MyHtml.html"context=”/sample2” var="thisPage"/>

<c:import url="www.sample.com/MyHtml.html"var="thisPage"/>

该示例演示了三种不同的导入方法，第一种是在同一Context下的导入，第二种是在不同的Context下导入，第三种是导入任意一个URL。

9.3.10 用于得到URL地址的<c:url>标签

<c:url>标签用于得到一个URL地址。它的属性和描述如表9.10所示：

表9.10 <c:url>标签属性和说明

属性	描述
value	页面的URL地址
context	Web Context该属性用于得到不同Context下的URL地址，当出现context属性时，必须以“/”开头，此时也需要url属性以“/”开头（可选）
charEncoding	URL的字符集（可选）
var	存储URL的变量名（可选）
scope	变量名作用范围（可选）

下面看一个示例：

<c:url value="/MyHtml.html"var="urlPage" />

<ahref="${urlPage}">link</a>

得到了一个URL后，以EL表达式放入<a>标签的href属性，达到链接的目的。

9.3.11 用于页面重定向的<c:redirect>标签

<c:redirect>用于页面的重定向，该标签的作用相当于response.setRedirect方法的工作。它包含url和context两个属性，属性含义和<C:url>标签相同。下面看一个示例。

<c:redirecturl="/MyHtml.html"/>

该示例若出现在JSP中，则将重定向到当前Web Context下的“MyHtml.html”页面，一般会与<c:if>等标签一起使用。

9.3.12 用于包含传递参数的<c:param>标签

<c:param>用来为包含或重定向的页面传递参数。它的属性和描述如表9.11所示：

表9.11　<c:param>标签属性和说明

属性	描述
name	传递的参数名
value	传递的参数值（可选）

下面是一个示例：

<c:redirecturl="/MyHtml.jsp">

<c:param name="userName"value=”RW” />

</c:redirect>

该示例将为重定向的“MyHtml.jsp”传递指定参数“userName=’RW’”。

9.4 JSTL XML processing标签库

在企业级应用越来越依赖XML的今天，XML格式的数据被作为信息交换的优先选择。XML processing标签库为程序设计者提供了基本的对XML格式文件的操作。在该标签库中的标签一共有10个，被分为了三类，分别是：

q XML核心标签：<x:parse>、<x:out>、<x:set>。

q XML流控制标签：<x:if>、<x:choose>、<x:when>、<x:otherwise>、<x:forEach>。

q XML转换标签：<x:transform>、<x:param>。

由于该组标签库专注于对某一特定领域的实现，因此本书将只选择其中常见的一些标签和属性进行介绍。

9.4.1 用于解析XML文件的<x:parse>标签

<x:parse>标签是该组标签库的核心，从其标签名就可以知道，它是作为解析XML文件而存在的。它的属性和描述如表9.12所示：

表9.12　<x:parse>标签属性和说明

属性	描述
doc	源XML的内容，该属性的内容应该为String类型或者java.io.Reader的实例，可以用xml属性来替代，但是不被推荐
var	将解析后的XML保存在该属性所指定的变量中，之后XML processing标签库中的其他标签若要取XML中的内容就可以从该变量中得到（可选）
scope	变量的作用范围（可选）
varDom	指定保存的变量为org.w3c.dom.Document接口类型（可选）
scopeDom	org.w3c.dom.Document的接口类型变量作用范围（可选）
systemId	定义一个URI，该URI将被使用到XML文件中以接入其他资源文件（可选）
filter	该属性必须为org.xml.sax.XMLFilter类的一个实例，可以使用EL表达式传入，将对XML文件做过滤得到自身需要的部分（可选）

其中，var、scope和varDom、scopeDom不应该同时出现，而应该被视为两个版本来使用，二者的变量都可以被XML processing标签库的其他标签来使用。

<x:parse>标签单独使用的情况很少，一般会结合XML processing标签库中的其他标签来一起工作。下面看一个示例。

首先给出一个简单的XML文件，将对该XML文件做解析，该XML文件名为SampleXml.xml。

<?xml version="1.0"encoding="UTF-8"?>

<xml-body>

<books>

</books>

</xml-body>

标签库的工作：

<c:import var="xmlFile"url="http://localhost:8080/booksamplejstl/SampleXml.xml"/>

<x:parse var="xmlFileValue"doc="${xmlFile}"/>

9.5 I18Nformatting标签库

看到I18N就应该想到知识“国际化”，I18N formatting标签库就是用于在JSP页面中做国际化的动作。在该标签库中的标签一共有12个，被分为了两类，分别是：

q 国际化核心标签：<fmt:setLocale>、<fmt:bundle>、<fmt:setBundle>、<fmt:message>、<fmt:param>、<fmt:requestEncoding>。

q 格式化标签：<fmt:timeZone>、<fmt:setTimeZone>、<fmt:formatNumber>、<fmt:parseNumber>、<fmt:formatDate>、<fmt:parseDate>。

下面只选择其中常见的一些标签和属性进行介绍。

9.5.1 用于设置本地化环境的<fmt:setLocale>标签

<fmt:setLocale>标签用于设置Locale环境。它的属性和描述如表9.17所示：

表9.17　<fmt:setLocale>标签属性和说明

属性	描述
value	Locale环境的指定，可以是java.util.Locale或String类型的实例
scope	Locale环境变量的作用范围（可选）

下面看一个示例：

<fmt:setLocale value="zh_TW"/>

表示设置本地环境为繁体中文。

9.5.2 用于资源文件绑定的<fmt:bundle>、<fmt:setBundle>标签

这两组标签用于资源配置文件的绑定，唯一不同的是<fmt:bundle>标签将资源配置文件绑定于它标签体中的显示，<fmt:setBundle>标签则允许将资源配置文件保存为一个变量，在之后的工作可以根据该变量来进行。

根据Locale环境的不同将查找不同后缀的资源配置文件，这点在国际化的任何技术上都是一致的，通常来说，这两种标签单独使用是没有意义的，它们都会与I18N formatting标签库中的其他标签配合使用。它们的属性和描述如表9.18所示：

表9.18　<fmt:bundle>、<fmt:setBundle>标签属性和说明

属性	描述
basename	资源配置文件的指定，只需要指定文件名而无须扩展名，二组标签共有的属性
var	<fmt:setBundle>独有的属性，用于保存资源配置文件为一个变量
scope	变量的作用范围

下面看一个示例

<fmt:setLocale value="zh_CN"/>

<fmt:setBundle basename="applicationMessage"var="applicationBundle"/>

该示例将会查找一个名为applicationMessage_zh_CN.properties的资源配置文件，来作为显示的Resource绑定。

9.5.3 用于显示资源配置文件信息的<fmt:message>标签

用于信息显示的标签，将显示资源配置文件中定义的信息。它的属性和描述如表9.19所示：

表9.19　<fmt:message>标签属性和说明

属性	描述
key	资源配置文件的“键”指定
bundle	若使用<fmt:setBundle>保存了资源配置文件，该属性就可以从保存的资源配置文件中进行查找
var	将显示信息保存为一个变量
scope	变量的作用范围

下面看一个示例：

<fmt:setBundle basename="applicationMessage"var="applicationBundle"/>

<fmt:bundlebasename="applicationAllMessage">

<fmt:message key="userName" />

<p>

<fmt:message key="passWord"bundle="${applicationBundle}" />

</fmt:bundle>

该示例使用了两种资源配置文件的绑定的做法，“applicationMessage ”资源配置文件利用<fmt:setBundle>标签被赋于了变量“applicationBundle ”，而作为<fmt:bundle>标签定义的“applicationAllMessage ”资源配置文件作用于其标签体内的显示。

q 第一个<fmt:message>标签将使用“applicationAllMessage ”资源配置文件中“键”为“userName ”的信息显示。

q 第二个<fmt:message>标签虽然被定义在<fmt:bundle>标签体内，但是它使用了bundle属性，因此将指定之前由<fmt:setBundle>标签保存的“applicationMessage ”资源配置文件，该“键”为“passWord ”的信息显示。

9.5.4 用于参数传递的<fmt:param>标签

<fmt:param>标签应该位于<fmt:message>标签内，将为该消息标签提供参数值。它只有一个属性value。

<fmt:param>标签有两种使用版本，一种是直接将参数值写在value属性中，另一种是将参数值写在标签体内。

9.5.6 用于为请求设置字符编码的<fmt:requestEncoding>标签

<fmt:requestEncoding>标签用于为请求设置字符编码。它只有一个属性value，在该属性中可以定义字符编码。

9.5.7 用于设定时区的<fmt:timeZone>、<fmt:setTimeZone>标签

这两组标签都用于设定一个时区。唯一不同的是<fmt:timeZone>标签将使得在其标签体内的工作可以使用该时区设置，<fmt:setBundle>标签则允许将时区设置保存为一个变量，在之后的工作可以根据该变量来进行。它们的属性和描述如表9.20所示：

表9.20　<fmt:timeZone>、<fmt:setTimeZone>标签属性和说明

属性	描述
value	时区的设置
var	<fmt:setTimeZone>独有的属性，用于保存时区为一个变量
scope	变量的作用范围

9.5.8 用于格式化数字的<fmt:formatNumber>标签

<fmt:formatNumber >标签用于格式化数字。它的属性和描述如表9.21所示：

表9.21　<fmt:formatNumber>标签属性和说明

属性	描述
value	格式化的数字，该数值可以是String类型或java.lang.Number类型的实例
type	格式化的类型
pattern	格式化模式
var	结果保存变量
scope	变量的作用范围
maxIntegerDigits	指定格式化结果的最大值
minIntegerDigits	指定格式化结果的最小值
maxFractionDigits	指定格式化结果的最大值，带小数
minFractionDigits	指定格式化结果的最小值，带小数

<fmt:formatNumber>标签实际是对应java.util.NumberFormat类，type属性的可能值包括currency（货币）、number（数字）和percent（百分比）。

下面看一个示例。

<fmt:formatNumber value="1000.888"type="currency" var="money"/>

该结果将被保存在“money ”变量中，将根据Locale环境显示当地的货币格式。

9.5.9 用于解析数字的<fmt:parseNumber>标签

<fmt:parseNumber>标签用于解析一个数字，并将结果作为java.lang.Number类的实例返回。<fmt:parseNumber>标签看起来和<fmt:formatNumber>标签的作用正好相反。它的属性和描述如表9.22所示：

表9.22　<fmt:parseNumber>标签属性和说明

属性	描述
value	将被解析的字符串
type	解析格式化的类型
pattern	解析格式化模式
var	结果保存变量，类型为java.lang.Number
scope	变量的作用范围
parseLocale	以本地化的形式来解析字符串，该属性的内容应为String或java.util.Locale类型的实例

下面看一个示例。

<fmt:parseNumber value="15%"type="percent" var="num"/>

解析之后的结果为“0.15 ”。

9.5.10 用于格式化日期的<fmt:formatDate>标签

<fmt:formatDate>标签用于格式化日期。它的属性和描述如表9.23所示：

表9.23　<fmt:formatDate>标签属性和说明

属性	描述
value	格式化的日期，该属性的内容应该是java.util.Date类型的实例
type	格式化的类型
pattern	格式化模式
var	结果保存变量
scope	变量的作用范围
timeZone	指定格式化日期的时区

<fmt:formatDate>标签与<fmt:timeZone>、<fmt:setTimeZone>两组标签的关系密切。若没有指定timeZone属性，也可以通过<fmt:timeZone>、<fmt:setTimeZone>两组标签设定的时区来格式化最后的结果。

9.5.11 用于解析日期的<fmt:parseDate>标签

<fmt:parseDate>标签用于解析一个日期，并将结果作为java.lang.Date类型的实例返回。<fmt:parseDate>标签看起来和<fmt:formatDate>标签的作用正好相反。它的属性和描述如表9.24所示：

表9.24　<fmt:parseDate>标签属性和说明

属性	描述
value	将被解析的字符串
type	解析格式化的类型
pattern	解析格式化模式
var	结果保存变量，类型为java.lang.Date
scope	变量的作用范围
parseLocale	以本地化的形式来解析字符串，该属性的内容为String或java.util.Locale类型的实例
timeZone	指定解析格式化日期的时区

<fmt:parseNumber>和<fmt:parseDate>两组标签都实现解析字符串为一个具体对象实例的工作，因此，这两组解析标签对var属性的字符串参数要求非常严格。就JSP页面的表示层前段来说，处理这种解析本不属于份内之事，因此<fmt:parseNumber>和<fmt:parseDate>两组标签应该尽量少用，替代工作的地方应该在服务器端表示层的后段，比如在Servlet中。

9.6 Databaseaccess标签库

Databaseaccess标签库中的标签用来提供在JSP页面中可以与数据库进行交互的功能，虽然它的存在对于早期纯JSP开发的应用以及小型的开发有着意义重大的贡献，但是对于MVC模型来说，它却是违反规范的。因为与数据库交互的工作本身就属于业务逻辑层的工作，所以不应该在JSP页面中出现，而是应该在模型层中进行。

对于Databaseaccess标签库本书不作重点介绍，只给出几个简单示例让读者略微了解它们的功能。

Databaseaccess标签库有以下6组标签来进行工作：<sql:setDataSource>、<sql:query>、<sql:update>、<sql:transaction>、<sql:setDataSource>、<sql:param>、<sql:dateParam>。

9.6.1 用于设置数据源的<sql:setDataSource>标签

<sql:setDataSource>标签用于设置数据源，下面看一个示例：

<sql:setDataSource

var="dataSrc"

url="jdbc:postgresql://localhost:5432/myDB"

driver="org.postgresql.Driver"

user="admin"

password="1111"/>

该示例定义一个数据源并保存在“dataSrc ”变量内。

9.6.2 用于查询的<sql:query>标签

<sql:query>标签用于查询数据库，它标签体内可以是一句查询SQL。下面看一个示例：

<sql:query var="queryResults" dataSource="${dataSrc}">

select * from table1

</sql:query>

该示例将返回查询的结果到变量“queryResults ”中，保存的结果是javax.servlet.jsp.jstl.sql.Result类型的实例。要取得结果集中的数据可以使用<c:forEach>循环来进行。下面看一个示例。

<c:forEach var="row"items="${queryResults.rows}">

<tr>

<td>${row.userName}</td>

<td>${row.passWord}</td>

</tr>

</c:forEach>

“ rows ”是javax.servlet.jsp.jstl.sql.Result实例的变量属性之一，用来表示数据库表中的“列”集合，循环时，通过“${row.XXX} ”表达式可以取得每一列的数据，“XXX ”是表中的列名。

9.6.3 用于更新的<sql:update>标签

<sql:update>标签用于更新数据库，它的标签体内可以是一句更新的SQL语句。其使用和<sql:query>标签没有什么不同。

9.6.4 用于事务处理的<sql:transaction>标签

<sql:transaction>标签用于数据库的事务处理，在该标签体内可以使用<sql:update>标签和<sql:query>标签，而<sql:transaction>标签的事务管理将作用于它们之上。

<sql:transaction>标签对于事务处理定义了read_committed、read_uncommitted、repeatable_read、serializable4个隔离级别。

9.6.5 用于事务处理的<sql:param>、<sql:dateParam>标签

这两个标签用于向SQL语句提供参数，就好像程序中预处理SQL的“? ”一样。<sql:param>标签传递除java.util.Date类型以外的所有相融参数，<sql:dateParam>标签则指定必须传递java.util.Date类型的参数。

9.7 Functions标签库

称呼Functions标签库为标签库，倒不如称呼其为函数库来得更容易理解些。因为Functions标签库并没有提供传统的标签来为JSP页面的工作服务，而是被用于EL表达式语句中。在JSP2.0规范下出现的Functions标签库为EL表达式语句提供了许多更为有用的功能。Functions标签库分为两大类，共16个函数。

q 长度函数：fn:length

q 字符串处理函数：fn:contains、fn:containsIgnoreCase、fn:endsWith、fn:escapeXml、fn:indexOf、fn:join、fn:replace、fn:split、fn:startsWith、fn:substring、fn:substringAfter、fn:substringBefore、fn:toLowerCase、fn:toUpperCase、fn:trim

以下是各个函数的用途和属性以及简单示例。

9.7.1 长度函数fn:length函数

长度函数fn:length的出现有重要的意义。在JSTL1.0中，有一个功能被忽略了，那就是对集合的长度取值。虽然java.util.Collection接口定义了size方法，但是该方法不是一个标准的JavaBean属性方法（没有get,set方法），因此，无法通过EL表达式“${collection.size} ”来轻松取得。

fn:length函数正是为了解决这个问题而被设计出来的。它的参数为input，将计算通过该属性传入的对象长度。该对象应该为集合类型或String类型。其返回结果是一个int类型的值。下面看一个示例。

<%ArrayList arrayList1 = new ArrayList();

arrayList1.add("aa");

arrayList1.add("bb");

arrayList1.add("cc");

<%request.getSession().setAttribute("arrayList1",arrayList1);%>

${fn:length(sessionScope.arrayList1)}

假设一个ArrayList类型的实例“arrayList1 ”，并为其添加三个字符串对象，使用fn:length函数后就可以取得返回结果为“3 ”。

9.7.2 判断函数fn:contains函数

fn:contains函数用来判断源字符串是否包含子字符串。它包括string和substring两个参数，它们都是String类型，分布表示源字符串和子字符串。其返回结果为一个boolean类型的值。下面看一个示例。

${fn:contains("ABC", "a")}<br>

${fn:contains("ABC", "A")}<br>

前者返回“false ”，后者返回“true ”。

9.7.3 fn:containsIgnoreCase函数

fn:containsIgnoreCase函数与fn:contains函数的功能差不多，唯一的区别是fn:containsIgnoreCase函数对于子字符串的包含比较将忽略大小写。它与fn:contains函数相同，包括string和substring两个参数，并返回一个boolean类型的值。下面看一个示例。

${fn:containsIgnoreCase("ABC","a")}<br>

${fn:containsIgnoreCase("ABC","A")}<br>

前者和后者都会返回“true ”。

9.7.4 词头判断函数fn:startsWith函数

fn:startsWith函数用来判断源字符串是否符合一连串的特定词头。它除了包含一个string参数外，还包含一个subffx参数，表示词头字符串，同样是String类型。该函数返回一个boolean类型的值。下面看一个示例。

${fn:startsWith ("ABC", "ab")}<br>

${fn:startsWith ("ABC", "AB")}<br>

前者返回“false ”，后者返回“true ”。

9.7.5 词尾判断函数fn:endsWith函数

fn:endsWith函数用来判断源字符串是否符合一连串的特定词尾。它与fn:startsWith函数相同，包括string和subffx两个参数，并返回一个boolean类型的值。下面看一个示例。

${fn:endsWith("ABC", "bc")}<br>

${fn:endsWith("ABC", "BC")}<br>

前者返回“false ”，后者返回“true ”。

9.7.6 字符实体转换函数fn:escapeXml函数

fn:escapeXml函数用于将所有特殊字符转化为字符实体码。它只包含一个string参数，返回一个String类型的值。

9.7.8 字符匹配函数fn:indexOf函数

fn:indexOf函数用于取得子字符串与源字符串匹配的开始位置，若子字符串与源字符串中的内容没有匹配成功将返回“-1 ”。它包括string和substring两个参数，返回结果为int类型。下面看一个示例。

${fn:indexOf("ABCD","aBC")}<br>

${fn:indexOf("ABCD","BC")}<br>

前者由于没有匹配成功，所以返回-1，后者匹配成功将返回位置的下标，为1。

9.7.9 分隔符函数fn:join函数

fn:join函数允许为一个字符串数组中的每一个字符串加上分隔符，并连接起来。它的参数、返回结果和描述如表9.25所示：

表9.25　fn:join函数

参数	描述
array	字符串数组。其类型必须为String[]类型
separator	分隔符。其类型必须为String类型
返回结果	返回一个String类型的值

下面看一个示例。

<% String[] stringArray ={"a","b","c"}; %>

<%request.getSession().setAttribute("stringArray",stringArray);%>

${fn:join(sessionScope.stringArray,"")}<br>

定义数组并放置到Session中，然后通过Session得到该字符串数组，使用fn:join函数并传入分隔符“; ”，得到的结果为“a;b;c ”。

9.7.10 替换函数fn:replace函数

fn:replace函数允许为源字符串做替换的工作。它的参数、返回结果和描述如表9.26所示：

表9.26　fn:replace函数

参数	描述
inputString	源字符串。其类型必须为String类型
beforeSubstring	指定被替换字符串。其类型必须为String类型
afterSubstring	指定替换字符串。其类型必须为String类型
返回结果	返回一个String类型的值

下面看一个示例。

${fn:replace("ABC","A","B")}<br>

将“ABC ”字符串替换为“BBC ”，在“ABC ”字符串中用“B ”替换了“A ”。

9.7.11 分隔符转换数组函数fn:split函数

fn:split函数用于将一组由分隔符分隔的字符串转换成字符串数组。它的参数、返回结果和描述如表9.27所示：

表9.27　fn:split函数

参数	描述
string	源字符串。其类型必须为String类型
delimiters	指定分隔符。其类型必须为String类型
返回结果	返回一个String[]类型的值

下面看一个示例。

${fn:split("A,B,C",",")}<br>

将“A,B,C ”字符串转换为数组{A,B,C}。

9.7.12 字符串截取函数fn:substring函数

fn:substring函数用于截取字符串。它的参数、返回结果和描述如表9.28所示：

表9.28　fn:substring函数

参数	描述
string	源字符串。其类型必须为String类型
beginIndex	指定起始下标（值从0开始）。其类型必须为int类型
endIndex	指定结束下标（值从0开始）。其类型必须为int类型
返回结果	返回一个String类型的值

下面看一个示例。

${fn:substring("ABC","1","2")}<br>

截取结果为“B ”。

9.7.14 起始到定位截取字符串函数fn:substringBefore函数

fn:substringBefore函数允许截取源字符从开始到某个字符串。它的参数和fn:substringAfter函数相同，不同的是substring表示的是结束字符串。下面看一个示例。

${fn:substringBefore("ABCD","BC")}<br>

截取的结果为“A ”。

9.7.15 小写转换函数fn:toLowerCase函数

fn:toLowerCase函数允许将源字符串中的字符全部转换成小写字符。它只有一个表示源字符串的参数string，函数返回一个String类型的值。下面看一个示例。

${fn:toLowerCase("ABCD")}<br>

转换的结果为“abcd ”。

9.7.16大写转换函数fn:toUpperCase函数

fn:toUpperCase函数允许将源字符串中的字符全部转换成大写字符。它与fn:toLowerCase函数相同，也只有一个String参数，并返回一个String类型的值。下面看一个示例。

${fn:toUpperCase("abcd")}<br>

转换的结果为“ABCD ”。

9.7.17空格删除函数fn:trim函数

fn:trim函数将删除源字符串中结尾部分的“空格”以产生一个新的字符串。它与fn:toLowerCase函数相同，只有一个String参数，并返回一个String类型的值。下面看一个示例。

${fn:trim("AB C ")}D<br>

转换的结果为“AB CD ”，注意，它将只删除词尾的空格而不是全部，因此“B ”和“C ”之间仍然留有一个空格。

9.8 Struts与 JSTL

9.8.1 JSTL与Struts协同工作

作为服务器端表示层MVC经典框架的Struts，其突出表现就是在表示层页面流转方面。虽然在显示的视图层，Struts框架提供了一组功能强大的标签库来帮助运用。但是这组标签库还是比较复杂，例如要取得一个Session中的JavaBean，需要做两个步骤的动作。

（1）使用<bean:define>标签来定义一个目标JavaBean的标识，并从Session中取得源JavaBean赋给目标JavaBean。若该JavaBean本身是String类型，则只需要设置它的name属性，否则还需要设置property属性。

（2）使用<bean:write>标签将该JavaBean的变量属性显示出来。若该JavaBean本身是String类型，则只需要设置它的name属性，否则还需要设置property属性。

下面看一个示例，假设Session中有一个参数为“TEST ”，其值为String类型的字符串“hello ”。那么使用Struts框架的<bean>标签库的代码就应该是这样：

<bean:define id="test" name="TEST"scope="session"/>

<bean:write name="test"/>

定义一个目标JavaBean的标识“test ”，然后将从Session中的参数“TEST ”所取得的源JavaBean的实例赋给目标JavaBean。<bean:write>标签会根据<bean:define>标签的id属性设置自身的name属性，来获取目标JavaBean并显示出来。由于它们操作的是String类型的字符串，因此编码还算比较简单。可是，如果它们操作的是一个非String类型的JavaBean，那么编码就比较麻烦了。

如果使用的是JSTL，这部分的操作就十分简单了，仅仅通过EL表达式语言就可以完成了，转换成EL表达式的操作编码如下：

${sessionScope.TEST}

转换成JSTL，只要一句表达式就已经完成了<bean>标签库需要用两个标签和许多属性才能完成的工作。即使使用的是JavaBean中的属性，JSTL表达式也只需要再加个“. ”操作符而已。

使用JSTL中的EL表达式和JSTL标签库中的标签，可以简化Struts标签库中许多标签的操作。下面就根据具体的对比来进行介绍。

9.8.2 JSTL VS Struts Bean标签库：

Struts的Bean标签库在EL表达式没有出现前是十分常用的，无论从Session、request、page或是其他作用范围（Scope）中取得参数、或者从标准JavaBean中读取变量属性都处理得得心应手。然而，在EL表达式出现之后，Struts Bean标签库的标签在操作的时候就显示出了烦琐的缺点。因此用EL表达式来替代Struts Bean标签库中的标签是一种较好的做法。

1.<bean:define>标签和<bean:write>标签处理显示被EL表达式替换

q 原形：<bean:define>标签的作用是定义一个JavaBean类型的变量，从Scope源位置得到该JavaBean的实例。<bean:write>标签可以通过JavaBean变量来做显示的工作。

q 替换方案：利用EL表达式来替换。

q 示例比较

<bean:define>标签和<bean:write>标签的动作：

<bean:define id="javaBeanName"

name="javaBeanParameter"

property="javaBeanProperty"

scope="request"/>

<bean:write name="javaBeanName"/>

EL表达式的动作：

${requestScope.javaBeanParameter.javaBeanProperty}

或

${requestScope.javaBeanParameter['javaBeanProperty’]}

处理相同的一个动作，使用define标签，通常需要记住各种属性的功能，并有选择地根据实际情况来挑选是否需要property属性，还要指定其scope属性。而EL表达式就方便多了，直接使用默认变量pageScope、requestScope、sessionScope、applicationScope指定源JavaBean作用范围，利用“. ”操作符来指定JavaBean的名称以及利用“[] ”或“. ”来指定JavaBean中的变量属性。

q 比较结果：无论是可读性还是程序的简洁性方面，EL表达式无疑要胜过许多，唯一的缺点是EL表达式必须使用Servlet2.4以上的规范。

2.<bean:cookie>、<bean:header>、<bean:parameter>标签和<bean:write>标签处理显示被EL表达式替换

q 原形：<bean:cookie>、<bean:header>、<bean:parameter>标签的作用是，定义一个JavaBean类型的变量，从cookie、request header、request parameter中得到该JavaBean实例。<bean:write>标签可以通过JavaBean变量来做显示的工作。

q 替换方案：利用EL表达式来替换。

q 示例比较：<bean:parameter>标签的动作：

<bean:parameter id="requestString"name="requestParameterString" />

<bean:write name="requestString"/>

EL表达式的动作：

${param.requestParameterString}

q 比较结果：EL表达式默认的5个变量：cookie、header、headerValues、paramValues、param完全可以提供更方便简洁的操作。

3.<bean:include>标签被<c:import>标签替换

q 原形：<bean:include>标签的作用是定义一个String类型的变量，可以包含一个页面、一个响应或一个链接。

q 替换方案：利用<c:import>标签来替换。

q 示例比较

<bean:include>标签的动作：

<bean:include page="/MyHtml.html"id="thisurlPage" />

<c:import>标签的动作：

<c:import url="/MyHtml.html"var="thisurlPage" />

<bean:include>标签的page属性所起的作用可以由<c:import>标签来替换，二者的操作结果是一样的。

q 比较结果：这一对标签的比较没有明显区别，而<bean:include>标签有更多属性提供更多功能，因此替换并不是十分必要。

尤其是当要用到配置在 struts-config.xml中的 <global-forwards>元素进行全局转发页面时，必须使用<bean:include>标签的 forward元素来实现。

4.<bean:message>标签处理资源配置文件被<fmt:bundle>、<fmt:setBundle>、<fmt:message>标签合作替换

q 原形：<bean:message>标签是专门用来处理资源配置文件显示的，而它的资源配置文件被配置在struts-config.xml的<message-resources>元素中。

q 替换方案：利用<fmt:bundle>、<fmt:setBundle>、<fmt:message>标签合作来替换，由<fmt:bundle>、<fmt:setBundle>设置资源配置文件的实体名称，再由<fmt:message>标签负责读取显示。

q 示例比较

<bean:message>标签的动作：

<bean:message key="message.attacksolution"/>

<fmt:bundle>、<fmt:message>标签的动作：

<fmt:bundle basename="resources.application">

<fmt:message key="message.attacksolution" />

</fmt:bundle>

或<fmt:setBundle>、<fmt:message>标签的动作：

<fmt:setBundle basename="resources.application"var="resourceaApplication"/>

<fmt:message key="message.attacksolution"bundle="${resourceaApplication}"/>

q 比较结果：这一对标签对于国际化的支持都相当好，唯一最大的区别在于利用<bean:message>标签所操作的资源配置文件是配置在struts-config.xml中的，而<fmt:message>标签所操作的资源配置文件则是根据<fmt:bundle>、<fmt:setBundle>两组标签来得到的。看起来，后者的灵活性不错，但就笔者的眼光来看，前者更为规范，对于用户协作的要求也更高。试想，维护一到两个资源配置文件与维护一大堆资源配置文件哪个更方便呢？自然是前者了，因此除非是不依赖Struts框架的应用，否则最好使用<bean:message>标签。

9.8.3 JSTL VS Struts Logic标签库

StrutsLogic标签库中的标签在页面显示时是时常被用到的，但是常用的却不一定是最好用的，有了JSTL标签库和EL表达式后，许多Struts Logic标签库的标签可以被简单替换。

1.所有判断标签被EL表达式和<c:if>标签替换

q 原形：判断标签有一个特点，就是需要取得一个实例的变量，因此通过<bean:define>标签来取得实例的变量是必须的，随后就通过各种判断标签来完成判断的工作。常用的判断标签如表9.30所示：

表9.30 常用判断标签

标签名	描述
empty	判断变量是否为空
notEmpty	与empty标签正好相反
equal	判断变量是否与指定的相同
notEqual	与equal标签正好相反
lessThan	判断变量是否比指定的小
greaterThan	判断变量是否比指定的大
lessEqual	判断变量是否小于等于指定的值
greaterEqual	判断变量是否大于等于指定的值
present	检查header、request parameter 、cookie、JavaBean或JavaBean propertie不存在或等于null的时候，判断成功
notPresent	与present标签正好相反
match	比较String类型字符串是否与指定的相同
notMatch	与match标签正好相反

q 替换方案：利用EL表达式和<c:if>标签来替换。

q 示例比较：判断标签的动作：

<bean:define id="javaBeanName"

name="javaBeanParameter"

property="attack_event_code"

scope="request"/>

<logic:notEmpty name="javaBeanParameter">

javaBeanParameter not empty

</logic:notEmpty>

EL表达式和<c:if>标签的动作：

<c:iftest="${requestScope.javaBeanParameter.attack_event_code != null

&& requestScope.javaBeanParameter.attack_event_code!= ''”}>

javaBeanParameter not empty

</c:if>

EL表达式利用操作符来完成判断动作，然后通过<c:if>标签来根据判断结果处理对应工作。

q 比较结果：EL表达式的操作符对判断的贡献很大，EL表达式的灵活性是Struts判断标签无法比拟的，任何判断标签都可以通过表达式来实现。<c:if>标签还可以将判断的结果保存为一个变量，随时为之后的页面处理服务。

反观Struts框架的判断标签，在工作之前必须先定义被判断的变量，而判断后又无法保存判断结果，这样的程序设计远不如EL表达式和<c:if>标签的协作来得强大。因此使用EL表达式和<c:if>标签来替换判断标签是更好的选择。

2.<logic:iterate>标签被<c:forEach>标签和EL表达式替换

q 原形：<logic:iterate>标签用来对集合对象的迭代，可以依次从该集合中取得所需要的对象。

q 替换方案：利用<c:forEach>标签和EL表达式的协作替换<logic:iterate>标签。

q 示例比较

<logic:iterate>标签的动作：

<logic:iterate name="allAttackSolution"

id="attackSolution"

type="struts.sample.cap1.sample3.entity.AttackSolution">

<bean:write property="attack_event_code"name="attackSolution"/>

<bean:write property="attack_mean" name="attackSolution"/>

<bean:write property="attack_action"name="attackSolution"/>

</logic:iterate>

<c:forEach>标签EL表达式协作的动作：

<c:forEachitems="${requestScope.allAttackSolution}"var="attackSolution">

${attackSolution.attack_event_code}

${attackSolution.attack_mean}

${attackSolution.attack_action}

</c:forEach>

两个动作都做的是同一件事，从request中得到保存的“allAttackSolution ”参数，该参数为一个集合，集合中的对象为struts.sample.cap1.sample3.entity.AttackSolution类型的实例。

<logic:iterate>标签本身可以接收集合，保存为一个变量，利用迭代子模式，使<logic:iterate>标签体中的<bean:write>标签将集合中的每个JavaBean显示出来。

提示：在本例中由于要显示JavaBean中的变量属性，因此<bean:write>标签还需要设置property属性。

替换工作的<c:forEach>标签则相对要方便些，items属性使用EL表达式取得集合，然后设置var属性作为集合中对象的变量，最后使用EL表达式来显示数据。

q 比较结果：

值得注意的一个地方是，<logic:iterate>标签必须为集合中的对象指定类型，因为标签库处理时会将集合中的对象作为Object类型得到，然后需要读取type属性定义的Java类为它强制转型。

而<c:forEach>标签则完全不用，只要符合标准JavaBean（为变量属性提供get、set方法）的对象都可以通过EL表达式来从var属性定义的变量中取得该JavaBean的变量属性。

因此<c:forEach>标签和EL表达式的方式更加简单，也更加灵活。

当然，熟悉<logic:iterate>标的程序设计者也可以将<bean:write>标签替换为EL表达式而仍然使用<logic:iterate>标签。代码可以是这样：

<logic:iterate name="allAttackSolution"

id="attackSolution"

type="struts.sample.cap1.sample3.entity.AttackSolution">

${attackSolution.attack_event_code}

${attackSolution.attack_mean}

${attackSolution.attack_action}

</logic:iterate>

结果一样，但这种方式比<bean:write>标签显示方式灵活多了。

3.<logic:redirect>标签被<c:redirect>和<c:param>标签替换

q 原形：<logic:redirect>标签用来转发到一个页面，并可以为转发传递参数。

q 替换方案：利用<c:redirect>和<c:param>标签的协作替换<logic:redirect>标签。

q 示例比较：<logic:iterate>标签的动作：

HashMapparamMap = new HashMap();

paramMap.put("userName", "RW");

paramMap.put("passWord", "123456");

<logic:redirect page="/MyHtml.jsp"name="paramMap" scope="request" />

<c:redirect>和<c:param>标签协作的动作：

<c:redirect url="/MyHtml.jsp">

<c:paramname="userName" value="RW"/>

<c:paramname="passWord" value="123456"/>

</c:redirect>

两个动作都做的是同一件事，都将转发到当前Web Context下的“MyHtml.jsp ”去，而且都将为它提供两个参数。最后的转发链接看起来应该如下所示：

http://localhost:8080/test/ MyHtml.jsp?userName=RW&password=123456

q 比较结果

一眼就可以看出，<logic:redirect>标签的可读性不强，它的name属性表示的是一个Map类型的变量。如果还有property属性，则name属性指的是一个标准JavaBean。property属性指的是JavaBean中的一个Map类型的变量属性，通过Map的“名值对”来为转发页面传递参数。如果转发参数是来自于一个Map或JavaBean中的Map类型变量属性，那还好，因为可以在Java类中处理。可是如果纯粹是从页面上取得某些值作为转发参数，那就困难了，必须像本示例所给出的那样，自行定义一个Map实例。这种情况下，页面就会看到Java语言的片段，既麻烦又不符合标准。

而使用<c:redirect>和<c:param>标签协作，由于包含在<c:redirect>标签体内的<c:param>标签可以有多个，因此显式地提供<c:param>标签就完成了给出转发参数的工作，即使用到JavaBean，也可以使用EL表达式来实现。

综上所述，利用<c:redirect>和<c:param>标签来代替<logic:redirect>标签是有必要的。

9.8.4 总结

Struts框架和JSTL并不是互相冲突的两种技术，虽然Struts框架提供了功能不错的标签库，但是使用JSTL可以简化Struts框架标签库复杂的地方，这对于服务器端表示层框架的Struts来说帮助很大。Struts的HTML标签库无法使用JSTL来替换，但是，使用EL表达式作为一些value属性，来做赋值的工作仍然不失为一种好的选择。因此，在JSTL已经比较成熟的今天，使用Struts框架和JSTL整合来作JSP页面将使程序设计更为轻松。

9.9 完整示例

在这一小节中，将修改在第三章中曾经给出的Struts框架示例，以Struts框架和JSTL的协同工作来实现。

对于第三章的示例，要将JSTL整合进去，需要做以下几步工作。

（1）下载JSTL并配置。

（1）修改原先的web.xml使其作为Servlet2.4的实现。

（3）修改JSP显示页面，整合JSTL和Struts标签库一起工作。

9.9.1 下载JSTL并配置

可以从http://java.sun.com/products/jsp/jstl网址中下载JSTL1.1的最新版本。要使用这些标签库需要做3个步骤的工作。

（1）将下载的jstl.jar放置到Web应用的WEB-INF的lib目录下。

（2）将下载的TLD文件放置到Web应用的WEB-INF目录下。

（3）在需要使用的JSP页面中声明该标签库。

9.9.2 修改web.xml使其作为Servlet2.4的实现

在第三章的示例中所给出的web.xml是Servlet2.3规范的，因此无法很好的支持JSTL1.1，要修改为符合Servlet2.4规范的代码。使web.xml成为Servlet2.4规范是十分容易的，需要修改的是其头部DTD声明。

在Servlet2.3之前，校验和规范web.xml都是使用DTD，因此其头部声明如下：

<?xml version="1.0"encoding="UTF-8"?>

<!DOCTYPE web-app PUBLIC "-//Sun Microsystems,Inc.//DTD Web Application 2.3//EN""http://java.sun.com/dtd/web-app_2_3.dtd">

<web-app>

…

</web-app>

而到了Servlet2.4规范，首此使用了xmlns来声明web.xml，因此其头部声明为：

<?xml version="1.0"encoding="UTF-8"?>

<web-app version="2.4"

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

所以，为了支持Servlet2.4规范，应该将第三章示例的web.xml改成如例9.6的样子。

例9.6：修改后的web.xml

<?xml version="1.0"encoding="UTF-8"?>

<web-app version="2.4"

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-app_2_4.xsd">

<filter-name>SetCharacter Encoding</filter-name>

<filter-class>struts.sample.cap1.sample3.util.SetCharacterEncodingFilter</filter-class>

<init-param>

<param-name>encoding</param-name>

<param-value>UTF-8</param-value>

</init-param>

</filter>

<filter-mapping>

<filter-name>SetCharacter Encoding</filter-name>

<url-pattern>*.do</url-pattern>

</filter-mapping>

<servlet-name>action</servlet-name>

<servlet-class>org.apache.struts.action.ActionServlet</servlet-class>

<init-param>

<param-name>config</param-name>

<param-value>/WEB-INF/struts-config.xml</param-value>

</init-param>

<init-param>

<param-name>debug</param-name>

<param-value>2</param-value>

</init-param>

<load-on-startup>1</load-on-startup>

</servlet>

<servlet-mapping>

<servlet-name>action</servlet-name>

<url-pattern>*.do</url-pattern>

</servlet-mapping>

<welcome-file-list>

<welcome-file>setSolution.jsp</welcome-file>

</welcome-file-list>

<taglib-uri>/WEB-INF/struts-template.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-template.tld</taglib-location>

</taglib>

<taglib-uri>/WEB-INF/struts-bean.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-bean.tld</taglib-location>

</taglib>

<taglib-uri>/WEB-INF/struts-html.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-html.tld</taglib-location>

</taglib>

<taglib-uri>/WEB-INF/struts-logic.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-logic.tld</taglib-location>

</taglib>

<taglib-uri>/WEB-INF/struts-template.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-template.tld</taglib-location>

</taglib>

<taglib-uri>/WEB-INF/struts-tiles.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-tiles.tld</taglib-location>

</taglib>

<taglib-uri>/WEB-INF/struts-nested.tld</taglib-uri>

<taglib-location>/WEB-INF/struts-nested.tld</taglib-location>

</taglib>

</web-app>

修改的地方不多，仅仅是头部的声明。其他地方完全不必改动，这样的web.xml已经支持了Servlet2.4规范了。

9.9.3 JSP部分：<logic:notEmpty>和<c:if>标签

对于JSP显示页面的修改是整合的核心部分，在第三章示例的showAttackSolution.jsp中出现了这样的语句：

<logic:notEmpty name="allAttackSolution">

...

</logic:notEmpty>

将类型为ArrayList的变量“allAttackSolution ”从作用范围中取出，利用<logic:notEmpty>标签判断该ArrayList是否为空。

根据之前讨论的“所有判断标签被EL表达式和<c:if>标签替换”，可以利用<c:if>标签和EL表达式来修改该段JSP代码。

修改后的结果如下：

<c:if test="${(requestScope.allAttackSolution !=null)

&& fn:length(requestScope.allAttackSolution) !=0}">

...

</c:if>

<logic:notEmpty>标签其本身具有多种功能：

q 一是判断是否为null。

q 二是当它为String类型的变量时，判断字符串长度是否为0。

q 三是当它为集合类型的变量时，利用集合类的isEmpty方法可以判断是否是一个空的集合。

本示例既然要在替换后与替换前的工作一致，就应该对集合做两个判断：

q 一是该集合不为null。

q 二是该集合中的对象数量不为0。

“!=null ”的EL表达式实现了集合实例不为null的判断；fn:length()函数实现了集合内对象数量不为0的判断，两个判断用“&& ”连接起来就实现了<logic:notEmpty>标签对于集合判断的工作。

在这里应该利用“<logic:notEmpty>标签”，还是利用“EL表达式和<c:if>标签”呢？<logic:notEmpty>标签相对来说可读性更强些，EL表达式作为判断条件则可读性稍差些。然而，这些仅是就本示例的改动而言的，其他情况下，利用EL表达式和<c:if>标签还是有其优势的。

9.9.4 JSP部分：<logic:iterate>和<c:forEach>标签

在第三章示例的showAttackSolution.jsp中出现了这样的使用：

<logic:iterate name="allAttackSolution"

id="attackSolution"

type="struts.sample.cap1.sample3.entity.AttackSolution">

<tr>

<bean:write property="attack_event_code"name="attackSolution" />

</td>

<bean:write property="attack_mean" name="attackSolution"/>

</td>

<bean:write property="attack_action"name="attackSolution" />

</td>

<input type="button"

onclick="del('<%=attackSolution.getAttack_event_code()%>');"

value="<bean:messagekey="message.delete"/>">

</td>

</tr>

</logic:iterate>

由于在Action中将显示的内容作为ArrayList类型的实例保存在request中，因此这段JSP页面标签的工作是：

（1）利用<logic:iterate>标签对保存在ArrayList实例中的所有对象进行循环取得。

（2）ArrayList类型实例中的对象为struts.sample.cap1.sample3.entity.AttackSolution类型，AttackSolution Java类中的变量属性都有get、set方法，因此可以被认为是一个标准的JavaBean。利用<bean:write>标签将AttackSolution实例的变量属性读取出来，并显示。

根据之前讨论的“<logic:iterate>标签被<c:forEach>标签和EL表达式替换”，可以利用<c:forEach>标签和EL表达式来修改该段JSP代码。修改的方式有两种：

q 完全使用<c:forEach>标签和EL表达式来替换全部。

q 仅使用EL表达式来替换<bean:write>标签。

1.<c:forEach>标签和EL表达式

<c:forEach>标签和EL表达式：

<c:forEachitems="${requestScope.allAttackSolution}"

var="attackSolution">

<tr>

${attackSolution.attack_event_code}

</td>

${attackSolution.attack_mean}

</td>

${attackSolution.attack_action}

</td>

<input type="button"

onclick="del('${attackSolution.attack_event_code}');"

value="<bean:messagekey="message.delete"/>">

</td>

</tr>

</c:forEach>

这种修改方式将屏弃Struts框架的<logic:iterate>标签，而以<c:forEach>标签来作为循环迭代的工作。它的最大优点是无需关注集合中的对象类型，只要保证该对象是一个标准的JavaBean就可以了。

2.使用EL表达式来替换<bean:write>标签

<logic:iterate name="allAttackSolution"

id="attackSolution"

type="struts.sample.cap1.sample3.entity.AttackSolution">

<tr>

${attackSolution.attack_event_code}

</td>

${attackSolution.attack_mean}

</td>

${attackSolution.attack_action}

</td>

<input type="button"

onclick="del('${attackSolution.attack_event_code}');"

value="<bean:messagekey="message.delete"/>">

</td>

</tr>

</logic:iterate>

这种方式对原来的代码没有做多大的改动，依然会使用<logic:iterate>标签来作为循环标签。不过对于原来使用<bean:write>标签做显示功能的地方，摒弃了<bean:write>标签而直接使用EL表达式。灵活的EL表达式对页面显示逻辑有很大帮助，这种方式比较适合熟悉<logic:iterate>标签的程序设计者。

9.9.5 完整的JSP

下面看一个完整的修改后JSP页面的代码，注释掉的是被替换之前的代码，读者可以比较一下两种实现方法。请见例9.7。

例9.7：修改后showAttackSolution.jsp。

<%@ page contentType="text/html;charset=utf-8"%>

<%@ taglib uri="/WEB-INF/struts-logic.tld"prefix="logic" %>

<%@ taglib uri="/WEB-INF/struts-html.tld"prefix="html" %>

<%@ taglib uri="/WEB-INF/struts-bean.tld"prefix="bean" %>

<%@ taglib prefix="c"uri="http://java.sun.com/jsp/jstl/core"%>

<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>

<html>

<head>

...

</head>

<body>

<table>

<html:errors/>

</table>

<bean:message key="message.attackcode"/>:

<bean:message key="message.attackdesc"/>:

<bean:messagekey="message.attacksolution"/>:

<p/>

<html:formaction="AddAttackSolutionAction.do">

<html:hiddenproperty="attack_event_code"/>

<html:hiddenproperty="attack_mean"/>

<html:hiddenproperty="attack_action"/>

<inputtype="button" onclick="add();" value="<bean:messagekey="message.add"/>">

<inputtype="button"

onclick="search();"

value="<bean:messagekey="message.search"/>">

</html:form>

<tr>

<td style="background-color:#808080;font-size:12pt;color:#ffffff;font-weight:

bold;line-height:15pt;border:1px solid #808080;">

<bean:message key="message.attackcode"/>

</td>

<td style="background-color:#808080;font-size:12pt;color:#ffffff;font-weight:

bold;line-height:15pt;border:1px solid #808080;">

<bean:message key="message.attackdesc"/>

</td>

<td style="background-color:#808080;font-size:12pt;color:#ffffff;font-weight:

bold;line-height:15pt;border:1px solid #808080;">

<bean:message key="message.attacksolution"/>

</td>

<td style="background-color:#808080;font-size:12pt;color:#ffffff;font-weight:

bold;line-height:15pt;border:1px solid #808080;">

<bean:message key="message.delete"/>

</td>

</tr>

<!--

<logic:notEmpty name="allAttackSolution">

<logic:iterate name="allAttackSolution"

id="attackSolution"

type="struts.sample.cap1.sample3.entity.AttackSolution">

<tr>

<bean:write property="attack_event_code"

name="attackSolution"/>

</td>

<bean:write property="attack_mean"name="attackSolution"/>

</td>

<bean:write property="attack_action"name="attackSolution"/>

</td>

<input type="button"

onclick="del('

<bean:write

property="attack_event_code"

name="attackSolution"/>');"

value="<bean:messagekey="message.delete"/>">

</td>

</tr>

</logic:iterate>

</logic:notEmpty>

-->

<!--

<logic:notEmpty name="allAttackSolution">

<logic:iterate name="allAttackSolution"

id="attackSolution"

type="struts.sample.cap1.sample3.entity.AttackSolution">

<tr>

${attackSolution.attack_event_code}

</td>

${attackSolution.attack_mean}

</td>

${attackSolution.attack_action}

</td>

<input type="button"

onclick="del('${attackSolution.attack_event_code}');"

value="<bean:message key="message.delete"/>">

</td>

</tr>

</logic:iterate>

</logic:notEmpty>

-->

<c:iftest="${(requestScope.allAttackSolution != null)

&& fn:length(requestScope.allAttackSolution) !=0}">

<c:forEach items="${requestScope.allAttackSolution}"var="attackSolution">

<tr>

${attackSolution.attack_event_code}

</td>

${attackSolution.attack_mean}

</td>

${attackSolution.attack_action}

</td>

<input type="button"

onclick="del('${attackSolution.attack_event_code}');"

value="<bean:messagekey="message.delete"/>">

</td>

</tr>

</c:forEach>

</c:if>

</table>

</body>

</html>

可以看到，在这个被修改的JSP页面代码中，利用了Struts框架提供的标签来实现提交部分的工作以及国际化资源配置文件读取显示的工作，也利用JSTL的标签库和EL表达式来实现页面逻辑部分的工作。

在JSP页面使用JSTL是一种规范，也是一件令人兴奋的事情，因为它使JSP部分的程序设计变得更加有效合理。

posted @ 2013-08-23 13:58 alaricblog 阅读(1128) 评论(0) 编辑收藏举报

刷新页面返回顶部

JSTL

公告