JSTL标签

 

  JSTL（JSP Standard Tag Library ，JSP标准标签库)是一个不断完善的开放源代码的JSP标签库，是由apache的jakarta小组来维护的。JSTL只能运行在支持JSP1.2和Servlet2.3规范的容器上，如tomcat 4.x。在JSP 2.0中也是作为标准支持的。

 

定义

　JSTL 1.0 发布于 2002 年 6 月，由四个定制标记库（core、format、xml 和 sql）和一对通用标记库验证器（ScriptFreeTLV 和 PermittedTaglibsTLV）组成。core 标记库提供了定制操作，通过限制了作用域的变量管理数据，以及执行页面内容的迭代和条件操作。它还提供了用来生成和操作 URL 的标记。顾名思义，format 标记库定义了用来格式化数据（尤其是数字和日期）的操作。它还支持使用本地化资源束进行 JSP 页面的国际化。xml 库包含一些标记，这些标记用来操作通过 XML 表示的数据，而 sql 库定义了用来查询关系数据库的操作。

　　两个 JSTL 标记库验证器允许开发人员在其 JSP 应用程序中强制使用编码标准。可以配置 ScriptFreeTLV 验证器以在 JSP 页面中禁用各种类型的 JSP 脚本元素 — scriptlet、表达式和声明。类似地，PermittedTaglibsTLV 验证器可以用来限制可能由应用程序的 JSP 页面访问的定制标记库集（包括 JSTL 标记库）。

　　尽管 JSTL 最终将会成为 J2EE 平台的必需组件，但目前只有少数应用程序服务器包括它。JSTL 1.0 的参考实现可作为 Apache 软件基金会（Apache Software Foundation）的 Jakarta Taglibs 项目（请参阅参考资料）的一部分而获得。可以将该参考实现中的定制标记库合并到任何支持 JSP 1.2 和 Servlet 2.3 规范的服务器，以添加对 JSTL 的支持。

　　如果要使用JSTL，则必须将jstl.jar和 standard.jar文件放到classpath中，如果你还需要使用XML processing及Database access (SQL)标签，还要将相关JAR文件放到classpath中，这些JAR文件全部存在于下载回来的zip文件中。这个zip文件可以从http://jakarta.apacheorg/builds/jakarta-taglibs/releases/standard/jakarta-taglibs-standard-1.0.zip下载。

 

 

stl的使用条件

 

　　jstl带来的优雅编程体验人所皆知，在java社区蒸蒸日上的今天使用jstl已无需考虑很多问题，我们可以用myeclipse等java 集成开发环境轻松搭建一个jstl的web项目。即便有了myeclipse这么得力的工具帮我们快速开发web项目，但是有一些知识我们必须了解的 ---- 那就是jstl与servlet版本，以及jsp版本之间的依赖关系。

　　以下列出jstl各个版本与jsp及servlet版本之间的依赖关系。

 

版本号 JSTL 版本 要求（必须满足此条件） 获取Taglib途径

Standard 1.2 JSTL 1.2 （尚未经过JCP认证） Servlet 2.5, JavaServer Pages 2.1 subversion

Standard 1.1 JSTL 1.1 Servlet 2.4, JavaServer Pages 2.0 下载

Standard 1.0 JSTL 1.0 Servlet 2.3, JavaServer Pages 1.2 下载

 

JSTL的优点

 

　　1、 在应用程序服务器之间提供了一致的接口，最大程度地提高了WEB应用在各应用服务器之间的移植。

　　2、 简化了JSP和WEB应用程序的开发。

 

 

详细介绍

 

　　JSP 标准标签库（JSP Standard Tag Library，JSTL）是一个实现 Web 应用程序中常见的通用功能的定制标记库集，这些功能包括迭代和条件判断、数据管理格式化、XML 操作以及数据库访问。在 developerWorks 上其新系列的第一篇文章中，软件工程师 Mark Kolb 向您展示了如何使用 JSTL 标记来避免在 JSP 页面中使用脚本编制元素。您还将了解如何通过从表示层删除源代码来简化软件维护。最后，您将了解 JSTL 经过简化的表达式语言，它允许在不必使用功能齐全的编程语言的情况下对 JSTL 操作指定动态属性值。

　　JavaServer Pages（JSP）是用于 J2EE 平台的标准表示层技术。JSP 技术提供了用于执行计算（这些计算用来动态地生成页面内容）的脚本编制元素和操作。脚本编制元素允许在 JSP 页面中包括程序源代码，在为响应用户请求而呈现页面时可以执行这些源代码。操作将计算操作封装到很象 HTML 或 XML 标记的标记中，JSP 页面的模板文本通常包含这些标记。JSP 规范只将几种操作定义成了标准，但从 JSP 1.1 开始，开发人员已经能够以定制标记库的方式创建其自己的操作了。

　　JSP 标准标记库（JSTL）是 JSP 1.2 定制标记库集，这些标记库实现大量服务器端 Java 应用程序常用的基本功能。通过为典型表示层任务（如数据格式化和迭代或条件内容）提供标准实现，JSTL 使 JSP 作者可以专注于特定于应用程序的开发需求，而不是为这些通用操作“另起炉灶”。

　　当然，您可以使用 JSP 脚本编制元素（scriptlet、表达式和声明）来实现此类任务。例如，可以使用三个 scriptlet 实现条件内容，清单 1 中着重显示了这三个 scriptlet。但是，因为脚本编制元素依赖于在页面中嵌入程序源代码（通常是 Java 代码），所以对于使用这些脚本编制元素的 JSP 页面，其软件维护任务的复杂度大大增加了。例如，清单 1 中的 scriptlet 示例严格地依赖于花括号的正确匹配。如果不经意间引入了一个语法错误，则条件内容中的嵌套其它 scriptlet 可能会造成严重破坏，并且在 JSP 容器编译该页面时，要使所产生的错误信息有意义可能会很困难。

　　清单 1. 通过 scriptlet 实现条件内容

　　<% if (user.getRole() == "member")) { %>

　　<p>Welcome, member!</p>

　　<% } else { %>

　　<p>Welcome, guest!</p>

　　<% } %>

　　修正此类问题通常需要相当丰富的编程经验。尽管通常会由十分精通页面布局和图形设计的设计人员来开发和维护 JSP，但是同一页面中的脚本编制元素出现问题时，需要程序员的介入。这种状况将单个文件中代码的责任分担给多人，因而使得开发、调试和增强此类 JSP 页面成为很麻烦的任务。通过将常用功能包装到定制标记库的标准集合中，JSTL 使 JSP 作者可以减少对编制脚本元素的需求，甚至可以不需要它们，并避免了相关的维护成本。

　　JSTL 1.0

　　JSTL 1.0 发布于 2002 年 6 月，由四个定制标记库（ core 、 format 、 xml 和 sql ）和一对通用标记库验证器（ ScriptFreeTLV 和 PermittedTaglibsTLV ）组成。 core 标记库提供了定制操作，通过限制了作用域的变量管理数据，以及执行页面内容的迭代和条件操作。它还提供了用来生成和操作 URL 的标记。顾名思义， format 标记库定义了用来格式化数据（尤其是数字和日期）的操作。它还支持使用本地化资源束进行 JSP 页面的国际化。 xml 库包含一些标记，这些标记用来操作通过 XML 表示的数据，而 sql 库定义了用来查询关系数据库的操作。

　　两个 JSTL 标记库验证器允许开发人员在其 JSP 应用程序中强制使用编码标准。可以配置 ScriptFreeTLV 验证器以在 JSP 页面中禁用各种类型的 JSP 脚本元素 ― scriptlet、表达式和声明。类似地， PermittedTaglibsTLV 验证器可以用来限制可能由应用程序的 JSP 页面访问的定制标记库集（包括 JSTL 标记库）。

　　尽管 JSTL 最终将会成为 J2EE 平台的必需组件，但目前只有少数应用程序服务器包括它。JSTL 1.0 的参考实现可作为 Apache 软件基金会（Apache Software Foundation）的 Jakarta Taglibs 项目（请参阅 参考资料）的一部分而获得。可以将该参考实现中的定制标记库合并到任何支持 JSP 1.2 和 Servlet 2.3 规范的服务器，以添加对 JSTL 的支持。

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

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

　　在EL表达式尚未出现之前,Structs1中一直用<bean:write>输出变量内容

　　表达式语言

　　在 JSP 1.2 中，可以使用静态字符串或表达式（如果允许的话）指定 JSP 操作的属性。例如，在清单 2 中，对 <jsp:setProperty> 操作的 name 和 property 属性指定了静态值，而用表达式指定了其 value 属性。这个操作的效果是将请求参数的当前值赋予命名的 bean 特性。以这种形式使用的表达式被称为 请求时属性值（request-time attribute value），这是构建到 JSP 规范中的用于动态指定属性值的唯一机制。

　　清单 2. 合并请求时属性值的 JSP 操作

　　<jsp:setProperty name="user" property="timezonePref"

　　value='<%= request.getParameter("timezone") %>'/>

　　因为请求时属性值是用表达式指定的，所以它们往往有和其它脚本元素一样的软件维护问题。因此，JSTL 定制标记支持另一种用于指定动态属性值的机制。可以用简化的 表达式语言（EL）而不使用完整的 JSP 表达式来指定 JSTL 操作的属性值。EL 提供了一些标识符、存取器和运算符，用来检索和操作驻留在 JSP 容器中的数据。EL 在某种程度上以 EcmaScript（请参阅 参考资料）和 XML 路径语言（XML Path Language，XPath）为基础，因此页面设计人员和程序员都应该熟悉它的语法。EL 擅长寻找对象及其特性，然后对它们执行简单操作；它不是编程语言，甚至不是脚本编制语言。但是，与 JSTL 标记一起使用时，它就能使用简单而又方便的符号来表示复杂的行为。EL 表达式的格式是这样的：用美元符号（$）定界，内容包括在花括号（{}）中，如清单 3 所示。

　　清单 3. 说明 EL 表达式定界符的 JSTL 操作

　　<c:out value="${user.firstName}"/>

　　此外，您可以将多个表达式与静态文本组合在一起以通过字符串并置来构造动态属性值，如清单 4 所示。单独的表达式由标识符、存取器、文字和运算符组成。标识符用来引用存储在数据中心中的数据对象。EL 有 11 个保留标识符，对应于 11 个 EL 隐式对象。假定所有其它标识符都引用 限制了作用域的变量。存取器用来检索对象的特性或集合的元素。文字表示固定的值 ― 数字、字符、字符串、布尔型或空值。运算符允许对数据和文字进行组合以及比较。

　　清单 4. 组合静态文本和多个 EL 表达式以指定动态属性值

　　<c:out value="Hello ${user.firstName} ${user.lastName}"/>

　　限制了作用域的变量

　　JSP API 通过 <jsp:useBean> 操作允许从 JSP 容器内的四个不同作用域中存储和检索数据。JSTL 通过提供用于指定和除去这些作用域中的对象的附加操作来扩展这一能力。此外，EL 提供将这些对象作为限制了作用域的变量进行检索的内置支持。特别地，任何出现在 EL 表达式中但不对应于任何 EL 隐式对象的标识符，都被自动假定为引用存储在四个 JSP 作用域的其中某个中的对象，这四个作用域是：

　　页面作用域 　　请求作用域 　　会话作用域 　　应用程序作用域

　　您可能还记得，只有在为特定请求处理页面期间才能检索存储在该页面作用域中的对象。如果对象是存储在请求作用域中的，可以在处理所有参与处理某请求的页面期间检索这些对象（譬如在对某个请求的处理中遇到了一个或多个 <jsp:include> 或 <jsp:forward> 操作）。如果对象是存储在会话作用域中的，则在与 Web 应用程序的交互式会话期间，可以由用户访问的任何页面检索它（即，直到与该用户交互相关联的 HttpSession 对象无效为止）。可以由任何用户从任何页面访问存储在应用程序作用域中的对象，直到卸载 Web 应用程序本身为止（通常是由于关闭 JSP 容器所致）。

　　通过将字符串映射为期望作用域中的对象来将对象存储到该作用域。然后，就可以通过提供相同字符串来从该作用域检索该对象。在作用域的映射中查找字符串，并返回被映射的对象。在 Servlet API 中，将此类对象称为相应作用域的 属性。但是，在 EL 的上下文中，也将与属性相关联的字符串看作变量的名称，该变量通过属性映射的方式获得特定的值。

　　在 EL 中，与隐式对象无关联的标识符被认为是存储在四个 JSP 作用域中的名称对象。首先对页面作用域检查是否存在这样的标识符，其次对请求作用域、然后对会话作用域、最后对应用程序作用域依次进行这样的检查，然后测试该标识符的名称是否与存储在该作用域中的某个对象的名称匹配。第一个这样的匹配作为 EL 标识符的值被返回。通过这种方法，可以将 EL 标识符看作引用限制了作用域的变量。

　　从更技术的方面来说，没有映射到隐式对象的标识符是用 PageContext 实例的 findAttribute() 方法求值的，该实例表示对页面的处理，在该页面上，当前正在处理用于请求的表达式。标识符的名称作为参数传递给这个方法，然后该方法依次在四个作用域中搜索具有相同名称的属性。并将所找到的第一个匹配项作为 findAttribute() 方法的值返回。如果未在这四个作用域中找到这样的属性，则返回 null 。

　　最终，限制了作用域的变量是四个 JSP 作用域的属性，这些属性具有可以用作 EL 标识符的名称。只要对限制了作用域的变量赋予由字母数字组成的名称，就可以通过 JSP 中提供的用于设置属性的任何机制来创建它们。这包括内置的 <jsp:useBean> 操作，以及由 Servlet API 中的几个类定义的 setAttribute() 方法。此外，四个 JSTL 库中定义的许多定制标记本身就能够设置作为限制了作用域的变量使用的属性值。

　　隐式对象

　　表 1 中列出了 11 个 EL 隐式对象的标识符。不要将这些对象与 JSP 隐式对象（一共只有九个）混淆，其中只有一个对象是它们所共有的。

　　表 1. EL 隐式对象

　　类别 标识符 描述

　　JSP pageContext PageContext 实例对应于当前页面的处理

　　作用域 pageScope 与页面作用域属性的名称和值相关联的 Map 类

　　requestScope 与请求作用域属性的名称和值相关联的 Map 类

　　sessionScope 与会话作用域属性的名称和值相关联的 Map 类

　　applicationScope 与应用程序作用域属性的名称和值相关联的 Map 类

　　请求参数 param 按名称存储请求参数的主要值的 Map 类

　　paramValues 将请求参数的所有值作为 String 数组存储的 Map 类

　　请求头 header 按名称存储请求头主要值的 Map 类

　　headerValues 将请求头的所有值作为 String 数组存储的 Map 类

　　Cookie cookie 按名称存储请求附带的 cookie 的 Map 类

　　初始化参数 initParam 按名称存储 Web 应用程序上下文初始化参数的 Map 类

　　尽管 JSP 和 EL 隐式对象中只有一个公共对象（ pageContext ），但通过 EL 也可以访问其它 JSP 隐式对象。原因是 pageContext 拥有访问所有其它八个 JSP 隐式对象的特性。实际上，这是将它包括在 EL 隐式对象中的主要理由。

　　其余所有 EL 隐式对象都是映射，可以用来查找对应于名称的对象。前四个映射表示先前讨论的各种属性作用域。可以用它们来查找特定作用域中的标识符，而不用依赖于 EL 在缺省情况下使用的顺序查找过程。

　　接下来的四个映射用来获取请求参数和请求头的值。因为 HTTP 协议允许请求参数和请求头具有多个值，所以它们各有一对映射。每对中的第一个映射返回请求参数或头的主要值，通常是恰巧在实际请求中首先指定的那个值。每对中第二个映射允许检索参数或头的所有值。这些映射中的键是参数或头的名称，但这些值是 String 对象的数组，其中的每个元素都是单一参数值或头值。

　　cookie 隐式对象提供了对由请求设置的 cookie 名称的访问。这个对象将所有与请求相关联的 cookie 名称映射到表示那些 cookie 特性的 Cookie 对象。

　　最后一个 EL 隐式对象 initParam 是一个映射，它储存与 Web 应用程序相关联的所有上下文的初始化参数的名称和值。初始化参数是通过 web.xml 部署描述符文件指定的，该文件位于应用程序的 WEB-INF 目录中。

　　存取器

　　因为 EL 标识符是作为隐式对象或限制了作用域的变量（通过属性来实现）解析的，因此有必要将它们转换成 Java 对象。EL 可以自动包装和解包其相应的 Java 类中的基本类型（例如，可以在后台将 int 强制转换成 Integer 类，反之亦可），但大多数的标识符将成为指向完整的 Java 对象的指针。

　　结果是，对这些对象的特性或（在对象是数组和集合的情况下）对其元素的访问通常是令人满意的。就为了实现这种用途，EL 提供了两种不同的存取器（点运算符（ . ）和方括号运算符（ [] ）），也支持通过 EL 操作特性和元素。

　　点运算符通常用于访问对象的特性。例如，在表达式 ${user.firstName} 中，使用点运算符来访问 user 标识符所引用对象的名为 firstName 的特性。EL 使用 Java bean 约定访问对象特性，因此必须定义这个特性的 getter 方法（通常是名为 getFirstName() 的方法），以便表达式正确求值。当被访问的特性本身是对象时，可以递归地应用点运算符。例如，如果我们虚构的 user 对象有一个实现为 Java 对象的 address 特性，那么也可以用点运算符来访问这个对象的特性。例如，表达式 ${user.address.city} 将会返回这个地址对象嵌套的 city 特性。

　　方括号运算符用来检索数组和集合的元素。在数组和有序集合（也即，实现了 java.util.List 接口的集合）的情况下，把要检索的元素的下标放在方括号中。例如，表达式 ${urls[3]} 返回 urls 标识符所引用的数组或集合的第四个元素（和 Java 语言以及 JavaScript 中一样，EL 中的下标是从零开始的）。

　　对于实现 java.util.Map 接口的集合，方括号运算符使用关联的键查找存储在映射中的值。在方括号中指定键，并将相应的值作为表达式的值返回。例如，表达式 ${commands["dir"]} 返回与 commands 标识符所引用的 Map 中的 "dir" 键相关联的值。

　　对于上述两种情况，都可允许表达式出现在方括号中。对嵌套表达式求值的结果将被作为下标或键，用来检索集合或数组的适当元素。和点运算符一样，方括号运算符也可以递归应用。这使得 EL 能够从多维数组、嵌套集合或两者的任意组合中检索元素。此外，点运算符和方括号运算符还可以互操作。例如，如果数组的元素本身是对象，则可以使用方括号运算符来检索该数组的元素，并结合点运算符来检索该元素的一个特性（例如 ${urls[3].protocol} ）。

　　假定 EL 充当指定动态属性值的简化语言，EL 存取器有一个有趣的功能（与 Java 语言的存取器不同），那就是它们在应用于 null 时不抛出异常。如果应用 EL 存取器的对象（例如， ${foo.bar} 和 ${foo["bar"]} 中的 foo 标识符）是 null ，那么应用存取器的结果也是 null 。事实证明，在大多数情况下，这是一个相当有用的行为，不久您就会了解这一点。

　　最后，点运算符和方括号运算符可能实现某种程度的互换。例如，也可以使用 ${user["firstName"]} 来检索 user 对象的 firstName 特性，正如可以用 ${commands.dir} 获取与 commands 映射中的 "dir" 键相关联的值一样。

　　以下是el表达式对javabean组件、数组，Map集合、List集合中数据调用方法的简要总结：

 

数据类型 示例用法 实际调用方法

JavaBean组件 ${colorBean.red} 

${colorBean["red"]} colorBean.getRed()

数组 ${colorArray[2]} 

${colorArray["2"]} Array.get(colorArray, 2)

List colorList[2] 

colorList["2"] colorList.get(2)

Map colorMap[red] 

colorMap["red"] colorMap.get(pageContext.findAttribute("red")) 

colorMap.get("red")

运算符

　　EL 还可以通过使用标识符和存取器，遍历包含应用程序数据（通过限制了作用域的变量公开）或关于环境的信息（通过 EL 隐式对象）的对象层次结构。但是，只是访问这些数据，通常不足以实现许多 JSP 应用程序所需的表示逻辑。

　　最终，EL 还包括了几个用来操作和比较 EL 表达式所访问数据的运算符。表 2 中汇总了这些运算符。

　　表 2. EL 运算符

　　类别 运算符

　　算术运算符 + 、 - 、 * 、 / （或 div ）和 % （或 mod ）

　　关系运算符 == （或 eq ）、 != （或 ne ）、 < （或 lt ）、 > （或 gt ）、 <= （或 le ）和 >= （或 ge ）

　　逻辑运算符 && （或 and ）、 || （或 or ）和 ! （或 not ）

　　验证运算符 empty

　　算术运算符支持数值的加法、减法、乘法和除法。还提供了一个求余运算符。注：除法和求余运算符都有替代的、非符号的名称（为的是与 XPath 保持一致）。清单 5 中显示了一个演示算术运算符用法的示例表达式。对几个 EL 表达式应用算术运算符的结果是将该算术运算符应用于这些表达式返回的数值所得的结果。

　　清单 5. 利用算术运算符的 EL 表达式

　　${item.price * (1 + taxRate[user.address.zipcode])}

　　关系运算符允许比较数字或文本数据。比较的结果作为布尔值返回。逻辑运算符允许合并布尔值，返回新的布尔值。因此，可以将 EL 逻辑运算符应用于嵌套的关系或逻辑运算符的结果，如清单 6 所示。

　　清单 6. 利用关系和逻辑运算符的 EL 表达式

　　${(x >= min) && (x <= max)}

　　最后一种 EL 运算符是 empty ，它对于验证数据特别有用。 empty 运算符采用单个表达式作为其变量（也即， ${empty input} ），并返回一个布尔值，该布尔值表示对表达式求值的结果是不是“空”值。求值结果为 null 的表达式被认为是空，即无元素的集合或数组。如果参数是对长度为零的 String 求值所得的结果，则 empty 运算符也将返回 true 。

　　表 3 显示了 EL 运算符的优先级。正如清单 5 和 6 所示，可以用圆括号对表达式分组，高于普通的优先级规则。

　　表 3. EL 运算符优先级（自顶到底，从左到右）

　　[] , .

　　()

　　unary - 、 not 、 ! 、 empty

　　* 、 / 、 div 、 % 、 mod

　　+ 、binary -

　　() <</code> 、 > 、 <= 、 >= 、 lt 、 gt 、 le 、 ge

　　== 、 != 、 eq 、 ne

　　&& 、 and

　　|| 、 or

　　文字

　　在 EL 表达式中，数字、字符串、布尔值和 null 都可以被指定为文字值。字符串可以用单引号或双引号定界。布尔值被指定为 true 和 false 。

　　Taglib 伪指令

　　正如我们先前讨论的，JSTL 1.0 包括四个定制标记库。为了演示 JSTL 标记和表达式语言的交互，我们将研究几个来自 JSTL core 库的标记。和使用任何 JSP 定制标记库一样，必须在您想要使用这个库标记的任何页面中包括 taglib 伪指令。清单 7 显示了用于这个特定库的伪指令。

　　清单 7. 用于 JSTL core 库 EL 版本的 taglib 伪指令

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

　　实际上，对应于 JSTL core 库的 taglib 伪指令有两种，因为在 JSTL 1.0 中，EL 是可选的。所有四个 JSTL 1.0 定制标记库都有使用 JSP 表达式（而不是 EL）指定动态属性值的备用版本。因为这些备用库依赖于 JSP 的更传统的请求时属性值，所以它们被称为 RT库，而那些使用表达式语言的则被称为 EL 库。开发人员用不同的 taglib 伪指令来区分每个库的这两个版本。清单 8 显示了使用 core 库的 RT 版本的伪指令。但是，由于现在我们讨论的重点是 EL，所以首先需要这些伪指令。

　　清单 8. 用于 JSTL core 库 RT 版本的 taglib 伪指令

　　<%@ taglib uri="http://java.suncom/jstl/core_rt" prefix="c_rt" %>

　　变量标记

　　我们首先要考虑的 JSTL 定制标记是 <c:set> 操作。正如已经说明的，限制了作用域的变量在 JSTL 中起关键作用， <c:set> 操作提供基于标记的机制来创建和设置限制了作用域的变量。清单 9 中显示了该操作的语法，其中 var 属性指定了限制了作用域的变量的名称， scope 属性表明了该变量驻留在哪个作用域中， value 属性指定了分配给该变量的值。如果指定变量已经存在，则简单地将所指明的值赋给它。如果不存在，则创建新的限制了作用域的变量，并用该值初始化这个变量。

　　清单 9. <c:set> 操作的语法

　　<c:set var="name"

　　scope="scope"

　　value="expression"/>

　　scope 属性是可选的，其缺省值是 page 。

　　清单 10 中显示了 <c:set> 的两个示例。在第一个示例中，将会话作用域变量设置成 String 值。在第二个示例中，用表达式来设置数值：将页面作用域内名为 square 的变量赋值为名为 x 的请求参数的值的平方。

　　清单 10. <c:set> 操作示例

　　<c:set var="timezone" scope="session" value="CST"/>

　　<c:set var="square" value="${param['x'] * param['x']}"/>

　　您还可以将限制了作用域的变量的值指定为 <c:set> 操作的主体内容，而不是使用属性。使用这种方法，您可以重新编写清单 10 中的第一个示例，如清单 11 所示。此外，正如我们马上可以看到的， <c:set> 标记的主体内容本身也可以使用定制标记。 <c:set> 主体内生成的所有内容都将作为一个 String 值赋给指定变量。

　　清单 11. 通过主体内容指定 <c:set> 操作的值

　　<c:set var="timezone" scope="session">CST</c:set>

　　JSTL core 库包含第二个用于管理限制了作用域的变量的标记 ― <c:remove> 。顾名思义， <c:remove> 操作是用来删除限制了作用域的变量的，它获取两个属性。 var 属性指定待删除变量的名称， scope 属性是可选的，它表示待删除变量来自哪个作用域，缺省为 page ，如清单 12 所示。

　　清单 12. <c:remove> 操作示例 <c:remove var="timezone" scope="session"/>

　　输出

　　尽管 <c:set> 操作允许将表达式结果赋给限制了作用域的变量，但开发人员通常会希望只显示表达式的值，而不存储它。JSTL <c:out> 定制标记承担这一任务，其语法如清单 13 所示。该标记对由其 value 属性指定的表达式进行求值，然后打印结果。如果指定了可选属性 default ，那么，在对 value 属性的表达式求值所得结果为 null 或空 String 的情况下， <c:out> 将打印其值。

　　清单 13. <c:out> 操作的语法

　　<c:out value="expression"

　　default="expression"

　　escapeXml="boolean"/>

　　escapeXml 属性也是可选的。它控制当用 <c:out> 标记输出诸如“<”、“>”和“&”之类的字符（在 HTML 和 XML 中具有特殊意义）时是否应该进行转义。如果将 escapeXml 设置为 true，则会自动将这些字符转换成相应的 XML 实体（此处提到的字符分别转换成 < 、 > 和 & ）。

　　例如，假定有一个名为 user 的会话作用域变量，它是一个类的实例，该类为用户定义了两个特性： username 和 company 。每当用户访问站点时，这个对象被自动分配给会话，但直到用户实际登录后，才会设置这两个特性。假定是这种方案，请考虑清单 14 中的 JSP 片段。在用户登录之后，这个片段将显示单词“Hello”，其后是他/她的用户名和一个惊叹号。但是，在用户登录之前，由这个片段生成的内容则是短语“Hello Guest!”。在这种情况下，因为 username 特性还有待初始化，所以 <c:out> 标记将转而打印出 default 属性的值（即字符串“Guest”）。

　　清单 14. 带缺省内容的 <c:out> 操作示例

　　Hello <c:out value="${user.username}" default=="Guest"/>!

　　接下来，考虑清单 15，它使用了 <c:out> 标记的 escapeXml 属性。如果在这种情况下已经将 company 特性设置成 Java String 值 "Flynn & Sons" ，那么，实际上该操作生成的内容将是 Flynn & Sons 。如果这个操作是生成 HTML 或 XML 内容的 JSP 页面的一部分，那么，这个字符串中间的“&”符号最终可能被解释为 HTML 或 XML 控制字符，从而妨碍了对该内容的显示或解析。但是，如果将 escapeXml 属性值设置成 true ，则所生成的内容将是 Flynn & Sons 。浏览器或解析器不会因在解释时遇到这种内容而出问题。假定 HTML 和 XML 是 JSP 应用程序中最常见的内容类型，所以 escapeXml 属性的缺省值是 true 就不足为奇了。

　　清单 15. 禁用转义的 <c:out> 操作示例

　　<c:out value="${user.company}" escapeXml=="false"/>

　　用缺省值设置变量

　　除了简化动态数据的显示之外，当通过 <c:set> 设置变量值时， <c:out> 指定缺省值的能力也很有用。正如 清单 11 所示，用来赋给限制了作用域的变量的值可以指定为 <c:set> 标记的主体内容，也可以通过其值属性来指定。通过将 <c:out> 操作嵌套在 <c:set> 标记的主体内容中，变量赋值就可以利用其缺省值能力。

　　清单 16 中说明了这种方法。外部 <c:set> 标记的行为非常简单：它根据其主体内容设置会话作用域 timezone 变量的值。但是，在这种情况下，主体内容是通过 <c:out> 操作生成的。这个嵌套操作的值属性是表达式 ${cookie['tzPref'].value} ，它尝试通过 cookie 隐式对象返回名为 tzPref 的 cookie 值。（ cookie 隐式对象将 cookie 名称映射到相应的 Cookie 实例，这意味着必须通过对象的 value 特性使用点运算符来检索储存在 cookie 中的实际数据。）

　　清单 16. 合并 <c:set> 和 <c:out> 以提供缺省变量值

　　<c:set var="timezone" scope=="session">

　　<c:out value="${cookie['tzPref'].value}" default=="CST"/>

　　</c:set>

　　但是，请考虑以下情况，用户是第一次尝试使用这段代码的 Web 应用程序。结果是，请求中没有提供名为 tzPref 的 cookie。这意味着使用隐式对象的查找将返回 null ，在这种情况下整个表达式将返回 null 。因为对 <c:out> 标记的 value 属性求值的结果是 null ，所以 <c:out> 标记会转而输出对其 default 属性求值的结果。在这里是字符串 CST 。因此，实际的结果是将 timezone 限制了作用域的变量设置成用户的 tzPref cookie 中存储的时区，或者，如果没有，则使用缺省时区 CST 。

　　EL 和 JSP 2.0

　　目前，表达式语言仅可用于指定 JSTL 定制标记中的动态属性值。但 JSTL 1.0 表达式语言的一个扩展已经被提出，会把它包括到 JSP 2.0 中去，眼下正在进行最后评审。这个扩展将允许开发人员通过自己的定制标记来使用 EL。页面作者将可以在目前允许使用 JSP 表达式的任何地方使用 EL 表达式，譬如将动态值插入模板文本中： <p>Your preferred time zone is $</p> 。

　　这个 JSP 2.0 功能（就象 JSTL 本身一样）将支持页面作者进一步减少对 JSP 编制脚本元素的依赖，从而改进 JSP 应用程序的可维护性。

　　常用函数

　　fn:contains(string, substring)

　　如果参数string中包含参数substring，返回true

　　fn:containsIgnoreCase(string, substring)

　　如果参数string中包含参数substring（忽略大小写），返回true

　　fn:endsWith(string, suffix)

　　如果参数 string 以参数suffix结尾，返回true

　　fn:escapeXml(string)

　　将有特殊意义的XML (和HTML)转换为对应的XML实体字符，并返回转义后的字符

　　fn:indexOf(string, substring)

　　返回参数substring在参数string中第一次出现的位置

　　fn:join(array, separator)

　　将一个给定的数组array用给定的间隔符separator串在一起，组成一个新的字符串并返回。

　　fn:length(item)

　　返回参数item中包含元素的数量。

　　参数Item类型是普通对象、数组、Collection、Map、Iterator迭代器、Enumeration枚举对象、

　　或者String。

　　如果是String类型,返回值是String中的字符数。

　　如果是 数组类型，返回值是数组的长度。

　　如果是Collection容器类的子类，返回值是该容器类的包含元素的个数。

　　如果是Map类型，返回值是此映射中的键-值映射关系数。

　　如果是Iterator类型，返回值是Iterator中的元素个数。

　　如果是Enumeration类型，返回值是Enumeration中的元素个数

　　fn:replace(string, before, after)

　　返回一个String对象。

　　用参数after字符串替换参数string中所有出现参数before字符串的地方，并返回替换后的结果

　　fn:split(string, separator)

　　返回一个数组，以参数separator 为分割符分割参数string，分割后的每一部分就是数组的一个元素

　　fn:startsWith(string, prefix)

　　如果参数string以参数prefix开头，返回true

　　fn:substring(string, begin, end)

　　返回参数string部分字符串, 从参数begin开始到参数end位置，包括end位置的字符

　　fn:substringAfter(string, substring)

　　返回参数substring在参数string中后面的那一部分字符串

　　fn:substringBefore(string, substring)

　　返回参数substring在参数string中前面的那一部分字符串

　　fn:toLowerCase(string)

　　将参数string所有的字符变为小写，并将其返回

　　fn:toUpperCase(string)

　　将参数string所有的字符变为大写，并将其返回

　　fn:trim(string)

　　去除参数string 首尾的空格，并将其返回

　　结束语

　　EL（与四个 JSTL 定制标记库提供的操作结合起来）允许页面作者不使用脚本元素即可实现表示层逻辑。例如，对比本文开头 清单 1 中的 JSP 代码和清单 17 中显示的通过 JSTL 实现的同样功能。（JSTL core 库中其余的标记，包括 <c:choose> 及其子标记，将在本系列的下一篇文章中讨论。）尽管显然执行了条件逻辑，但是 JSTL 版本中没有 Java 语言源代码，并且标记之间的关系（尤其是关于嵌套需求）对于任何精通 HTML 语法的人都应该是熟悉的。

　　清单 17. 合并 <c:set> 和 <c:out> 以提供缺省变量值

　　<c:choose><c:when test="${user.role == 'member'}">

　　<p>Welcome, member!</p>

　　</c:when><c:otherwise>

　　<p>Welcome, guest!</p>

　　</c:otherwise></c:choose>

　　通过提供大多数 Web 应用程序常用功能的标准实现，JSTL 有助于加速开发周期。与 EL 结合起来，JSTL 可以不需要对表示层程序编写代码，这极大地简化了 JSP 应用程序的维护。

 

 

 

 

 

 

 

 

 

标准标签库JSTL

JSTL简介:

      标准标签库JSTL的全名为:Java Server Pages Standard Tag Library.

 

      JSTL主要提供了5大类标签库:

1.      核心标签库: 为日常任务提供通用支持,如显示和设置变量,重复使用一组项目,测试条件以及其他操作(如导入和重定向web页面等).

2.      国际化(I18N)标签库: 支持多种语言的引用程序.

3.      SQL标签库: 对访问和修改数据库提供标准化支持.

4.      XML标签库: 对XML文件处理和操作提供支持,包括XML节点的解析,迭代,基于XML数据的条件评估以及可扩展样式语言转换(Extensible Style Language Transformations , XSLT)的执行.

5.      函数标签库: 通过在EL表达式中调用函数标签库中的函数来实现特定的操作,例如: ${fn:contains(sring,substring)},其功能是判断string字符串中是否包含substring字符串.

 

 

JSTL标签库使用方法:

标签库                  URI                                  前缀         使用模式

核心标签库              http://java.sun.com/jstl/core        c            <c:tagname…>

国际化标签(I18N)        http://java.sun.com/jstl/fmt         fmt          <fmt:tagname…>

SQL标签库               http://java.sun.com/jstl/sql         sql          <sql:tagname…>

XML标签库               http://java.sun.com/jstl/xml         x            <x:tagname…>

函数标签库              http://java.sun.com/jstl/functions   fn           <fn:tagname…>

 

 

核心标签库

      核心标签库包括:out , set , remove , catch , if , choose , when 和 URL 等.

 

表达式操作标签:  包括:out , set , remove , catch.

 

out标签:

      核心标签库中最为基本的标签就是<c:out>,他可以在页面中显示一个字符串或者一个EL表达式的值,其功能与JSP中的<%= 表达式%>类似

      使用格式如下:

              <c: out value=”object” />

              这个标签还可以有一个体,如下:

              <c: out value=”object” >defalut value</c:out>

这表示当value属性指定的object值为null时,就会显示体中指定的值,也就是default value的值,体中也可以是jsp代码.

              <c:out>中各属性的说明如下:

      1.value : 可以指定一个字符串作为输出内容,也可以指定为EL表达式,例如:${3+5}.

      2.escapeXml : 类型为boolean , 确定 , < , > , & , ‘ , “ 等字符在结构的字符串中是否被转换成字符串实体代码,默认值是true(就是是否按html中的样式进行输出,设置true就是按照字符串原样进行输出,false就是按照html标识符进行输出)

      3.default value : 可以是字符串,也可以是一个EL表达式或者jsp表达式,如果属性(value)指定的表达式或者对象为null,那么将输出这个defalut value部分的值. 

 

set标签:

      set标签用来在某个范围(request,session或者application)内设置值,或者设置某个对象的属性值.

      Set标签使用格式如下:

      1. 使用value 属性在一个特定的范围内指定某个变量的值,其使用格式如下:

      <c:set var=”varName” value=”varValue” />

      2. 当使用value属性在一个特定范围内指定某各变量的值时,也可以包括一个体,他的作用与out标签体的作用一样,即value指定的值为null时,默认使用体中指定的值,使用的格式如下:

      <c:set var=”varName” value=”varValue” >

              default value

      </c:set>

      3. 设置某一个特定对象属性的使用格式如下:

      <c:set property=”propertyName” target=”target” value=”value”/>

      4. 在设置某个特定对象的一个属性时,也可以使用一个体,并且指定默认的值,使用格式如下:

      <c:set property=”propertyName” target=”target” value=”value”>

            default value

      </c:set>

 

      该标签中的各属性说明如下:

      1. value : 该属性指定变量或者对象中某个属性的值,并且可以是一个表达式.

      2. var : 变量名称,value属性指定的值就保存在这个变量中.

      3. scope : 设定变量的有效范围,如果不设置,默认为page.

      4. target : 设置属性的一个对象,它必须是JavaBean 或者java.util.Map对象.

      5. property : 设置对象中的一个属性.

 

remove标签

      remove标签一般和set标签配套使用,两者是相对应的,remove标签用于删除某个变量或者属性,使用格式如下:

      <c:remove var=”varName” />

      Remove标签中使用的各属性说明如下:

1.      scope : 设定这个需要删除的变量的所在范围.

2.      var : 需要删除的变量或者对象属性的名称.

如果没有scope属性,即采用默认值,就相当于调用PageContext.removeAttribute(varName)方法,如果指定了这个变量所在的范围,那么系统会调用PageContext.removeAttribute(varName,scope)方法.

 

catch标签

catch标签的功能和java中的try{…}catch{…}语句的功能很相似,它用于捕获嵌入到其中间语句抛出的异常,这个标签的使用格式如下:

              <c:catch var=”varName”>

相关操作语句 

</c:catch>  --如果操作语句中出现异常,则catch会将异常保存在 varName变量中.

 

流程控制标签: 包括: if , choose , when , otherwise 等.

 

if标签

      这个标签作用与java中的if语句作用相同,用于判断条件语句,主要的使用格式如下

      1.在<c:if> 体中不包括体的使用格式:

<c:if test=”checkCondition” var=”varName” scope=”page|request|session|application”/>

      2.当<c:if> 体中包括体时,使用格式如下:

<c:if test=”checkCondition” var=”varName” scope=”page|request|session|application”>

      body content

</c:if>

      标签中使用的属性说明:

              test : 判断条件的表达式,返回类型为true 或者 false;(也就是if的条件)

              var : 这个变量用于保存test条件表达式判断所返回的true或者false值(if条件执行后所得到的boolean值将要保存在var变量中).

              scope : 指定var变量所在的有效范围.

 

choose , when , otherwise 标签

      这些标签相当于java中的 switch , case , default 条件,使用实例如下:

      <c:set var=”num” scope=”page” value=”admin”/>

      <c:choose>

              <c:when test=”${num==’guest’}”>

                    <c:out value=”guest”/>

              </c:when>

              <c:when test=”${num==’admin’}”>

                    <c:out value=”admin”/>

              </c:when>

              <c:otherwise>

                    <c:out value=”other”/>

              </c:otherwise>

      </c:choose>

    运行jsp页面后,输出 admin

 

forEach迭代标签

该标签用来对一个collection集合中的一系列对象进行迭代输出,并且可以指定迭代次数,一般的使用格式如下:

<c:forEach items=”collection” var=”varName” >

      Body content

</c:forEach>

这个标签使用的属性描述如下:

1.      var : 也就是保存在collection集合类中的对象名称.

2.      items : 将要迭代的集合类名.

3.      varStatus : 存储迭代的状态信息,可以访问到迭代自身的信息.

4.      begin : 如果指定了begin值,就表示从items开始迭代;如果没有指定begin值,则从集合的第一个值开始迭代.

5.      end : 表示迭代到集合的end位时结束,如果没有指定end值,则表示一直迭代到集合的最后一位.

6.      step : 指定迭代的步长.

例:

      <%

              String Items[] =new String[5];

              Items[0]=”核心标签库”;

              Items[1]=”国际化标签库”;

              Items[2]=”SQL标签库”;

              Items[3]=”XML标签库”;

              Items[4]=”函数标签库”;

              Request.setAttribute(“ItemName”,Items);

%>

<B><c:out value=”不指定begin和end的迭代:”/><B><br>

<c:forEach var=”ItemName” items=”${Items}”>

       <c:out value=”${ItemName}” /><br>

</c:forEach>

 

<B><c:out value=”指定begin和end的迭代:”/><B><br>

<c:forEach var=”ItemName” items=”${Items}” begin=”1” end=”3” step=”1”>

       <c:out value=”${ItemName}” /><br>

</c:forEach>

 

<B><c:out value=”输出整个迭代的信息:”/><B><br>

<c:forEach var=”ItemName” items=”${Items}” begin=”3” end=”4” step=”1” varStatus=”s”>

       <c:out value=”${ItemName}” />的四种属性:<br>

       所在位置即索引: <c:out value=”${s.index}” /> <br>

       总共已迭代的次数: <c:out value=”${s.count}”/><br>

       是否为第一个位置: <c:out value=”${s.first}” /><br>

       是否为最后一个位置: <c:out value=”${s.last}”/>

</c:forEach>

代码说明:      s.index 用来获取计数器的值,  s.count用来获取这是第几次循环,  s.first 用来获取是否是循环开始的第一次 , s.last 用来获取是否是循环的最后一次 ,  first 和last 都返回boolean 值.

 

forTokens 标签

这个标签的作用和Java中的StringTokenizer类的作用非常相似,通过items属性来指定一个特定的字符串,然后通过delims属性指定一种分隔符(可以同时指定多个),通过指定的分隔符把items属性指定的字符串进行分组,与forEach标签一样,forTokens标签也可以指定begin和end以及step属性值.

使用格式如下:

<c:forTokens items=”stringOfTokens” delims=”delimiters” var=”varName” >

              Body content

</c:forTokens>

标签中的各个属性描述如下:

  1.      var : 进行迭代的参数名称.

  2.      items : 指定的进行标签化的字符串.

  3.      varSatus : 每次迭代的状态信息.

  4.      delims : 使用这个属性指定的分隔符来分隔items指定的字符串.

  5.      begin : 开始迭代的位置.

  6.      end : 迭代结束的位置.

  7.      step : 迭代的步长.

例:

<c:out value=”forTokens标签实例”/>

<h4>使用” | ” 作为分隔符</h4>

<c:forTokens var=”token” items=”bleu,rouge|vert,jaune|blanc,rouge” delims=”|”>

        <c:out value=”${token}”/>

</c:forTokens>

 

<h4>使用” | , ”作为分隔符</h4>

<c:forTokens var=”token” items=”bleu,rouge|vert,jaune|blanc,rouge” delims=”|,”>

        <c:out value=”${token}”/>

</c:forTokens>

代码说明: delims=”|,” , 即使用”|”和”,”同时作为分隔符进行使用.如果需要更多的分隔符就是使用 “|,./” 在引号内输出.

 

 

 

URL相关的标签:

URL相关的标签主要用来将其他文件包含进来,或者提供页面之间的重定位以及URL地址的生成,参数的输出等.一般包括如下几个标签.

<c:import>标签: 与传统JSP页面重的<jsp:include>标签类似.

<c:redirect>标签: 进行页面的重定位.

<c:url> : 主要用来重写URL地址.

<c:param> : 一般param标签会与其他标签一起配套使用,用于参数值的传递.

 

 

<c:import> 标签:

      该标签用于把其他今天文件包含到该文件当中,它与传统的<jsp:include>相类似,不同的是<jsp:include>标签只能用来包括该应用中的其他文件,而<c:import>还可以包含外部站点中的静态文件,所以它的功能更加强大.使用格式如下:

      <c:import url=”url” >

         Body content

      </c:import>

 

标签中的属性描述如下:

      url: 待引用静态文件的URL地址.

      context: 当采用相对路径访问一个外部静态文件时,这里的context指定这个外部文件的名称.

      var: 当使用字符串输出时,把输出的内容存储在这个var指定的变量中.

      scope: 指定var参数变量的有效范围.

      varReader: 这个属性指定的参数变量类型是Reader,可以用于读取文件的内容.

      charEncoding: 引入文件所采用的字符编码.

 

Import标签即可以采用相对路径也可以采用绝对路径来引用本地点中的任何静态文件,还可以使用绝对路径引用外部站点中的静态文, 甚至可以是ftp站点中的文件,例如:<c:import var=”myurl” url=”http://www.163.com” />就是引用http://www.163.com 站点的主页面.

可以把引用文件中的内容赋值给var属性指定的变量,然后进行读取,也可以赋值给varReader指定的Reader类型的变量,然后进行相应的读取.

有时引入的文件在本地显示会出现乱码,这时可以通过charEncoding来指定这些内容所采用的字符集编码.

 

<c:redirect>和<c:param>标签:

      Redirect标签用来进行页面之间的重定向,它与传统JSP程序重的<jsp:redirect>标签功能相类似,param标签是与redirect一起使用的,它用来进行参数值的传递,redirect标签的使用格式如下:

      <c:redirect url=”url” />

      在redirect标签中指定param参数的使用格式如下:

      <c:redirect url=”url” []context=”context”>

            <c:param name=”paramName” value=”value”/>

      </c:redirect>

 

例:  [通过创建c_redirect1.jsp  和 c_redirect2.jsp  两个文件说明]

      c_redirect1.jsp文件内容如下:

            <c:redirect url=”c_redirect2.jsp” >

                    <c:param name=”userName” value=”admin”/>

            </c:redirect>

 

      c_redirect2.jsp 文件内容如下:

            <body>

                    userName=<c:out value=”${param.userName}”>

            </body>

      c_redirect1.jsp页面文件内容不会显示,因为直接重定向到c_redirect2.jsp,重定向c_redirect2.jsp后,页面中输出 userName=admin

 

<c:url>标签:

      这个标签主要用来重写url地址,使用格式如下:

<c:url value=”value” />

      当进行参数传递时,使用格式如下:

<c:url value=”value” >

            <c:param name=”paramName” value=”value” />

</c:url>

 

标签中使用的属性描述如下:

      value: 将要处理的URL地址.

      context: 当使用相对路径方法指定外部文件时,这个属性指定的是外在文件的名称.

      var: 给这个URL地址起一个标识.

      Scope: 规定这个var属性所指定变量的有效范围.

 

创建一个c_url.jsp,其源代码如下:

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

      <c:url var=”url” value=”c_url2.jsp” scope=”session” >

              <c:param name=”userName” value=”admin”/>

              <c:param name=”password” value=”123456”/>

      </c:url>

      <c:out value=”${url}”/>

      <a herf=’<c:out value=”${url}”/>’>Link to other page</a>

      代码说明: url标签可以指定一个变量(var属性指定)来把url地址保存,并且可以指定这个变量的有效范围为session ,所以当需要用到这个url地址时,就可以使用session.getAttribute(varName)方法来获取这个地址,所以一般需要重复使用同一个url地址才会使用<c:url>标签的功能.

 

 

 

国际化( I18N )标签库

国际化标签包括:

      <fmt:setLocale>: 用于设置当前本地化环境,为对应的java类javax.servlet.jsp.jstl.fmt.locale配置参数值,这个指定的参数由jsp运行时维护,用于确定各个jstl标签使用的本地化环境.

      <fmt:bundle>: 指定消息资源使用的文件.

      <fmt:message>: 显示消失资源文件中指定key的消息,支持带参数的消息.

      <fmt:param>: 给带参数的消息设置参数值.

      <fmt:setBundle>: 设置消息资源文件.

 

设置本地化环境标签<fmt:setLocale>

HTML请求到达服务器时,浏览器提供的HTTP首部可以指出用户的首选本地化环境(可能是多个本地化环境的列表).这个列表放在Accept-Language HTTP首部中,jsp容器会访问这个首部信息,如果没有使用标签<fmt:setLocale>明确地指出引用本地化环境,JSTL标签就会使用这个列表中的首选本地化环境.

<fmt:setLocale>标签专门用于设置当前本地化环境,基本使用格式如下:

<fmt:setLocale value=”…locale value…” />

<fmt:setLocale>标签的属性描述如下:

      value: 这个属性是必须设置的,它用来设置本地环境名,例如en_US 或者zh_HK.

      variant: 这个属性是可选的,而且很少使用.

      scope: 指定value设置的本地化环境名的有效范围,默认为page,即本页面,如果把scope设置为session,则表示同一个用户发出的所有请求都具有相同的本地化环境.

 

执行信息资源标签<fmt:bundle>

一旦已经设置了web引用的本地化环境后,就可以使用<fmt:bundle>标签了,其体重可以包括一些调用本地化文本的<fmt:message>标签,使用格式如下:

<fmt:bundle basename=”…the bundle’s base name…” >

      <fmt:message key=”…key name…”/>

</fmt:bundle>

属性描述如下:

     Basename: 资源文件(这里使用文件,而不是类)的基名,例如,某资源文件Res_zh_CN.property,则基名为Res.

     prefix: 这个设置是可选的,如果指定这个属性,就会为标签体中嵌套的<fmt:message>标签附加一个前缀.

当<fmt:bundle>标签中嵌套<fmt:message>标签时,这时<fmt:message>标签默认使用<fmt:bundle>标签中的basename所指定的资源文件.

 

 

获取资源属性值标签<fmt:message>:

      该标签用于显示本地化的文本,它通过key属性来取得资源文件中相应的消息<fmt:message>标签的一般使用格式如下:

<fmt:message key=”…name of property…” />

    这个标签从资源文件重获取到一个消息,生成相应的一个本地化文本串,该便去重的属性描述如下:

      Key : 用于查找资源文件重相应的关键字名,它对应着一条特定的消息.

      bundle: 如果设置了这个属性,就会使用这个属性指定的资源文件,否则若嵌套在<fmt:bundle>标签重,就会直接使用<fmt:bundle>标签重basename属性指定的资源文件.

      Var : 如果指定这个属性,则把取出的消息字符串存储在这个变量中.

      Scope: 这个属性指定了var设置变量的有效范围,默认为page,然而也可以设置为session.

 

 

设置资源文件标签<fmt:setBundle>

该标签用于设置一个资源文件,并给定一个标记,以便可以通过<fmt:message>标准中指定bundle属性值来取得这个资源文件中的消息,使用格式如下:

<fmt:setBundle basename=”…the bundle’s base name…” var=”…var name…” />

      标签中的属性描述如下:

      basename : 该属性与<fmt:message>标签中的basename属性类似.

Var : 给指定的资源文件取一个变量名,以便<fmt:message>标签可以通过这个变量名来读取资源文件中的消息

Scope: 设置var属性指定的变量的有效范围.

 

 

获取参数值标签<fmt:param>:

该标签一般与<fmt:message>标签配套使用,用来在获取的消息中插入一个值.例如:资源文件中的一条消息如下:

       密码错误=”{0}的密码错误”

      <fmt:message>标签首先使用key=”密码错误”这个关键字找到以上这条消息,然后在<fmt:message>标签中使用<fmt:param>标签赋一个值来替代{0}部分.

      <fmt:param>标签的使用格式如下:

              <fmt:message ……>

                    <fmt:param value=”value”/>

              </fmt:message>

      其中value属性的值即为要的替代{0}部分的值.

 

函数(function)标签库:

      函数标签库中的标签基本分成两种:

1.      长度度量函数,例如:fn.length().  [ fn.length(“”) 就为要输出的格式表达式,结果输出0 ]

2.      字符串操作函数.

 

各类函数标签的功能:

1.      fn:contains(string,substring): 如果参数string中包含substring,则返回true.

2.      fn:containsIgnoreCase(string,substring): 如果参数string中包含substring,则返回true(忽略大小写).

3.      fn:endsWith(string,suffix): 如果参数string以参数suffix结尾,则返回true.

4.      fn:escapeXml(string): 将由特殊意义的xml(和html)转换成对应的XML character entity code并返回.

5.      fn:indexOf(string,substring): 返回参数substring在string中第一次出现的位置.

6.      fn:join(array,separator): 将一个给定的数组array用给定的间隔符separator串在一起,组成一个新的字符串并返回.

7.      fn:length(item): 返回参数item中包含元素的数量,参数item的类型是数组,collection或者string,如果是string则返回string的字符数.

8.      fn:replace(string,before,after): 返回一个String对象,用参数after字符串替换参数string中所有出现before字符串的地方,并返回替换后的结果.

9.      fn:split(string,separator): 返回一个数组,以参数separator为分隔符分隔参数string,分隔后的每一部分就是数组的一个元素.

10.  fn:startsWith(string,prefix): 如果参数string以参数prefix开头,则返回true.

11.  fn:substring(string,begin,end): 返回参数string的部分字符串,从参数begin开始到参数end结束,其中包括end位置的字符.

12.  fn:substringAfter(string,substring): 返回参数substring在参数string中后面的那一部分字符串. 

13.  fn:substringBefore(string,substring): 返回参数substring在参数string中前面的那一部分字符串.

14.  fn:toLowerCase(string): 将参数string的所有字符变为小写,并返回.

15.  fn:toUpperCase(string): 将参数string的所有字符变成大写,并返回.

16.  fn:trim(string): 将参数string的头尾空格全部去除,并返回.

 

 

 

 

 

 

 

 

 

 

 

 

SP 标准标记库（Standard Tag Library，JSTL)是一组以标准化格式实现许多通用的Web站点功能的定制标记。 JSTL的目标是为了简化JSP 页面的设计。 

 

一．配置JSTL

包括两个JAR文件，jstl.jar 和standard.jar。是什么没有必要管 

原文引入：

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

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

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

 

 

二．Core标签库

 

Core标签库主要包括了一般用途的标签、条件标签、迭代标签和URL相关的标签。在JSP页面使用Core标签，要使用taglig指令，指定引用的标签库，如下：

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

 

一般用途的标签有<c:out>、<c:set>、<c:remove>、<c:cath>

1.<c:out>

用于计算一个表达式并将结果输出。类似于JSP 中<%=%>表达式，或者是EL中$ ${el-expression}。

2.<c:set>

用于设置范围变量的值或者javabean对象的属性。

看个实际例子：

<c:set var=”username” value=”lisi” scope=”session”/>

这样就相当于设置了session。

 3.<c:remove>

相对<c:set>其作用是移除范围变量。比如

<c:remove var=”nusername” scope=”session”/>

 

4.<c:catch>

 用于捕获在其中嵌套的操作所抛出的异常对象，并将异常信息保存到变量中。

我们将有可能抛出异常的代码放置到开始标签:<c:catch>和结束标签:</c:catch>之间。如果其中代码出现异常，异常对象将被捕获，保存在var声明的变量中，该变量总是有page范围。如果没有发生异常，而var所标识的范围变量将被移除。

如果没有指定var属性，异常只是简单的被捕获，异常信息并不会被保存。

Eg：

<c:catch var=”exception”>

<%

       int i = 5;

       int j = 0;

       int k=i/j;

%>

</c:catch>

<c:out value=”${exception}” /><br>

<c:out value=”${exception.massage}”/>

 

 

后一句相当于：exception.getMessage()

 

条件标签包括<c:if><c:choose><c:when><c:otherwise>

1.<c:if>

用于实现java中的if语句功能。

<c:if test=”${user.visitCount==1}”>

       This is your first visit .

</c:if>

 

若为true，会打印中间部分。也可以声明var，方便下一步判断。

 

<c:if test=”${param.name==’admin’}” value=”result”/>

<c:out value=”${result}” />

 

2.<c:choose>

<c:choose>和<c:when>、<c:otherwise>一起实现互斥条件执行，类似于java中的if else.

<c:choose>一般作为<c:when>、<c:otherwise>的父标签。

eg：

<c:choose>

       <c:when test="${row.v_money<10000}">

              初学下海

       </c:when>

       <c:when test="${row.v_money>=10000&&row.v_money<20000}">

 

            身手小试

        </c:when>

       <c:otherwise>

              商业能手

       </c:otherwise>

</c:choose>

 

 

迭代标签 迭代标签有<c:forEach>和</c:forEach>

//遍历记录集

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

<tr class="<%=tdClass[(rank+1)%2]%>">

<td align="center"><span><%=rank%> </span></td>

<td align="center"><span ><c:out value="${row.player_name}"/></span> </td>

<td align="center"><span >￥<c:out value="${row.money}"/></span></td>

</tr>

<%rank++;%>      

</c:forEach>

也可以设定固定次数。

<c:forEach var =”i” begin=”100 “ end= “110”>

       ${i}

</c:forEach>

如果再加个step=“2”那么每次增长为2。

 

三．sql标签

 

//设置数据源：

<sql:setDataSource dataSource="proxool.breadTycoon" />

//将数据库某查询的结果声明为一个变量

<sql:query var="finalResult" >

    select player_name,money from tb_player order by money DESC LIMIT 10    

</sql:query>

       然后可以：

<c:forEach items="${ finalResult.rows}" var="row" varStatus="s">

        advCosts[${s.index}]=${row.adv_cost};

   </c:forEach>

 

      数据更新标签：

     <sql:update>   

                call proc_set_role_salespro(?,?,?,?,?);

                <sql:param value="30"/>

                <sql:param value="39"/>

                <sql:param value="<%=spID%>"/>

                <sql:param value="<%=productID%>"/>

                <sql:param value="1"/>                

     </sql:update>

 

 

四．格式化标签

<fmt: formatNumber value =”12.3” pattern=”.000”/>

将输出12.300.应用样式”.000”,将使格式化后的小数部分有3位。不足3位将以0补齐

   <fmt:formatDate value=”<%=new java.util.Date() %>” type=”date” />

 

 格式化的结果是：2007-5-27.

<fmt:formatDate value=”<%=new java.util.Date() %>” type=”time” />

格式化的结果是：9:25:11

<fmt:formatDate value=”<%=new java.util.Date() %>” type=”both” />

 

格式化的结果是： 2007-5-27 9:25:11

fn函数

JSTL1.1标签库还包含了许多其它经常使用的函数：

fn:contains(string, substring)

 如果参数string中包含参数substring，返回true

 

fn:containsIgnoreCase(string, substring)

 如果参数string中包含参数substring（忽略大小写），返回true

 

fn:endsWith(string, suffix)

 如果参数 string 以参数suffix结尾，返回true

 

fn:escapeXml(string)

 将有特殊意义的XML (和HTML)转换为对应的XML character entity code，并返回

 

fn:indexOf(string, substring)

 返回参数substring在参数string中第一次出现的位置

 

fn:join(array, separator)

 将一个给定的数组array用给定的间隔符separator串在一起，组成一个新的字符串并返回。

 

fn:length(item)

 返回参数item中包含元素的数量。参数Item类型是数组、collection或者String。如果是String类型,返回值是String中的字符数。

 

fn:replace(string, before, after)

 返回一个String对象。用参数after字符串替换参数string中所有出现参数before字符串的地方，并返回替换后的结果

 

fn:split(string, separator)

 返回一个数组，以参数separator 为分割符分割参数string，分割后的每一部分就是数组的一个元素

 

fn:startsWith(string, prefix)

 如果参数string以参数prefix开头，返回true

 

fn:substring(string, begin, end)

 返回参数string部分字符串, 从参数begin开始到参数end位置，包括end位置的字符

 

fn:substringAfter(string, substring)

 返回参数substring在参数string中后面的那一部分字符串

 

fn:substringBefore(string, substring)

 返回参数substring在参数string中前面的那一部分字符串

 

fn:toLowerCase(string)

 将参数string所有的字符变为小写，并将其返回

 

fn:toUpperCase(string)

 将参数string所有的字符变为大写，并将其返回

 

fn:trim(string)

 去除参数string 首尾的空格，并将其返回

 主要是替换

<sql:setDataSource var="dataSrc"

    url="jdbc:jtds:sqlserver://localhost/LOG_DB" driver="net.sourceforge.jtds.jdbc.Driver"

    user="sa" password="admin"/>

    <%-- Set number of rows to process --%>

    <c:set var="noOfRows" value="100" />

    <c:set var="msg" value="select top 100 * from L_ips_tb where id> (select max (id) from

(select top ard id from L_ips_tb order by id) as T

)     order by id"/>

 <c:set var="test" value="${fn:replace(msg,'ard',100)}" />

 <c:out value="${test}" />

    <sql:query var="empList"

      sql="${test}"       dataSource="${dataSrc}"

    />

   <c:out value="${fn:length(empList.rows)}"/>

使用反射

<c:setvar="arrayvalue"value="ID,SrcIP"/>

<c:setvar="delim"value=","/>

<c:setvar="array"value="${fn:split(arrayvalue,delim)}"/>

<c:setvar="count"value="${fn:length(array)}"/>

array是一个String数组，loghistory是一个Map

<c:forEachvar="loghistory"items="${loghistory}"varStatus="statusindex">

<c:forEachbegin="0"end="${count-1}""varStatus="index">

<c:outvalue="${loghistory[array[index.index]]}"/>

</c:forEach>

<c:choose>

使用二维数组

<c:forEach items="${applicationScope[param.answersMapName]}"

          var="a">

          ${a.key}) ${a.value}:

          ${applicationScope[param.votesMapName][a.key]}<br>

        </c:forEach〉