JSTL详解

 一JSTL概述

       (1)什么是JSTL

       JSTL是Java中的一个定制标记库集。JSP标准标签库(JSTL)是一个JSP标签集合，它封装了JSP应用的通用核心功

能。JSTL支持通用的、结构化的任务，比如迭代，条件判断，XML文档操作，国际化标签，SQL标签。 除了这些，它

还提供了一个框架来使用集成JSTL的自定义标签。

       (2)为什么要使用JSTL

       1)实现了JSP页面的代码复用。基于标签库原理，重复率较高的代码块支持复用，提高效率。

       2)书写JSP页面时可读性更强。长得像XML，方便前端查看和参与开发。

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

       4)简化了JSP和WEB应用程序的开发。

       (3)简单实例演示

       假如我们要做一个这样的效果：

       用户在页面的文本框中输入自己的角色(user or admin)，然后点击登录按钮，如果输入的是user，那么结果是：

       

       如果输入的是admin，那么显示的结果是：

       

       同样的我们再来看它们两者的代码：

       JSP代码的效果是这样的：

       

       JSTL标签的效果是这样的：

       

       二搭建JSTL开发环境

       由于JSTL标签和Servlet及JSP页面有着比较严格的版本对应关系，版本对应不正确很容易抛出异常，所以在这里

我采用的是Tomcat 8.0+JSTL 1.1.2的组合开发环境。

       具体步骤：

       1)从Apache的标准标签库中下载的二进包(jakarta-taglibs-standard-current.zip)。下载地址：

http://archive.apache.org/dist/jakarta/taglibs/standard/binaries/

      

       2)下载jakarta-taglibs-standard-1.1.2.zip 包并解压，将jakarta-taglibs-standard-1.1.2/lib/下的两个jar文

件：standard.jar和jstl.jar文件拷贝到/WEB-INF/lib/下。

       

       

       3)选中这两个jar包，右键选择Build Path中的Add to Build Path，就会在Java源代码中的类库中出现这两个jar

包。

       

       测试代码：

   

       运行结果：

       

       三JSTL标签分类

       根据JSTL标签所提供的功能，可以将其分为5个类别：

       1)核心标签(最常用、最重要，也是最基本的标签)

       2)格式化标签

       3)SQL标签

       4)XML标签

       5)JSTL函数(很常用)

       要使用JSTL库，要在每一个JSP的顶部，使用该库必须包括一个<taglib>指令。

       (1)核心标签

       核心组的标签是最常用的JSTL标签。以下是在JSP的语法包含JSTL核心库：

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

       有以下核心JSTL标签：

       

       (2)格式化标签

       使用JSTL格式标签来格式化和显示文本，日期，时间和数字的，国际化的网站。以下是在您的JSP的语法，包括

格式化库：

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

       以下是格式化JSTL标签列表：

        

       (3)SQL标签

       JSTL的SQL标签库标签可以交互关系型数据库(如Oracle，MySQL或Microsoft SQL Server的关系数据库管理系

统)。以下是在您的JSP语法包括JSTL SQL库：

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

       以下是SQL JSTL标签的列表：

       

       (4)XML标签

       JSTL XML标记提供了一种创建和操作XML文档的JSP为中心的方式。以下是在您的JSP的语法包括JSTL XML库。

JSTL XML标记库具有自定义标签与XML数据交互。这包括XML解析，转换XML数据，流控制，基于XPath表达式。

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

       在继续之前的例子中，将需要复制下面的两个XML和XPath相关的库到<Tomcat安装目录> 的\lib目录：

       XercesImpl.jar: 下载地址 http://www.apache.org/dist/xerces/j/

       xalan.jar: 下载地址 http://xml.apache.org/xalan-j/index.html

       以下是XML JSTL标签列表：

       

       (5)JSTL函数

       JSTL包括一些标准功能，其中大部分是常见的字符串操作函数。以下是在JSP的语法包函JSTL函数库：

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

       以下是JSTL函数列表：

       

       后面就是详细介绍EL表达式和一些重要的标签的用法。

    在进行深入JSTL的学习之前，有必要先来学习一下EL表达式。

       一EL表达式

       EL表达式的全名为Expression language，经常与JSTL配合使用，使得JSP页面更直观，写法更简单。

       在EL表达式出现之前，开发Java Web应用程序时，经常需要将大量的Java代码片段嵌入JSP页面中，这会使得页

面看起来很乱，而使用EL表达式则比较简洁。

       示例：

       在页面中显示保存在session中的变量username，并将其输出到页面中，代码如下：

<%
    if(session.getAttribute("username") != null){
           out.println(session.getAttribute("username").toString());
      }
%>

       如果使用EL，则只需一句代码即可实现：

${sessionScope.username}

        因此，EL在Web开发中比较常用，通常与JSTL一起使用。

        EL表达式除了具有语法简单、使用方便的特点，还有以下特点：

       1)EL表达式可以与JSTL结合使用，也可以也JavaScript语句结合使用；

       2)EL表达式L中会自动进行类型转换，如果想通过EL输入两个字符串数值(如n1和n2)的和，可以直接通过"+"进

行连接(如${n1+n2})；

       3)EL表达式不仅可以访问一般变量，还可以访问JavaBean中的属性及嵌套属性和集合对象；

       4)EL表达式中可以执行算术运算、逻辑运算、关系运算和条件运算等操作；

       5)EL表达式中可以获取命名空间(PageContext对象，他是页面中所有其他内置对象的最大范围的继承对象，通过

他可以访问其他内置对象)；

       6)在EL表达式中可以访问JSP的作用域(request、session、application、page)；

       7)在使用EL表达式进行除法运算的时候，如果0作为除数，则返回无穷大Infinity，而不是返回错误；

       8)扩展函数可以与Java类的静态方法进行映射；

        二EL表达式用法

        (1)语法结构

        EL表达式的语法格式用美元符号$定界，内容包括在花括号{}中。以${开头，以}结束，中间为合法的表达式，具

体语法格式如下：

${expression}

       参数说明：

       expression：指定要输出的内容，可以是字符串，也可以是由EL运算符组成的表达式。

       需要注意的是：

       由于EL表达式的语法是以${开头，所以如果在JSP页面中要显示字符串S{，则必须在前面加上"${"或者写

成"${'${'}"。

       示例：

       在页面中输出字符串“JSP学习”，代码如下：

 ${'JSP学习'}

       (2)保留的关键字

       同Java一样，EL也有自己的保留关键字，在变量命名时，应避免这些关键字，包括使用EL输出已经保存在作用域

范围内的变量，也不能使用关键字，如果已经定义了，那么需要修改为其他的变量名。EL表达式中的保留关键字如

下：

      
       如果EL中使用了保留的关键字，那么在Eclipse中，将给出错误提示。如果忽略该提示，直接运行程序，将会出

错。

       (3)EL变量

       EL表达式存取变量数据的方法很简单，例如：${username}。它的意思是取出某一范围中名称为username的变

量。

       因为我们并没有指定哪一个范围的username，所以它会依序从Page、Request、Session、Application范围查

找。

       假如途中找到username，就直接回传，不再继续找下去，但是假如全部的范围都没有找到时，就回传null。

       属性范围在EL表达式中的名称：

       

       (4)[ ]与.操作符

       EL表达式提供"."和"[]"两种操作符来存取数据。两者通常情况是通用的：${user.sex}或者${user["sex"]}都是允许

的。此外，"[]"还可以用来进行集合元素中的定位：${booklist[0].price}。

       以下两种情况是不可以通用的：

       1)包含特殊字符

       当要存取的属性名称中包含一些特殊字符，如 . 或 - 等并非字母或数字的符号，就一定要使用"[ ]"。例如：

${ user. My-Name}应当改为${user["My-Name"]}

       2)通过变量动态取值：

       如果要动态取值时，就可以用"[ ]"来做，而"."无法做到动态取值。例如：

${sessionScope.user[data]}中data 是一个变量。

       (5)EL表达式自动类型转换

       要取得文本框中的输入，我们需要做类型转换：

 String str_count = request.getParameter("count");
 int count = Integer.parseInt(str_count);
 count = count + 20;

       EL表达式会进行自动类型转换，只需要这样写：

${param.count + 20}

       (6)EL运算符

       运算符允许对数据和文字进行组合以及比较。

       EL运算符列表：

       

       1)算术运算符有五个：+、-、*或$、/或div、%或mod

       2)关系运算符有六个：==或eq、!=或ne、<或lt、>或gt、<=或le、>=或ge

       3)逻辑运算符有三个：&&或and、||或or、!或not

       4)其它运算符有三个：empty运算符、条件运算符、()运算符

       最常用的表达式：

       为空判断：${empty param.name}

       三元运算：${A?B:C}

       算数运算：${A*(B+C)} 

       简单实例：

   

       结果：

       

       三EL隐含对象 

       隐含对象列表：

       

       JSP表达式语言定义了一组隐式对象，pageContext取得其他有关用户要求或页面的详细信息。其中许多对象在

 JSP scriplet和表达式中可用：

       

       

       此外，还提供几个隐式对象，允许对以下对象进行简易访问：

       

       与输入有关的隐含对象有两个：param和paramValues，它们是EL表达式中比较特别的隐含对象。

       例如我们要取得用户的请求参数时，可以利用下列方法：

request.getParameter(String name)
request.getParameterValues(String name)

      在EL表达式中则可以使用param和paramValues两者来取得数据。

${param.name}
${paramValues.name}

       其他隐含对象的具体用法可以参考手册。

       除了上述两种类型的隐式对象之外，还有些对象允许访问多种范围的变量，如 Web 上下文、会话、请求、页

面：

       

       在EL表达式中，这四个隐含对象只能用来取得范围属性值，即getAttribute(String name)，却不能取得其他相

关信息。

       例如：我们要取得session中储存一个属性username的值，可以利用下列方法：

session.getAttribute("username") 

       在EL表达式中则使用下列方法：

${sessionScope.username}

        四EL函数

        EL函数的语法如下：ns:function( arg1, arg2, arg3 …. argN)

        其中ns为前置名称(prefix)，它必须和taglib指令的前置名称一样。前置名称都为my，至于function为EL函数的

名称，而arg1、arg2等等，都是function的传入值。

       EL函数主要分为四个部分

      1)web.xml配置文件：设定taglib的TLD文件位置

      2)JSP页面：使用EL函数的JSP页面

      3)tld文档：EL函数、标签库的设定文件

      4)Java源文件：EL函数主要程序逻辑处理部分

      这四个部分环环相扣，都互有关系。我们将在范例中详细描述这四个部分的制作过程。

      由于目前还没有使用到过，就不再进行举例说明了。

     

     常用核心标签介绍

       JSTL的核心标签共13个，从功能上可以分为4类：

       1)表达式控制标签

<c:out>、<c:set>、<c:remove>、<c:catch>

       2)流程控制标签

<c:if>、<c:choose>、<c:when>、<c:otherwise>  

       3)循环标签

<c:forEach>、<c:forTokens>

       4)URL操作标签

<c:import>、<c:url>、<c:redirect>

       <c:out>标签

       <c:out>标签是显示表达式的结果，类似的方式<%=%>效果，与其不同的是<c:out>标签可以使用简单的"."操

作符来访问属性。例如，要访问customer.address.street，使用的标签是：

<c:out value="customer.address.street"/>

       <c:out>标签可自动转义XML标签，以便他们都不会计算为实际的标签。

       <c:out>标签具有以下属性：

       

       <c:out>标签的用法：

       1)输出常量：可在属性value中直接赋值

       2)输出变量：变量不存在时可配合defalut属性输出默认值，还可以通过属性escapeXml控制转义字符的输出方

式。

       实例：

   

       结果：

       

       <c:set>标签

       <c:set>标签是JSTL的setProperty动作的友好版本。标签是有用的，因为它的表达式求值，并使用结果的

JavaBean或Java.util.Map对象设置一个值。

       <c:set>标签具有以下属性：

       

       如果指定目标，属性也必须指定。

       <c:set>标签的用法：

       1)存值到scope中：可将值以变量形式存放在指定的范围中(2种方式)

       2)存值到JavaBean的属性中

       实例：

       实例类Person的代码：

package com.entity;


/**
 * 实体类Person
 * @author Administrator
 * @date 2016年7月27日
 */
public class Person {
	private String name;
	private int age;
	private String hobby;


	public String getName() {
		return name;
	}


	public void setName(String name) {
		this.name = name;
	}


	public int getAge() {
		return age;
	}


	public void setAge(int age) {
		this.age = age;
	}


	public String getHobby() {
		return hobby;
	}


	public void setHobby(String hobby) {
		this.hobby = hobby;
	}


}

       NewFile.jsp页面：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!-- 导入JSTL标签库 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!-- 导入实例类Person -->
<jsp:useBean id="person" class="com.entity.Person" />
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSTL使用</title>
</head>
<body>
     <h1>JSTL标签的使用</h1>
     <hr>
     <!-- 存值到scope中 -->
     <!-- 方式一 -->
     <c:set value="today" var="day" scope="session" />
     <c:out value="${day}" /><br/>  
     <!-- 方式二 -->
     <c:set var="love" scope="application" >football</c:set>
     <c:out value="${love}" /><br/> 
     <!-- 通过set标签向person中赋值 -->
     <c:set target="${person}" property="name" value="Jack"/>
     <c:out value="${person.name}" /><br/>  
     <c:set target="${person}" property="age" >22</c:set>
     <c:out value="${person.age}" /><br/>       
</body>
</html>

       结果：

       

       <c:remove>标签

       <c:remove>标签是删除变量，无论是从指定的范围内或范围内的变量(如果没有指定范围)。这个动作通常是不

特别有帮助，但它可以帮助确保一个JSP范围内的资源，它负责清理。

       <c:remove>标签具有以下属性：

       

       <c:remove>标签的用法：

       移除掉某个变量，var属性是必选的；scope属性是可选的。

       实例：

       

       结果：

       

       <c:catch>标签

       <c:catch>标签捕获任何异常信息，发生在它的身上，有选择地公开。简单地用于错误处理，更优雅地处理这

个问题。

       <c:catch>标签具有以下属性：

       

       <c:catch>标签的用法：

       可以包含那些容易出错的JSTL标签(逻辑)。

       实例：

       

       结果：

       

       <c:if>标签

       <c:if>标签计算表达式，只有当表达式的值为true，则显示其主体内容。

       <c:if>标签具有以下属性：

       

       <c:if>标签的用法：

       同程序中的if作用相同，用来实现分支条件控制。

       text属性用于存放判断的条件，一般使用EL表达式来编写；

       var属性是指定名称用来存放判断的结果类型为true或false；

       scope属性是用来存放var属性存放的范围。

       实例：

       根据用户输入的成绩进行等级判断

       

       结果：

         

       这个例子没有做完，使用<c:if>标签实现比较繁琐，我们后面可以使用<c:choose>标签以及<c:when>标签来实

现。

   <c:choose>标签、<c:when>标签和<c:otherwise>标签

       <c:choose>就像Java switch语句，它可以让你选择一些替代方案品。正如switch语句case语句，<c:choose>标

签有<c:when>的标签。一个switch语句中有default子句来指定一个默认的行动同样的方式<c:choose>有

<c:otherwise>作为默认子句。

       通常这三个标签被放在一起使用。<c:choose>标签嵌套在<c:when>标签和<c:otherwise>标签的外面作为他们

的父标签来使用；其中<c:choose>标签和<c:when>标签也可以一起组合使用。

       <c:choose>标签没有任何属性。<c:when>标记有一个属性，下面列出了。<c:otherwise>标签没有任何属性。

       <c:when>标记具有以下属性：

       

        语法结构一：同时使用<c:choose>标签、<c:when>标签和<c:otherwise>标签

        结构：

<c:choose>
     <c:when test="判断条件1" >
         //业务逻辑
     </c:when>
     <c:when tes="判断条件2" >
         //业务逻辑
     </c:when>
     ...
     <c:otherwise>
         //业务逻辑
      </c:otherwise>
</c:choose>

         实例代码：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!-- 导入JSTL标签库 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSTL使用</title>
</head>
<body>
     <h1>JSTL标签的使用</h1>
     <hr>
     <!-- 标签的用法 -->
     <form action="NewFile.jsp" method="post">
           <input type="text" name="score" value="${param.score}" />
           <input type="submit" />
     </form>
     <c:choose>
           <c:when test="${param.score>=90&&param.score<=100}">
                  <c:out value="优秀" />
           </c:when>
           <c:when test="${param.score>=80&&param.score<90}">
                  <c:out value="良好" />
           </c:when>
           <c:when test="${param.score>=70&&param.score<80}">
                  <c:out value="中等" />
           </c:when>
           <c:when test="${param.score>=60&&param.score<70}">
                  <c:out value="及格" />
           </c:when>
           <c:when test="${param.score>=0&&param.score<60}">
                  <c:out value="不及格" />
           </c:when>
           <c:otherwise>
                  <c:out value="你的输入有问题！" />
           </c:otherwise>
     </c:choose>
</body>
</html>

        结果：

        

        

        语法结构二：只使用<c:choose>标签和<c:when>标签

        结构：

<c:choose>
     <c:when test="条件" />
         表达式
     </c:when>
</c:choose>

        实例：

        在上面的代码中加上以下代码：

        

        结果：

        

        <c:forEach>标签

        存在这些标签嵌入Java的一个很好的选择，让while或do-while循环通过脚本。<c:forEach>标签是常用的标

签，因为它遍历对象的集合。

       <c:forEach>标记有以下属性：

       

       <c:forEach>标签的用法：

       根据循环条件遍历集合(Collection)中的元素。

       var属性是设定变量名用于存储从集合中取出元素(必须无默认值)；

       items属性是指定要遍历的几个(必须无默认值)；

       begin属性和end属性是用于指定遍历的起始位置和终止位置(有默认)；

       step属性指定循环的步长(有默认)；

       varStatus属性通过index、count、first和last几个状态值，描述begin和end子集中的元素的状态。

       常用用法一：全部遍历

<c:forEach var="存储当前遍历元素的变量" items="待遍历集合" >
     操作var变量表示的元素<br/>
</c:forEach>

       实例代码：

<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!-- 导入JSTL标签库 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSTL使用</title>
</head>
<body>
     <h1>JSTL标签的使用</h1>
     <hr>
     <%
           List<String> fruits = new ArrayList<String>();
           fruits.add("apple");
           fruits.add("orange");
           fruits.add("pear");
           fruits.add("watermelon");
           fruits.add("banana");
           fruits.add("grape");
           request.setAttribute("fruits",fruits);
     %>
     <!--用法一：全部遍历 -->
     <c:forEach var="fruit" items="${fruits}" >
            <c:out value="${fruit}" /><br/>
     </c:forEach>
     <c:out value="==========================" />
</body>
</html>

       结果：

       

       常用用法二：部分遍历

<c:forEach var="存储当前遍历元素的变量" items="待遍历集合" begin="开始遍历元素的index值" end="结束遍历的元素的index值" >
       操作var变量表示的元素<br/>
</c:forEach>

      上面实例加上以下代码：

      

      结果：

      

      常用用法三：部分遍历并且指定步长

<c:forEach var="存储当前遍历元素的变量" items="待遍历集合" begin="开始遍历元素的index值" end="结束遍历的元素的index值" step="部分遍历中每次遍历的间隔元素个数" >
       操作var变量表示的元素<br/>
</c:forEach>

       上面实例加上以下代码：

        

        结果：

        

        常用用法四：部分遍历时输出元素的状态

<c:forEach var="存储当前遍历元素的变量" items="待遍历集合" begin="开始遍历元素的index值" end="结束遍历的元素的index值" step="部分遍历中每次遍历的间隔元素个数" varStatus="指定一个变量用来存储当前元素的状态值" >
       操作var变量表示的元素<br/>
</c:forEach>

       上面实例加上以下代码：

       

        结果：

        

       <c:foTokens>标签

       <c:forTokens>标签是用来打破的字符串令牌和遍历每个标记。<c:forTokens>标签有类似<c:forEach>的属性，

除了一个额外的属性delims指定要使用的字符作为分隔符。

        

       <c:forTokens>标签的用法：

       用于浏览字符串，并根据指定的字符将字符串截取。

       items属性用于指定迭代的字符串；

       delims属性指定使用的分隔符；

       var属性用来指定存放遍历到的成员；

       begin属性指定遍历的开始位置(int型从取值0开始)；

       end属性是指定遍历的结束位置(int型，默认集合中最后一个元素)；

       step属性指定循环的步长(大于0的整型)；

       varStatus属性通过index、count、first和last几个状态值，描述begin和end子集中的元素的状态。

       实例：

       

       结果：

       

       对于其他的属性可以自行进行设置与验证。

       

<c:import>标签

       <c:import>标签提供<jsp:include>动作标签的所有的功能动作，但也可以包含绝对URL。例如，允许使用导入

标签包含的内容从一个不同的Web站点或FTP服务器。

       同<jsp:include>标签的区别：只能包含同一个Web应用中的文件，而<c:import>标签可以包含其他Web应用中

的文件，甚至是网络上的资源。

       <c:import>标签具有以下属性：

       

       <c:import>标签的用法：

       可以把其他静态或动态文件包含到本JSP页面。

       url属性指的是被导入资源的URL路径；

       context属性指的是相同服务器下其他Web工程，必须以"/"开头；

       var属性指的是以String类型存入被包含文件的内容；

       scope属性指的是var变量的JSP范围；

       charEncoding属性指的是被导入文件的编码格式 ；

       varReade属性指的是以Reader类型存储被包含文件内容；

       context属性引入的内容是webapps下的其他的Web project。

       实例代码：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!-- 导入JSTL标签库 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSTL使用</title>
</head>
<body>
     <h1>JSTL标签的使用</h1>
     <hr>
     <!-- import标签的用法 -->
     <!-- 导入网络上的绝对路径 -->
     <c:catch var="error09">
            <c:import url="https://www.baidu.com" charEncoding="UTF-8"  />
     </c:catch>
     <c:out value="${error09}" /><br/>
     <!-- 导入相对路径文件 -->
     <c:catch var="error08">
            <c:import url="test.txt" charEncoding="UTF-8" />
     </c:catch>
     <c:out value="${error08}" /><br/>
     <!-- var和scope属性的用法 -->
     <c:catch var="error07">
            <c:import url="test.txt" var="test" scope="session" charEncoding="UTF-8" />
     </c:catch>
     <c:out value="${error07}" />
     <c:out value="import标签存储的test字符串变量值为：${sessionScope.test}" /><br/>
     <!-- content属性的用法 -->
     <c:catch var="error06">
            <c:import url="/date.jsp" context="/FirstWebApp" charEncoding="UTF-8" />
     </c:catch>
     <c:out value="${error06}" />   
</body>
</html>

       结果：

       

        

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

        <c:redirect>标签将浏览器重定向到一个备用URL提供自动URL重写，它支持上下文相关的URL和支持

<c:param>标签。

       <c:redirect>标签具有以下属性：

       

       <c:param>标签允许适当的URL请求参数到指定的URL和任何必要的URL编码。在一个<c:param>标签的name

属性表示参数的名称，value属性表示的参数值。

       <c:param>标签具有以下属性：

       

       <c:redirect>标签的用法：

        该标签用来实现请求的重定向，同事可以在url中加入指定的参数；

       url属性用于指定重定向页面的地址，可以是一个String类型的绝对路径或相对地址；

       context属性用于导入其他Web应用中的页面。

       实例：

       

       test.jsp页面代码：

       

       结果：

       

       <c:url>标签

       <c:url>标签格式化成一个字符串格式的URL，并将其存储到变量中。这个标签会在必要时自动执行URL重写。

 var属性指定的变量将包含格式化的URL。JSTL url标签只是response.encodeURL()方法的调用一个替代方法。URL

标记提供的唯一的真正的优势是正确的URL编码，包括子<c:param>标签指定的任何参数。

       <c:url>标记具有以下属性：

       

       <c:url>标签的用法:

       该标签用于动态生成一个String类型的URL，可以同<c:param>标签共同使用，也可以使用HTML中的<a>标签

实现超链接。

       var属性是将url路径存储在的变量中；

       value属性表示url路径值；

       scope属性是var变量的范围。

       实例：

       

       结果：

       

       JSTL函数

       需要在页面添加：

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

       先来介绍几个简单常用的JSTL函数：

       1)使用fn:contains()函数判断输入的字符串是否包含指定的子串。

       使用fn:contains()函数的语法如下：

boolean contains(java.lang.String, java.lang.String) 

       2)fn:containsIgnoreCase()函数判断输入的字符串是否包含指定的子串，搜索时忽略大小写。

       使用fn:containsIgnoreCase()函数的语法如下:

 boolean containsIgnoreCase(java.lang.String, java.lang.String)

       3)fn:endsWith()函数判断输入的字符串是否与指定的后缀结束。

       使用fn:endsWith()函数的语法如下所示:

boolean endsWith(java.lang.String, java.lang.String)

       4)fn:startsWith() 函数判断输入的字符串是否为指定的子串开始。

       使用fn:startsWith() 函数有以下语法:

 boolean startsWith(java.lang.String, java.lang.String)

       5)fn:indexOf()函数返回在字符串中指定的子串的索引。

       使用fn:indexOf() 函数的语法如下：

int indexOf(java.lang.String, java.lang.String)

       6)fn:escapeXml()函数转义字符，可以解释为XML标记。

       使用fn:escapeXml() 函数的语法如下：

java.lang.String escapeXml(java.lang.String))

       实例代码：

<%@ page language="java" contentType="text/html; charset=UTF-8"
    pageEncoding="UTF-8"%>
<!-- 导入JSTL标签库 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
<!-- 导入JSTL函数库 -->
<%@ taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>JSTL使用</title>
</head>
<body>
    <h1>JSTL函数的使用</h1>
    <hr>
    <!-- contains函数使用 -->
    <c:out value=" Hello Word字符串是否包含Hello：${fn:contains('Hello World','Hello')}" /><br>
    <c:out value=" Hello Word字符串是否包含test：${fn:contains('Hello World','test')}" /><br>
    <!-- containsIgnoreCase函数使用 -->
    <c:out value=" Hello Word字符串是否包含hello(忽略大小写)：${fn:containsIgnoreCase('Hello World','hello')}" /><br>
    <c:out value=" Hello Word字符串是否包含WORLD(忽略大小写)：${fn:containsIgnoreCase('Hello World','WORLD')}" /><br>
    <!-- endsWith和startsWith函数使用 -->
    <c:out value=" Hello Word字符串是否以World结尾：${fn:endsWith('Hello World','World')}" /><br>
    <c:out value=" Hello Word字符串是否以Hello开头：${fn:startsWith('Hello World','Hello')}" /><br>
    <!-- escapeXml函数使用 -->
    <c:out value="${fn:escapeXml('<book>谁的青春不迷茫</book>')}"  /><br>
    <c:out value="<book>谁的青春不迷茫</book>"  /><br>
    <!-- indexOf函数使用 -->
    <c:out value=" Hello Word字符串中Hello出现的index值：${fn:indexOf('Hello World','Hello')}" /><br>
</body>
</html>

       结果：

       

       其他的JSTL函数：

       

       对于其他的JSTL函数具体用法可以参考：http://www.yiibai.com/jstl

       关于JSTL的学习就告一段落，对于其他的XML标签、SQL标签和格式化标签我们使用到的时候再进行介绍，学习

的过程是无止境的。