JavaWeb--------el & jstl
2018-03-13 20:43
651 查看
（参考http://www.cnblogs.com/xdp-gacl/p/3938361.html 点击打开链接，以此为模板 自己做了整理、修改）
1）获取数据
EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域 中检索Java对象、获取数据。(某个web域 中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组)
2）执行运算
利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算。${user==null}
3）获取web开发常用对象
EL 表达式定义了一些隐式对象，利用这些隐式对象，web开发人员可以很轻松获得对web常用对象的引用，从而获得这些对象中的数据。
4）调用Java方法
EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法。
下面详细介绍EL 的这四个主要作用。
EL表达式语句在执行时，会调用pageContext.findAttribute()方法，用标识符为关键字，分别从page、request、session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回”” （注意，不是null，而是空字符串）。
EL表达式可以很轻松获取JavaBean的属性，或获取数组、Collection、Map类型集合的数据
案例，el 表达式获取数据。代码如下： 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
3 <%@page import="me.gacl.domain.Person"%>
4 <%@page import="me.gacl.domain.Address"%>
5 <!DOCTYPE HTML>
6 <html>
7 <head>
8 <title>el表达式获取数据</title>
9 </head>
10
11 <body>
12 <%
13 request.setAttribute("name","孤傲苍狼");
14 %>
15 <%--${name}等同于pageContext.findAttribute("name") --%>
16 使用EL表达式获取数据：${name}
17 <hr>
18 <!-- 在jsp页面中，使用el表达式可以获取bean的属性 -->
19 <%
20 Person p = new Person();
21 p.setAge(12);
22 request.setAttribute("person",p);
23 %>
24 使用el表达式可以获取bean的属性：${person.age}
25 <hr>
26 <!-- 在jsp页面中，使用el表达式可以获取bean中的属性 -->
27 <%
28 Person person = new Person();
29
4000
Address address = new Address();
30 person.setAddress(address);
31
32 request.setAttribute("person",person);
33 %>
34 ${person.address.name}
35 <hr>
36 <!-- 在jsp页面中，使用el表达式获取list集合中指定位置的数据 -->
37 <%
38 Person p1 = new Person();
39 p1.setName("孤傲苍狼");
40
41 Person p2 = new Person();
42 p2.setName("白虎神皇");
43
44 List<Person> list = new ArrayList<Person>();
45 list.add(p1);
46 list.add(p2);
47
48 request.setAttribute("list",list);
49 %>
50
51 <!-- 取list指定位置的数据 -->
52 ${list[1].name}
53
54 <!-- 迭代List集合 -->
55 <c:forEach var="person" items="${list}">
56 ${person.name}
57 </c:forEach>
58 <hr>
59 <!-- 在jsp页面中，使用el表达式获取map集合的数据 -->
60 <%
61 Map<String,String> map = new LinkedHashMap<String,String>();
62 map.put("a","aaaaxxx");
63 map.put("b","bbbb");
64 map.put("c","cccc");
65 map.put("1","aaaa1111");
66 request.setAttribute("map",map);
67 %>
68
69 <!-- 根据关键字取map集合的数据 -->
70 ${map.c}
71 ${map["1"]}
72 <hr>
73 <!-- 迭代Map集合 -->
74 <c:forEach var="me" items="${map}">
75 ${me.key}=${me.value}<br/>
76 </c:forEach>
77 <hr>
78 </body>
79 </html>运行效果，如图所示：
1）关系运算符
2）逻辑运算符
3）empty运算符：检查对象是否为null(空)
4）二元表达式：${user!=null?user.name :""}
5）[ ] 和 . 号运算符
案例，使用EL表达式执行运算。代码如下：
语法：${隐式对象名称}：获得对象的引用
测试EL表达式中的11个隐式对象： 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <!DOCTYPE HTML>
3 <html>
4 <head>
5 <title>el隐式对象</title>
6 </head>
7
8 <body>
9 <br/>---------------1、pageContext对象：获取JSP页面中的pageContext对象------------------------<br/>
10 ${pageContext}
11 <br/>---------------2、pageScope对象：从page域(pageScope)中查找数据------------------------<br/>
12 <%
13 pageContext.setAttribute("name","孤傲苍狼"); //map
14 %>
15 ${pageScope.name}
16 <br/>---------------3、requestScope对象：从request域(requestScope)中获取数据------------------------<br/>
17 <%
18 request.setAttribute("name","白虎神皇"); //map
19 %>
20 ${requestScope.name}
21 <br/>---------------4、sessionScope对象：从session域(sessionScope)中获取数据------------------------<br/>
22 <%
23 session.setAttribute("user","xdp"); //map
24 %>
25 ${sessionScope.user}
26 <br/>---------------5、applicationScope对象：从application域(applicationScope)中获取数据------------------------<br/>
27 <%
28 application.setAttribute("user","gacl"); //map
29 %>
30 ${applicationScope.user}
31 <br/>--------------6、param对象：获得用于保存请求参数map，并从map中获取数据------------------------<br/>
32 <!-- http://localhost:8080/JavaWeb_EL_Study_20140826/ELDemo03.jsp?name=aaa -->
33 ${param.name}
34 <!-- 此表达式会经常用在数据回显上 -->
35 <form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">
36 <input type="text" name="username" value="${param.username}">
37 <input type="submit" value="注册">
38 </form>
39 <br/>--------------7、paramValues对象：paramValues获得请求参数 //map{"",String[]}------------------------<br/>
40 <!-- http://localhost:8080/JavaWeb_EL_Study_20140826/ELDemo03.jsp?like=aaa&like=bbb -->
41 ${paramValues.like[0]}
42 ${paramValues.like[1]}
43 <br/>--------------8、header对象：header获得请求头------------------------<br/>
44 ${header.Accept}<br/>
45 <%--${header.Accept-Encoding} 这样写会报错
46 测试headerValues时，如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
47 --%>
48 ${header["Accept-Encoding"]}
49 <br/>--------------9、headerValues对象：headerValues获得请求头的值------------------------<br/>
50 <%--headerValues表示一个保存了所有http请求头字段的Map对象，它对于某个请求参数，返回的是一个string[]数组
51 例如：headerValues.Accept返回的是一个string[]数组 ，headerValues.Accept[0]取出数组中的第一个值
52 --%>
53 ${headerValues.Accept[0]}<br/>
54 <%--${headerValues.Accept-Encoding} 这样写会报错
55 测试headerValues时，如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
56 headerValues["Accept-Encoding"]返回的是一个string[]数组，headerValues["Accept-Encoding"][0]取出数组中的第一个值
57 --%>
58 ${headerValues["Accept-Encoding"][0]}
59 <br/>--------------10、cookie对象：cookie对象获取客户机提交的cookie------------------------<br/>
60 <!-- 从cookie隐式对象中根据名称获取到的是cookie对象,要想获取值，还需要.value -->
61 ${cookie.JSESSIONID.value} //保存所有cookie的map
62 <br/>--------------11、initParam对象：initParam对象获取在web.xml文件中配置的初始化参数------------------------<br/>
63 <%--
64 <!-- web.xml文件中配置初始化参数 -->
65 <context-param>
66 <param-name>xxx</param-name>
67 <param-value>yyyy</param-value>
68 </context-param>
69 <context-param>
70 <param-name>root</param-name>
71 <param-value>/JavaWeb_EL_Study_20140826</param-value>
72 </context-param>
73 --%>
74 <%--获取servletContext中用于保存初始化参数的map --%>
75 ${initParam.xxx}<br/>
76 ${initParam.root}
77 </body>
78 </html>RegisterServlet的代码如下： 1 package me.gacl.web.controller;
2
3 import java.io.IOException;
4 import javax.servlet.ServletException;
5 import javax.servlet.http.HttpServlet;
6 import javax.servlet.http.HttpServletRequest;
7 import javax.servlet.http.HttpServletResponse;
8
9 public class RegisterServlet extends HttpServlet {
10 /*
11 * 处理用户注册的方法
12 */
13 public void doGet(HttpServletRequest request, HttpServletResponse response)
14 throws ServletException, IOException {
15 //1、接收参数
16 String userName = request.getParameter("username");
17 /**
18 * 2、直接跳转回/ELDemo03.jsp页面，没有使用request.setAttribute("userName", userName)将userName存储到request对象中
19 * 但是在ELDemo03.jsp页面中可以使用${param.username}获取到request对象中的username参数的值
20 */
21 request.getRequestDispatcher("/ELDemo03.jsp").forward(request, response);
22 }
23
24 public void doPost(HttpServletRequest request, HttpServletResponse response)
25 throws ServletException, IOException {
26 doGet(request, response);
27 }
28 }测试结果如下：
注意:
测试header和headerValues时，如果头里面有“-” ，例Accept-Encoding，则要header["Accept-Encoding"]、headerValues["Accept-Encoding"]
测试cookie时，例${cookie.key}取的是cookie对象，如访问cookie的名称和值，须${cookie.key.name}或${cookie.key.value}
在EL表达式中调用的只能是Java类的静态方法，这个Java类的静态方法需要在TLD文件中描述，才可以被EL表达式调用。
EL自定义函数用于扩展EL表达式的功能，可以让EL表达式完成普通Java程序代码所能完成的功能。
1）编写一个Java类的静态方法
2）编写标签库描述符（tld）文件，在tld文件中描述自定义函数。
3）在JSP页面中导入和使用自定义函数
示例：开发对html标签进行转义的el function
1、编写html转义处理工具类，工具类中添加对html标签进行转义的静态处理方法，如下：
2、在WEB-INF目录下编写标签库描述符（tld）文件，在tld文件中描述自定义函数
elFunction.tld的代码如下：
16e2e
入和使用自定义函数 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入EL自定义函数库 --%>
3 <%@taglib uri="/ELFunction" prefix="fn" %>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>使用EL调用Java方法</title>
8 </head>
9
10 <body>
11 <%--使用EL调用filter方法--%>
12 ${fn:filter("<a href=''>点点</a>")}
13 </body>
14 </html>运行结果，如图所示：
开发EL Function注意事项
编写完标签库描述文件后，需要将它放置到<web应用>\WEB-INF目录中或WEB-INF目录下的除了classes和lib目录之外的任意子目录中。
TLD文件中的<uri> 元素用指定该TLD文件的URI，在JSP文件中需要通过这个URI来引入该标签库描述文件。
<function>元素用于描述一个EL自定义函数，其中：
<name>子元素用于指定EL自定义函数的名称。
<function-class>子元素用于指定完整的Java类名，
<function-signature>子元素用于指定Java类中的静态方法的签名，方法签名必须指明方法的返回值类型及各个参数的类型，各个参数之间用逗号分隔。
注意：有些Tomcat服务器如不能使用EL表达式
（1）升级成tomcat6
（2）在JSP中加入<%@ page isELIgnored="false" %>
所谓保留字的意思是指变量在命名时，应该避开上述的名字，以免程序编译时发生错误，关于EL表达式的内容的总结就这么多。
这些EL函数在JSTL开发包中进行描述，因此在JSP页面中使用SUN公司的EL函数库，需要导入JSTL开发包，并在页面中导入EL函数库，如下所示：
MyEclipse自带的JSTL开发包：
在页面中使用JSTL定义的EL函数：<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
案例，EL函数的使用。代码如下：
2
3 public class User {
4
5 /**
6 * 兴趣爱好
7 */
8 private String likes[];
9
10 public String[] getLikes() {
11 return likes;
12 }
13
14 public void setLikes(String[] likes) {
15 this.likes = likes;
16 }
17 }运行结果，如图所示：
国际化标签(I18N格式化标签)
数据库标签(SQL标签，很少使用)
XML标签(几乎不用)
JSTL函数(EL函数)
从功能上可以分为4类：表达式控制标签、流程控制标签、循环标签、URL操作标签。
（1）表达式控制标签：out标签、set标签、remove标签、catch标签。
（2）流程控制标签：if标签、choose标签、when标签、otherwise标签。
（3）循环标签：forEach标签、forTokens标签。
（4）URL操作标签：import标签、url标签、redirect标签、param标签。
在JSP页面引入核心标签库的代码为：<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
3.3.1 表达式控制标签——out标签使用总结<c:out>标签的功能<c:out>标签主要是用来输出数据对象（字符串、表达式）的内容或结果。
在使用Java脚本输出时常使用的方式为： <% out.println(“字符串”)%> 或者 <%=表达式%> ，在web开发中，为了避免暴露逻辑代码会尽量减少页面中的Java脚本，使用<c:out>标签就可以实现以上功能。 <c:out value=”字符串”>
<c:out value=”EL表达式”> JSTL的使用是和EL表达式分不开的，EL表达式虽然可以直接将结果返回给页面，但有时得到的结果为空，<c:out>有特定的结果处理功能，EL的单独使用会降低程序的易读性，建议把EL的结果输入放入<c:out>标签中。
<c:out>标签的语法
<c:out>标签的使用有两种语法格式：
【语法1】：<c:out value=”要显示的数据对象” [escapeXml=”true|false”] [default=”默认值”]/>
【语法2】：<c:out value=”要显示的数据对象” [escapeXml=”true|false”]>默认值</c:out>
这两种方式没有本质的区别，只是格式上的差别。[escapeXml=”true|false”] [default=”默认值”]这些使用[]属性表示是不是必须的。
<c:out>标签的属性
<c:out>标签的使用范例 1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: --表达式控制标签“out”标签的使用</title>
8 </head>
9
10 <body>
11 <h3><c:out value="下面的代码演示了c:out的使用，以及在不同属性值状态下的结果。"/></h3>
12 <hr/>
13 <ul>
14 <%--（1）直接输出了一个字符串。 --%>
15 <li>（1）<c:out value="JSTL的out标签的使用" /></li>
16
17 <li>（2）<c:out value="<a href='http://www.cnblogs.com/'>点击链接到博客园</a>" /></li>
18 <%--escapeXml="false"表示value值中的html标签不进行转义，而是直接输出 --%>
19 <li>（3）<c:out value="<a href='http://www.cnblogs.com/'>点击链接到博客园</a>" escapeXml="false"/></li>
20
21 <%--(4）字符串中有转义字符，但在默认情况下没有转换。 --%>
22 <li>（4）<c:out value="<未使用字符转义>" /></li>
23 <%--（5）使用了转义字符<和>分别转换成<和>符号。 --%>
24 <li>（5）<c:out value="<使用字符转义>" escapeXml="false"></c:out></li>
25
26 <%--（6）设定了默认值，从EL表达式${null}得到空值，所以直接输出设定的默认值。 --%>
27 <li>（6）<c:out value="${null}">使用了默认值</c:out></li>
28 <%--（7）未设定默认值，输出结果为空。 --%>
29 <li>（7）<c:out value="${null}"></c:out></li>
30
31 <%--（8）设定了默认值，从EL表达式${null}得到空值，所以直接输出设定的默认值。 --%>
32 <li>（8）<c:out value="${null}" default="默认值"/></li>
33 <%--（9）未设定默认值，输出结果为空。 --%>
34 <li>（9）<c:out value="${null}"/></li>
35 </ul>
36 </body>
37 </html>运行结果，如图所示：
3.3.2 表达式控制标签——set标签使用总结<c:set>标签的功能
<c:set>标签用于把某一个对象存在指定的域范围内，或者将某一个对象存储到Map或者JavaBean对象中。
<c:set>标签的语法
<c:set>标签的编写共有4种语法格式。
语法1：存值，把一个值放在指定的域范围内。
<c:set value=”值1” var=”name1” [scope=”page|request|session|application”]/>
含义：把一个变量名为name1值为“值1”的变量存储在指定的scope范围内。
语法2：
<c:set var=”name2” [scope=”page|request|session|application”]>
值2
</c:set>
含义：把一个变量名为name2，值为值2的变量存储在指定的scope范围内。
语法3：
<c:set value=”值3” target=”JavaBean对象” property=”属性名”/>
含义：把一个值为“值3”赋值给指定的JavaBean的属性名。相当与setter()方法。
语法4：
<c:set target=”JavaBean对象” property=”属性名”>
值4
</c:set>
含义：把一个值4赋值给指定的JavaBean的属性名。
从功能上分语法1和语法2、语法3和语法4的效果是一样的，只是把value值放置的位置不同，至于使用那个根据个人的喜爱，语法1和语法2是向scope范围内存储一个值，语法3和语法4是给指定的JavaBean赋值。
<c:set>标签的属性
<c:set>标签的使用范例
2
3 /**
4 * 项目名称：JSTLStudy
5 * 类名称：Person
6 * 类描述：一个只有getter和setter方法的JavaBean或者说一个pojo(简单的Java对象(Plain Old Java Objects))类，
7 * 作为一个vo（数据传输对象）。定义了四个变量age、name、sex和home。
8 */
9
10 public class Person {
11
12 private String age;
13
14 private String home;
15
16 private String name;
17
18 private String sex;
19
20 public String getAge() {
21 return age;
22 }
23
24 public String getHome() {
25 return home;
26 }
27
28 public String getName() {
29 return name;
30 }
31
32 public String getSex() {
33 return sex;
34 }
35
36 public void setAge(String age) {
37 this.age = age;
38 }
39
40 public void setHome(String home) {
41 this.home = home;
42 }
43 public void setName(String name) {
44 this.name = name;
45 }
46 public void setSex(String sex) {
47 this.sex = sex;
48 }
49 }运行结果，如图所示：
3.3.3 表达式控制标签——remove标签使用总结<c:remove>标签的功能
<c:remove>标签主要用来从指定的JSP范围内移除指定的变量。
<c:remove>标签的语法
<c:remove var=”变量名” [scope=”page|request|session|application”]/>
其中var属性是必须的，scope可以以省略。
<c:remove>标签的使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: --表达式控制标签“remove”标签的使用</title>
8 </head>
9
10 <body>
11 <ul>
12 <c:set var="name" scope="session">孤傲苍狼</c:set>
13 <c:set var="age" scope="session">25</c:set>
14 <li><c:out value="${sessionScope.name}"></c:out></li>
15 <li><c:out value="${sessionScope.age}"></c:out></li>
16 <%--使用remove标签移除age变量 --%>
17 <c:remove var="age" />
18 <li><c:out value="${sessionScope.name}"></c:out></li>
19 <li><c:out value="${sessionScope.age}"></c:out></li>
20 </ul>
21 </body>
22 </html>运行结果如下：
3.3.4 表达式控制标签——catch标签使用总结<c:catch>标签的功能
<c:catch>标签用于捕获嵌套在标签体中的内容抛出的异常。
<c:catch>标签的语法
其语法格式如下：<c:catch [var="varName"]>容易产生异常的代码</c:catch>
var属性用于标识<c:catch>标签捕获的异常对象，它将保存在page这个Web域中。
<c:catch>标签的使用范例
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: --表达式控制标签“catch”标签实例</title>
8 </head>
9
10 <body>
11 <h4>catch标签实例</h4>
12 <hr>
13 <%--把容易产生异常的代码放在<c:catch></c:catch>中，
14 自定义一个变量errorInfo用于存储异常信息 --%>
15 <c:catch var="errorInfo">
16 <%--实现了一段异常代码，向一个不存在的JavaBean中插入一个值--%>
17 <c:set target="person" property="hao"></c:set>
18 </c:catch>
19 <%--用EL表达式得到errorInfo的值，并使用<c:out>标签输出 --%>
20 异常：<c:out value="${errorInfo}" /><br />
21 异常 errorInfo.getMessage：<c:out value="${errorInfo.message}" /><br />
22 异常 errorInfo.getCause：<c:out value="${errorInfo.cause}" /><br />
23 异常 errorInfo.getStackTrace：<c:out value="${errorInfo.stackTrace}" />
24 </body>
25 </html>运行结果，如图所示：
3.3.5 流程控制标签——if标签使用总结<c:if>标签的功能
<c:if>标签和程序中的if语句作用相同，用来实现条件控制。
<c:if>标签的语法
【语法1】：没有标签体内容(body)
<c:if test="testCondition" var="varName" [scope="{page|request|session|application}"]/>
【语法2】：有标签体内容
<c:if test="testCondition" [var="varName"] [scope="{page|request|session|application}"]>
标签体内容
</c:if>
【参数说明】：
（1）test属性用于存放判断的条件，一般使用EL表达式来编写。
（2）var属性用来存放判断的结果，类型为true或false。
（3）scopes属性用来指定var属性存放的范围。
<c:if>标签的属性
<c:if>标签的使用范例
3.3.6 流程控制标签——choose标签、when标签、otherwise标签配合使用讲解<c:choose>、<c:when>和<c:otherwise>标签的功能
<c:choose>、<c:when>和<c:otherwise>这3个标签通常情况下是一起使用的，<c:choose>标签作为<c:when>和<c:otherwise>标签的父标签来使用。
使用<c:choose>，<c:when>和<c:otherwise>三个标签，可以构造类似 “if-else if-else” 的复杂条件判断结构。
语法
<c:choose>
<c:when test="条件1">
//业务逻辑1
<c:when>
<c:when test="条件2">
//业务逻辑2
<c:when>
<c:when test="条件n">
//业务逻辑n
<c:when>
<c:otherwise>
//业务逻辑
</c:otherwise>
</c:choose>
使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- choose及其嵌套标签标签示例</title>
8 </head>
9
10 <body>
11 <h4>choose及其嵌套标签示例</h4>
12 <hr/>
13 <%--通过set标签设定score的值为85 --%>
14 <c:set var="score" value="85"/>
15 <c:choose>
16 <%--使用<c:when>进行条件判断。
17 如果大于等于90，输出“您的成绩为优秀”；
18 如果大于等于70小于90，输出“您的成绩为良好”；
19 大于等于60小于70，输出“您的成绩为及格”；
20 其他（otherwise）输出“对不起，您没能通过考试”。
21 --%>
22 <c:when test="${score>=90}">
23 你的成绩为优秀！
24 </c:when>
25 <c:when test="${score>70 && score<90}">
26 您的成绩为良好!
27 </c:when>
28 <c:when test="${score>60 && score<70}">
29 您的成绩为及格
30 </c:when>
31 <c:otherwise>
32 对不起，您没有通过考试！
33 </c:otherwise>
34 </c:choose>
35 </body>
36 </html>运行结果如下：
3.3.7 循环标签——forEach标签使用总结
<c:forEach>标签的功能
该标签根据循环条件遍历集合（Collection）中的元素。
<c:forEach>标签的语法
<c:forEach
var=”name”
items=”Collection”
varStatus=”StatusName”
begin=”begin”
end=”end”
step=”step”>
本体内容
</c:forEach>
【参数解析】：
（1）var设定变量名用于存储从集合中取出元素。
（2）items指定要遍历的集合。
（3）varStatus设定变量名，该变量用于存放集合中元素的信息。
（4）begin、end用于指定遍历的起始位置和终止位置（可选）。
（5）step指定循环的步长。
<c:forEach>标签属性
其中varStatus有4个状态属性，如下表所示：
<c:forEach>使用范例
3.3.8 循环标签——forTokens标签使用总结<c:forTokens>标签的功能
该标签用于浏览字符串，并根据指定的字符将字符串截取。
<c:forTokens>标签的语法
语法：
<c:forTokens items=”strigOfTokens”
delims=”delimiters”
[var=”name”
begin=”begin”
end=”end”
step=”len”
varStatus=”statusName”] >
本体内容
</c:forTokens>
【参数说明】
（1）items指定被迭代的字符串。
（2）delims指定使用的分隔符。
（3）var指定用来存放遍历到的成员。
（4）begin指定遍历的开始位置（int型从取值0开始）。
（5）end指定遍历结束的位置（int型，默认集合中最后一个元素）。
（6）step遍历的步长（大于0的整型）。
（7）varStatus存放遍历到的成员的状态信息。
<c:forTokens>使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- forTokens标签实例</title>
8 </head>
9
10 <body>
11 <h4><c:out value="forToken实例"/></h4>
12 <hr/>
13 <%--提示：分隔符的作用是根据标识，截取字符串。
14 如果未设定分隔符或在字符串中没有找到分隔付，将把整个元素作为一个元素截取。
15 在实际应用中用于在除去某些符号在页面中显示。 --%>
16 <c:forTokens var="str" items="北、京、欢、迎、您" delims="、">
17 <c:out value="${str}"></c:out><br/>
18 </c:forTokens>
19 <br/>
20 <c:forTokens items="123-4567-8854" delims="-" var="t">
21 <c:out value="${t}"></c:out><br/>
22 </c:forTokens>
23 <br/>
24 <c:forTokens items="1*2*3*4*5*6*7"
25 delims="*"
26 begin="1"
27 end="3"
28 var="n"
29 varStatus="s">
30 <c:out value="${n}" />的四种属性：<br>
31 所在位置，即索引：<c:out value="${s.index}" /><br>
32 总共已迭代的次数：<c:out value="${s.count}" /><br>
33 是否为第一个位置：<c:out value="${s.first}" /><br>
34 是否为最后一个位置：<c:out value="${s.last}" /><br>
35 </c:forTokens>
36 </body>
37 </html>运行结果如下：
3.3.9 URL操作标签——import标签使用讲解<c:import>标签的功能
该标签可以把其他静态或动态文件包含到本JSP页面，与<jsp:include>的区别为：<jsp:include>只能包含同一个web应用中的文件。而<c:import>可以包含其他web应用中的文件，甚至是网络上的资源。
<c:import>标签的语法
【语法1】：
<c:import
url=”url”
[context=”context”]
[value=”value”]
[scope=”page|request|session|application”]
[charEncoding=”encoding”]/>
【语法2】：
<c:import
url=”url”
varReader=”name”
[context=”context”]
[charEncoding=”encoding”]/>
【参数说明】：
（1）URL为资源的路径，当引用的资源不存在时系统会抛出异常，因此该语句应该放在<c:catch></c:catch>语句块中捕获。
（2）引用资源有两种方式：绝对路径和相对路径。
使用绝对路径的示例如下：<c:import url=”http://www.baidu.com”>
使用相对路径的示例如下：<c:import url=”aa.txt”>，aa.txt放在同一文件目录。
（3）如果以“/”开头表示应用的根目录下。例如：tomcat应用程序的根目录文件夹为webapps。导入webapps下的文件bb.txt的编写方式为：<c:import url=”/bb.txt”>
如果访问webapps管理文件夹中其他web应用就要用context属性。
（4）context属性用于在访问其他web应用的文件时，指定根目录。例如，访问root下的index.jsp的实现代码为：<c:import url=”/index.jsp” context=”/root”>
等同于webapps/root/index.jsp
（5）var、scope、charEncoding、varReader是可选属性。
<c:import>标签的使用范例
<c:url>标签用于在JSP页面中构造一个URL地址，其主要目的是实现URL重写。
<c:url>标签的语法
【语法1】：指定一个url不做修改，可以选择把该url存储在JSP不同的范围中。
<c:url
value=”value”
[var=”name”]
[scope=”page|request|session|application”]
[context=”context”]/>
【语法2】：配合 <c:param>标签给url加上指定参数及参数值，可以选择以name存储该url。
<c:url
value=”value”
[var=”name”]
[scope=”page|request|session|application”]
[context=”context”]>
<c:param name=”参数名” value=”值”>
</c:url>
<c:url>标签的主要属性
<c:url>标签使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- url标签实例</title>
8 </head>
9
10 <body>
11 <c:out value="url标签使用"></c:out>
12 <h4>使用url标签生成一个动态的url，并把值存入session中.</h4>
13 <hr/>
14 <c:url value="http://www.baidu.com" var="url" scope="session">
15 </c:url>
16 <a href="${url}">百度首页(不带参数)</a>
17 <hr/>
18 <h4>
19 配合 <c:param>标签给url加上指定参数及参数值，生成一个动态的url然后存储到paramUrl变量中
20 </h4>
21 <c:url value="http://www.baidu.com" var="paramUrl">
22 <c:param name="userName" value="孤傲苍狼"/>
23 <c:param name="pwd">123456</c:param>
24 </c:url>
25 <a href="${paramUrl}">百度首页(带参数)</a>
26 </body>
27 </html>3.3.11 URL操作标签——redirect标签使用总结<c:redirect>标签的功能
该标签用来实现请求的重定向。同时可以配合使用<c:param>标签在url中加入指定的参数。
<c:redirect>标签的语法
【语法1】：
<c:redirect url=”url” [context=”context”]/>
【语法2】：
<c:redirect url=”url”[context=”context”]>
<c:param name=”name1” value=”value1”>
</c:redirect>
【参数说明】：
（1）url指定重定向页面的地址，可以是一个string类型的绝对地址或相对地址。
（2）context用于导入其他web应用中的页面。
<c:redirect>标签的属性
<c:redirect>标签使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- redirect标签实例</title>
8 </head>
9
10 <body>
11 <c:redirect url="http://www.baidu.com">
12 <%--在重定向时使用<c:param>标签为URL添加了两个参数：uname=GACL和password=123 --%>
13 <c:param name="uname">GACL</c:param>
14 <c:param name="password">123</c:param>
15 </c:redirect>
16 </body>
17 </html>
3.3.12 <c:param>标签使用总结在JSP页面进行URL的相关操作时，经常要在URL地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内，为这些标签所使用的URL地址附加参数。
<c:param>标签在为一个URL地址附加参数时，将自动对参数值进行URL编码，例如，如果传递的参数值为“中国”， 则将其转换为“%d6%d0%b9%fa”后再附加到URL地址后面，这也就是使用<c:param>标签的最大好处。
示例1：与<c:url>标签嵌套使用 <c:url value="http://www.baidu.com" var="paramUrl">
<c:param name="userName" value="孤傲苍狼"/>
<c:param name="pwd">123456</c:param>
</c:url>
<a href="${paramUrl}">百度首页(带参数)</a> 示例2：与<c:redirect>标签嵌套使用 <c:redirect url="http://www.baidu.com">
<%--在重定向时使用<c:param>标签为URL添加了两个参数：uname=GACL和password=123 --%>
<c:param name="uname">GACL</c:param>
<c:param name="password">123</c:param>
</c:redirect>关于JSTL核心标签库中的标签掌握以上的那些标签基本上就可以应付开发了。
---------------------------------------- 我是低调的分隔线 ----------------------------------------
一. EL表达式
EL 全名为Expression Language，是为了使JSP写起来更加简单。EL主要作用：1）获取数据
EL表达式主要用于替换JSP页面中的脚本表达式，以从各种类型的web域 中检索Java对象、获取数据。(某个web域 中的对象，访问javabean的属性、访问list集合、访问map集合、访问数组)
2）执行运算
利用EL表达式可以在JSP页面中执行一些基本的关系运算、逻辑运算和算术运算，以在JSP页面中完成一些简单的逻辑运算。${user==null}
3）获取web开发常用对象
EL 表达式定义了一些隐式对象，利用这些隐式对象，web开发人员可以很轻松获得对web常用对象的引用，从而获得这些对象中的数据。
4）调用Java方法
EL表达式允许用户开发自定义EL函数，以在JSP页面中通过EL表达式调用Java类的方法。
下面详细介绍EL 的这四个主要作用。
1.1 获取数据
使用EL表达式获取数据语法：" ${标识符} "EL表达式语句在执行时，会调用pageContext.findAttribute()方法，用标识符为关键字，分别从page、request、session、application四个域中查找相应的对象，找到则返回相应对象，找不到则返回”” （注意，不是null，而是空字符串）。
EL表达式可以很轻松获取JavaBean的属性，或获取数组、Collection、Map类型集合的数据
案例，el 表达式获取数据。代码如下： 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
3 <%@page import="me.gacl.domain.Person"%>
4 <%@page import="me.gacl.domain.Address"%>
5 <!DOCTYPE HTML>
6 <html>
7 <head>
8 <title>el表达式获取数据</title>
9 </head>
10
11 <body>
12 <%
13 request.setAttribute("name","孤傲苍狼");
14 %>
15 <%--${name}等同于pageContext.findAttribute("name") --%>
16 使用EL表达式获取数据：${name}
17 <hr>
18 <!-- 在jsp页面中，使用el表达式可以获取bean的属性 -->
19 <%
20 Person p = new Person();
21 p.setAge(12);
22 request.setAttribute("person",p);
23 %>
24 使用el表达式可以获取bean的属性：${person.age}
25 <hr>
26 <!-- 在jsp页面中，使用el表达式可以获取bean中的属性 -->
27 <%
28 Person person = new Person();
29
4000
Address address = new Address();
30 person.setAddress(address);
31
32 request.setAttribute("person",person);
33 %>
34 ${person.address.name}
35 <hr>
36 <!-- 在jsp页面中，使用el表达式获取list集合中指定位置的数据 -->
37 <%
38 Person p1 = new Person();
39 p1.setName("孤傲苍狼");
40
41 Person p2 = new Person();
42 p2.setName("白虎神皇");
43
44 List<Person> list = new ArrayList<Person>();
45 list.add(p1);
46 list.add(p2);
47
48 request.setAttribute("list",list);
49 %>
50
51 <!-- 取list指定位置的数据 -->
52 ${list[1].name}
53
54 <!-- 迭代List集合 -->
55 <c:forEach var="person" items="${list}">
56 ${person.name}
57 </c:forEach>
58 <hr>
59 <!-- 在jsp页面中，使用el表达式获取map集合的数据 -->
60 <%
61 Map<String,String> map = new LinkedHashMap<String,String>();
62 map.put("a","aaaaxxx");
63 map.put("b","bbbb");
64 map.put("c","cccc");
65 map.put("1","aaaa1111");
66 request.setAttribute("map",map);
67 %>
68
69 <!-- 根据关键字取map集合的数据 -->
70 ${map.c}
71 ${map["1"]}
72 <hr>
73 <!-- 迭代Map集合 -->
74 <c:forEach var="me" items="${map}">
75 ${me.key}=${me.value}<br/>
76 </c:forEach>
77 <hr>
78 </body>
79 </html>运行效果，如图所示：
1.2 执行运算
语法：${运算表达式}，EL表达式支持如下运算符：1）关系运算符
2）逻辑运算符
3）empty运算符：检查对象是否为null(空)
4）二元表达式：${user!=null?user.name :""}
5）[ ] 和 . 号运算符
案例，使用EL表达式执行运算。代码如下：
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c" %>
3 <%@page import="me.gacl.domain.User"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>el表达式运算符</title>
8 </head>
9
10 <body>
11 <h3>el表达式进行四则运算：</h3>
12 加法运算：${365+24}<br/>
13 减法运算：${365-24}<br/>
14 乘法运算：${365*24}<br/>
15 除法运算：${365/24}<br/>
16
17 <h3>el表达式进行关系运算：</h3>
18 <%--${user == null}和 ${user eq null}两种写法等价--%>
19 ${user == null}<br/>
20 ${user eq null}<br/>
21
22 <h3>el表达式使用empty运算符检查对象是否为null(空)</h3>
23 <%
24
25 List<String> list = new ArrayList<String>();
26 list.add("gacl");
27 list.add("xdp");
28 request.setAttribute("list",list);
29 %>
30 <%--使用empty运算符检查对象是否为null(空) --%>
31 <c:if test="${!empty(list)}">
32 <c:forEach var="str" items="${list}">
33 ${str}<br/>
34 </c:forEach>
35 </c:if>
36 <br/>
37 <%
38 List<String> emptyList = null;
39 %>
40 <%--使用empty运算符检查对象是否为null(空) --%>
41 <c:if test="${empty(emptyList)}">
42 对不起，没有您想看的数据
43 </c:if>
44
45 <br/>
46
47 <h3>EL表达式中使用二元表达式</h3>
48 <%
49 session.setAttribute("user",new User("孤傲苍狼"));
50 %>
51 ${user==null? "对不起，您没有登陆 " : user.username}
52
53 <br/>
54
55 <h3>EL表达式数据回显</h3>
56 <%
57 User user = new User();
58 user.setGender("male");
59 //数据回显
60 request.setAttribute("user",user);
61 %>
62 <input type="radio" name="gender" value="male" ${user.gender=='male'?'checked':''}>男
63 <input type="radio" name="gender" value="female" ${user.gender=='female'?'checked':''}>女
64 <br/>65 </body>
66 </html>运行结果，如下所示：1.3 获得web开发常用对象
EL表达式语言中定义了11个隐含对象，使用这些隐含对象可以很方便地获取web开发中的一些常见对象，并读取这些对象的数据。语法：${隐式对象名称}：获得对象的引用
测试EL表达式中的11个隐式对象： 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <!DOCTYPE HTML>
3 <html>
4 <head>
5 <title>el隐式对象</title>
6 </head>
7
8 <body>
9 <br/>---------------1、pageContext对象：获取JSP页面中的pageContext对象------------------------<br/>
10 ${pageContext}
11 <br/>---------------2、pageScope对象：从page域(pageScope)中查找数据------------------------<br/>
12 <%
13 pageContext.setAttribute("name","孤傲苍狼"); //map
14 %>
15 ${pageScope.name}
16 <br/>---------------3、requestScope对象：从request域(requestScope)中获取数据------------------------<br/>
17 <%
18 request.setAttribute("name","白虎神皇"); //map
19 %>
20 ${requestScope.name}
21 <br/>---------------4、sessionScope对象：从session域(sessionScope)中获取数据------------------------<br/>
22 <%
23 session.setAttribute("user","xdp"); //map
24 %>
25 ${sessionScope.user}
26 <br/>---------------5、applicationScope对象：从application域(applicationScope)中获取数据------------------------<br/>
27 <%
28 application.setAttribute("user","gacl"); //map
29 %>
30 ${applicationScope.user}
31 <br/>--------------6、param对象：获得用于保存请求参数map，并从map中获取数据------------------------<br/>
32 <!-- http://localhost:8080/JavaWeb_EL_Study_20140826/ELDemo03.jsp?name=aaa -->
33 ${param.name}
34 <!-- 此表达式会经常用在数据回显上 -->
35 <form action="${pageContext.request.contextPath}/servlet/RegisterServlet" method="post">
36 <input type="text" name="username" value="${param.username}">
37 <input type="submit" value="注册">
38 </form>
39 <br/>--------------7、paramValues对象：paramValues获得请求参数 //map{"",String[]}------------------------<br/>
40 <!-- http://localhost:8080/JavaWeb_EL_Study_20140826/ELDemo03.jsp?like=aaa&like=bbb -->
41 ${paramValues.like[0]}
42 ${paramValues.like[1]}
43 <br/>--------------8、header对象：header获得请求头------------------------<br/>
44 ${header.Accept}<br/>
45 <%--${header.Accept-Encoding} 这样写会报错
46 测试headerValues时，如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
47 --%>
48 ${header["Accept-Encoding"]}
49 <br/>--------------9、headerValues对象：headerValues获得请求头的值------------------------<br/>
50 <%--headerValues表示一个保存了所有http请求头字段的Map对象，它对于某个请求参数，返回的是一个string[]数组
51 例如：headerValues.Accept返回的是一个string[]数组 ，headerValues.Accept[0]取出数组中的第一个值
52 --%>
53 ${headerValues.Accept[0]}<br/>
54 <%--${headerValues.Accept-Encoding} 这样写会报错
55 测试headerValues时，如果头里面有“-” ，例Accept-Encoding，则要headerValues[“Accept-Encoding”]
56 headerValues["Accept-Encoding"]返回的是一个string[]数组，headerValues["Accept-Encoding"][0]取出数组中的第一个值
57 --%>
58 ${headerValues["Accept-Encoding"][0]}
59 <br/>--------------10、cookie对象：cookie对象获取客户机提交的cookie------------------------<br/>
60 <!-- 从cookie隐式对象中根据名称获取到的是cookie对象,要想获取值，还需要.value -->
61 ${cookie.JSESSIONID.value} //保存所有cookie的map
62 <br/>--------------11、initParam对象：initParam对象获取在web.xml文件中配置的初始化参数------------------------<br/>
63 <%--
64 <!-- web.xml文件中配置初始化参数 -->
65 <context-param>
66 <param-name>xxx</param-name>
67 <param-value>yyyy</param-value>
68 </context-param>
69 <context-param>
70 <param-name>root</param-name>
71 <param-value>/JavaWeb_EL_Study_20140826</param-value>
72 </context-param>
73 --%>
74 <%--获取servletContext中用于保存初始化参数的map --%>
75 ${initParam.xxx}<br/>
76 ${initParam.root}
77 </body>
78 </html>RegisterServlet的代码如下： 1 package me.gacl.web.controller;
2
3 import java.io.IOException;
4 import javax.servlet.ServletException;
5 import javax.servlet.http.HttpServlet;
6 import javax.servlet.http.HttpServletRequest;
7 import javax.servlet.http.HttpServletResponse;
8
9 public class RegisterServlet extends HttpServlet {
10 /*
11 * 处理用户注册的方法
12 */
13 public void doGet(HttpServletRequest request, HttpServletResponse response)
14 throws ServletException, IOException {
15 //1、接收参数
16 String userName = request.getParameter("username");
17 /**
18 * 2、直接跳转回/ELDemo03.jsp页面，没有使用request.setAttribute("userName", userName)将userName存储到request对象中
19 * 但是在ELDemo03.jsp页面中可以使用${param.username}获取到request对象中的username参数的值
20 */
21 request.getRequestDispatcher("/ELDemo03.jsp").forward(request, response);
22 }
23
24 public void doPost(HttpServletRequest request, HttpServletResponse response)
25 throws ServletException, IOException {
26 doGet(request, response);
27 }
28 }测试结果如下：
注意:
测试header和headerValues时，如果头里面有“-” ，例Accept-Encoding，则要header["Accept-Encoding"]、headerValues["Accept-Encoding"]
测试cookie时，例${cookie.key}取的是cookie对象，如访问cookie的名称和值，须${cookie.key.name}或${cookie.key.value}
1.4 使用EL调用Java方法
EL表达式语法允许开发人员开发自定义函数，以调用Java类的方法。语法：${prefix：method(params)}在EL表达式中调用的只能是Java类的静态方法，这个Java类的静态方法需要在TLD文件中描述，才可以被EL表达式调用。
EL自定义函数用于扩展EL表达式的功能，可以让EL表达式完成普通Java程序代码所能完成的功能。
1.5 EL Function自定义函数
一般来说， EL自定义函数开发与应用包括以下三个步骤：1）编写一个Java类的静态方法
2）编写标签库描述符（tld）文件，在tld文件中描述自定义函数。
3）在JSP页面中导入和使用自定义函数
示例：开发对html标签进行转义的el function
1、编写html转义处理工具类，工具类中添加对html标签进行转义的静态处理方法，如下：
1 package me.gacl.util;
2
3 /**
4 * @ClassName: HtmlFilter
5 * @Description: html转义处理工具类
6 * @author: 孤傲苍狼
7 * @date: 2014-8-27 上午12:09:15
8 *
9 */
10 public class HtmlFilter {
11
12 /**
13 * @Method: filter
14 * @Description: 静态方法，html标签转义处理
15 * @Anthor:孤傲苍狼
16 *
17 * @param message 要转义的内容
18 * @return 转义后的内容
19 */
20 public static String filter(String message) {
21
22 if (message == null)
23 return (null);
24
25 char content[] = new char[message.length()];
26 message.getChars(0, message.length(), content, 0);
27 StringBuffer result = new StringBuffer(content.length + 50);
28 for (int i = 0; i < content.length; i++) {
29 switch (content[i]) {
30 case '<':
31 result.append("<");
32 break;
33 case '>':
34 result.append(">");
35 break;
36 case '&':
37 result.append("&");
38 break;
39 case '"':
40 result.append(""");
41 break;
42 default:
43 result.append(content[i]);
44 }
45 }
46 return (result.toString());
47 }
48 }2、在WEB-INF目录下编写标签库描述符（tld）文件，在tld文件中描述自定义函数
elFunction.tld的代码如下：
1 <?xml version="1.0" encoding="UTF-8"?> 2 <taglib version="2.0" xmlns="http://java.sun.com/xml/ns/j2ee" 3 xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee web-jsptaglibrary_2_0.xsd"> 4 <tlib-version>1.0</tlib-version> 5 <short-name>EL Function</short-name> 6 <!-- 7 自定义EL函数库的引用URI， 8 在JSP页面中可以这样引用：<%@taglib uri="/ELFunction" prefix="fn" %> 9 --> 10 <uri>/ELFunction</uri> 11 12 <!--<function>元素用于描述一个EL自定义函数 --> 13 <function> 14 <description>html标签转义处理方法</description> 15 <!--<name>子元素用于指定EL自定义函数的名称--> 16 <name>filter</name> 17 <!--<function-class>子元素用于指定完整的Java类名--> 18 <function-class>me.gacl.util.HtmlFilter</function-class> 19 <!--<function-signature>子元素用于指定Java类中的静态方法的签名， 20 方法签名必须指明方法的返回值类型及各个参数的类型，各个参数之间用逗号分隔。--> 21 <function-signature>java.lang.String filter(java.lang.String)</function-signature> 22 </function> 23 24 </taglib>3、在JSP页面中导
16e2e
入和使用自定义函数 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入EL自定义函数库 --%>
3 <%@taglib uri="/ELFunction" prefix="fn" %>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>使用EL调用Java方法</title>
8 </head>
9
10 <body>
11 <%--使用EL调用filter方法--%>
12 ${fn:filter("<a href=''>点点</a>")}
13 </body>
14 </html>运行结果，如图所示：
开发EL Function注意事项
编写完标签库描述文件后，需要将它放置到<web应用>\WEB-INF目录中或WEB-INF目录下的除了classes和lib目录之外的任意子目录中。
TLD文件中的<uri> 元素用指定该TLD文件的URI，在JSP文件中需要通过这个URI来引入该标签库描述文件。
<function>元素用于描述一个EL自定义函数，其中：
<name>子元素用于指定EL自定义函数的名称。
<function-class>子元素用于指定完整的Java类名，
<function-signature>子元素用于指定Java类中的静态方法的签名，方法签名必须指明方法的返回值类型及各个参数的类型，各个参数之间用逗号分隔。
1.6 EL注意事项
EL表达式是JSP 2.0规范中的一门技术 。因此，若想正确解析EL表达式，需使用支持Servlet2.4/JSP2.0技术的WEB服务器。注意：有些Tomcat服务器如不能使用EL表达式
（1）升级成tomcat6
（2）在JSP中加入<%@ page isELIgnored="false" %>
1.7 EL表达式保留关键字
所谓保留字的意思是指变量在命名时，应该避开上述的名字，以免程序编译时发生错误，关于EL表达式的内容的总结就这么多。
二. EL函数库
2.1 EL 函数库介绍
由于在JSP页面中显示数据时，经常需要对显示的字符串进行处理，SUN公司针对于一些常见处理定义了一套EL函数库供开发者使用。这些EL函数在JSTL开发包中进行描述，因此在JSP页面中使用SUN公司的EL函数库，需要导入JSTL开发包，并在页面中导入EL函数库，如下所示：
MyEclipse自带的JSTL开发包：
2.2 EL 函数库案例
fn.tld就是EL函数库的对应的tld描述文件，如下图所示：在页面中使用JSTL定义的EL函数：<%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn"%>
案例，EL函数的使用。代码如下：
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%@page import="me.gacl.domain.User"%>
3 <%--引入EL函数库 --%>
4 <%@taglib uri="http://java.sun.com/jsp/jstl/functions" prefix="fn" %>
5 <!DOCTYPE HTML>
6 <html>
7 <head>
8 <title>EL函数库中的方法使用范例</title>
9 </head>
10
11 <body>
12 <h3>fn:toLowerCase函数使用范例：</h3>
13 <%--fn:toLowerCase函数将一个字符串中包含的所有字符转换为小写形式，并返回转换后的字符串，
14 它接收一个字符串类型的参数。fn:toLowerCase("")的返回值为空字符串--%>
15 <%--fn:toLowerCase("Www.CNBLOGS.COM") 的返回值为字符串“www.cnblogs.com” --%>
16 fn:toLowerCase("Www.CNBLOGS.COM")的结果是：${fn:toLowerCase("Www.CNBLOGS.COM")}
17 <hr/>
18 <h3>fn:toUpperCase函数使用范例：</h3>
19 <%--fn:toUpperCase函数将一个字符串中包含的所有字符转换为大写形式，并返回转换后的字符串，
20 它接收一个字符串类型的参数。fn:toUpperCase("")的返回值为空字符串--%>
21 fn:toUpperCase("cnblogs.com")的结果是：${fn:toUpperCase("cnblogs.com")}
22 <hr/>
23 <h3>fn:trim函数使用范例：</h3>
24 <%--fn:trim函数删除一个字符串的首尾的空格，并返回删除空格后的结果字符串，
25 它接收一个字符串类型的参数。需要注意的是，fn:trim函数不能删除字符串中间位置的空格。--%>
26 fn:trim(" cnblogs.com ")的结果是：${fn:trim(" cnblogs.com ")}
27 <hr/>
28 <h3>fn:length函数使用范例：</h3>
29 <%--fn:length函数返回一个集合或数组大小，或返回一个字符串中包含的字符的个数，返回值为int类型。
30 fn:length函数接收一个参数，这个参数可以是<c:forEach>标签的items属性支持的任何类型，
31 包括任意类型的数组、java.util.Collection、java.util.Iterator、java.util.Enumeration、
32 java.util.Map等类的实例对象和字符串。
33 如果fn:length函数的参数为null或者是元素个数为0的集合或数组对象，则函数返回0；如果参数是空字符串，则函数返回0
34 --%>
35 <%
36 List<String> list = Arrays.asList("1","2","3");
37 request.setAttribute("list",list);
38 %>
39 fn:length(list)计算集合list的size的值是：${fn:length(list)}
40 <br/>
41 fn:length("cnblogs.com")计算字符串的长度是：${fn:length("cnblogs.com")}
42 <hr/>
43 <h3>fn:split函数使用范例：</h3>
44 <%--
45 fn:split函数以指定字符串作为分隔符，将一个字符串分割成字符串数组并返回这个字符串数组。
46 fn:split函数接收两个字符串类型的参数，第一个参数表示要分割的字符串，第二个参数表示作为分隔符的字符串
47 --%>
48 fn:split("cnblogs.com",".")[0]的结果是：${fn:split("cnblogs.com",".")[0]}
49 <hr/>
50 <h3>fn:join函数使用范例：</h3>
51 <%--
52 fn:join函数以一个字符串作为分隔符，将一个字符串数组中的所有元素合并为一个字符串并返回合并后的结果字符串。
53 fn:join函数接收两个参数，第一个参数是要操作的字符串数组，第二个参数是作为分隔符的字符串。
54 如果fn:join函数的第二个参数是空字符串，则fn:join函数的返回值直接将元素连接起来。
55 --%>
56 <%
57 String[] StringArray = {"www","iteye","com"};
58 pageContext.setAttribute("StringArray", StringArray);
59 %>
60 <%--fn:join(StringArray,".")返回字符串“www.iteye.com”--%>
61 fn:join(StringArray,".")的结果是：${fn:join(StringArray,".")}
62 <br/>
63 <%--fn:join(fn:split("www,iteye,com",","),".")的返回值为字符串“www.iteye.com”--%>
64 fn:join(fn:split("www,iteye,com",","),".")的结果是：${fn:join(fn:split("www,iteye,com",","),".")}
65 <hr/>
66
67 <h3>fn:indexOf函数使用范例：</h3>
68 <%--
69 fn:indexOf函数返回指定字符串在一个字符串中第一次出现的索引值，返回值为int类型。
70 fn:indexOf函数接收两个字符串类型的参数，如果第一个参数字符串中包含第二个参数字符串，
71 那么，不管第二个参数字符串在第一个参数字符串中出现几次，fn:indexOf函数总是返回第一次出现的索引值；
72 如果第一个参数中不包含第二个参数，则fn:indexOf函数返回-1。如果第二个参数为空字符串，则fn:indexOf函数总是返回0。
73 --%>
74 fn:indexOf("www.iteye.com","eye")的返回值为：${fn:indexOf("www.iteye.com","eye")}
75 <hr/>
76
77 <h3>fn:contains函数使用范例：</h3>
78 <%--
79 fn:contains函数检测一个字符串中是否包含指定的字符串，返回值为布尔类型。
80 fn:contains函数在比较两个字符串是否相等时是大小写敏感的。
81 fn:contains函数接收两个字符串类型的参数，如果第一个参数字符串中包含第二个参数字符串，则fn:contains函数返回true，否则返回false。
82 如果第二个参数的值为空字符串，则fn:contains函数总是返回true。
83 实际上，fn:contains(string, substring)等价于fn:indexOf(string, substring) != -1
84 忽略大小的EL函数：fn:containsIgnoreCase
85 --%>
86 <%
87 User user = new User();
88 String likes[] = {"sing","dance"};
89 user.setLikes(likes);
90 //数据回显
91 request.setAttribute("user",user);
92 %>
93 <%--使用el函数回显数据 --%>
94 <input type="checkbox" name="like"
95 vlaue="sing" ${fn:contains(fn:join(user.likes,","),"sing")?'checked':''}/>唱歌
96 <input type="checkbox" name="like"
97 value="dance" ${fn:contains(fn:join(user.likes,","),"dance")?'checked':''}/>跳舞
98 <input type="checkbox" name="like"
99 value="basketball" ${fn:contains(fn:join(user.likes,","),"basketball")?'checked':''}/>蓝球
100 <input type="checkbox" name="like"
101 value="football" ${fn:contains(fn:join(user.likes,","),"football")?'checked':''}/>足球
102 <hr/>
103
104 <h3>fn:startsWith函数和fn:endsWith函数使用范例：</h3>
105 <%--
106 fn:startsWith函数用于检测一个字符串是否是以指定字符串开始的，返回值为布尔类型。
107 fn:startsWith函数接收两个字符串类型的参数，如果第一个参数字符串以第二个参数字符串开始，则函数返回true，否则函数返回false。
108 如果第二个参数为空字符串，则fn:startsWith函数总是返回true。
109 与fn:startsWith函数对应的另一个EL函数为：fn:endsWith，用于检测一个字符串是否是以指定字符串结束的，返回值为布尔类型。
110 --%>
111 fn:startsWith("www.iteye.com","iteye")的返回值为：${fn:startsWith("www.iteye.com","iteye")}
112 <br/>
113 fn:endsWith("www.iteye.com","com")的返回值为：${fn:endsWith("www.iteye.com","com")}
114 <hr/>
115
116 <h3>fn:replace使用范例：</h3>
117 <%--
118 fn:replace函数将一个字符串中包含的指定子字符串替换为其它的指定字符串，并返回替换后的结果字符串。
119 fn:replace方法接收三个字符串类型的参数，第一个参数表示要操作的源字符串，第二个参数表示源字符串中要被替换的子字符串，
120 第三个参数表示要被替换成的字符串。
121 --%>
122 fn:replace("www iteye com ", " ", ".")的返回值为字符串：${fn:replace("www iteye com", " ", ".")}
123 <hr/>
124
125 <h3>fn:substring使用范例：</h3>
126 <%--
127 fn:substring函数用于截取一个字符串的子字符串并返回截取到的子字符串。
128 fn:substring函数接收三个参数，第一个参数是用于指定要操作的源字符串，第二个参数是用于指定截取子字符串开始的索引值，
129 第三个参数是用于指定截取子字符串结束的索引值，第二个参数和第三个参数都是int类型，其值都从0开始。
130 --%>
131 fn:substring("www.it315.org", 4, 9) 的返回值为字符串：${fn:substring("www.it315.org", 4, 9)}
132
133 <h3>fn:substringAfter函数和fn:substringBefore函数使用范例：</h3>
134 <%--
135 fn:substringAfter函数用于截取并返回一个字符串中的指定子字符串第一次出现之后的子字符串。
136 fn:substringAfter函数接收两个字符串类型的参数，第一个参数表示要操作的源字符串，第二个参数表示指定的子字符串
137 与之对应的EL函数为：fn:substringBefore
138 --%>
139 fn:substringAfter("www.it315.org",".")的返回值为字符串：${fn:substringAfter("www.it315.org",".")}
140 <br/>
141 fn:substringBefore("www.it315.org",".")的返回值为字符串：${fn:substringBefore("www.it315.org",".")}
142 <hr/>
143 </body>
144 </html>jsp页面中使用到的me.gacl.domain.User类的代码如下： 1 package me.gacl.domain;2
3 public class User {
4
5 /**
6 * 兴趣爱好
7 */
8 private String likes[];
9
10 public String[] getLikes() {
11 return likes;
12 }
13
14 public void setLikes(String[] likes) {
15 this.likes = likes;
16 }
17 }运行结果，如图所示：
三. JSTL标签库
3.1 JSTL标签库介绍
JSTL标签库的使用是为弥补html标签的不足，规范自定义标签的使用而诞生的。使用JSLT标签的目的就是不希望在jsp页面中出现java逻辑代码3.2 JSTL标签库的分类
核心标签(用得最多)国际化标签(I18N格式化标签)
数据库标签(SQL标签，很少使用)
XML标签(几乎不用)
JSTL函数(EL函数)
3.3 核心标签库使用说明
JSTL的核心标签库标签共13个，使用这些标签能够完成JSP页面的基本功能，减少编码工作。从功能上可以分为4类：表达式控制标签、流程控制标签、循环标签、URL操作标签。
（1）表达式控制标签：out标签、set标签、remove标签、catch标签。
（2）流程控制标签：if标签、choose标签、when标签、otherwise标签。
（3）循环标签：forEach标签、forTokens标签。
（4）URL操作标签：import标签、url标签、redirect标签、param标签。
在JSP页面引入核心标签库的代码为：<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
3.3.1 表达式控制标签——out标签使用总结<c:out>标签的功能<c:out>标签主要是用来输出数据对象（字符串、表达式）的内容或结果。
在使用Java脚本输出时常使用的方式为： <% out.println(“字符串”)%> 或者 <%=表达式%> ，在web开发中，为了避免暴露逻辑代码会尽量减少页面中的Java脚本，使用<c:out>标签就可以实现以上功能。 <c:out value=”字符串”>
<c:out value=”EL表达式”> JSTL的使用是和EL表达式分不开的，EL表达式虽然可以直接将结果返回给页面，但有时得到的结果为空，<c:out>有特定的结果处理功能，EL的单独使用会降低程序的易读性，建议把EL的结果输入放入<c:out>标签中。
<c:out>标签的语法
<c:out>标签的使用有两种语法格式：
【语法1】：<c:out value=”要显示的数据对象” [escapeXml=”true|false”] [default=”默认值”]/>
【语法2】：<c:out value=”要显示的数据对象” [escapeXml=”true|false”]>默认值</c:out>
这两种方式没有本质的区别，只是格式上的差别。[escapeXml=”true|false”] [default=”默认值”]这些使用[]属性表示是不是必须的。
<c:out>标签的属性
<c:out>标签的使用范例 1 <%@ page language="java" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: --表达式控制标签“out”标签的使用</title>
8 </head>
9
10 <body>
11 <h3><c:out value="下面的代码演示了c:out的使用，以及在不同属性值状态下的结果。"/></h3>
12 <hr/>
13 <ul>
14 <%--（1）直接输出了一个字符串。 --%>
15 <li>（1）<c:out value="JSTL的out标签的使用" /></li>
16
17 <li>（2）<c:out value="<a href='http://www.cnblogs.com/'>点击链接到博客园</a>" /></li>
18 <%--escapeXml="false"表示value值中的html标签不进行转义，而是直接输出 --%>
19 <li>（3）<c:out value="<a href='http://www.cnblogs.com/'>点击链接到博客园</a>" escapeXml="false"/></li>
20
21 <%--(4）字符串中有转义字符，但在默认情况下没有转换。 --%>
22 <li>（4）<c:out value="<未使用字符转义>" /></li>
23 <%--（5）使用了转义字符<和>分别转换成<和>符号。 --%>
24 <li>（5）<c:out value="<使用字符转义>" escapeXml="false"></c:out></li>
25
26 <%--（6）设定了默认值，从EL表达式${null}得到空值，所以直接输出设定的默认值。 --%>
27 <li>（6）<c:out value="${null}">使用了默认值</c:out></li>
28 <%--（7）未设定默认值，输出结果为空。 --%>
29 <li>（7）<c:out value="${null}"></c:out></li>
30
31 <%--（8）设定了默认值，从EL表达式${null}得到空值，所以直接输出设定的默认值。 --%>
32 <li>（8）<c:out value="${null}" default="默认值"/></li>
33 <%--（9）未设定默认值，输出结果为空。 --%>
34 <li>（9）<c:out value="${null}"/></li>
35 </ul>
36 </body>
37 </html>运行结果，如图所示：
3.3.2 表达式控制标签——set标签使用总结<c:set>标签的功能
<c:set>标签用于把某一个对象存在指定的域范围内，或者将某一个对象存储到Map或者JavaBean对象中。
<c:set>标签的语法
<c:set>标签的编写共有4种语法格式。
语法1：存值，把一个值放在指定的域范围内。
<c:set value=”值1” var=”name1” [scope=”page|request|session|application”]/>
含义：把一个变量名为name1值为“值1”的变量存储在指定的scope范围内。
语法2：
<c:set var=”name2” [scope=”page|request|session|application”]>
值2
</c:set>
含义：把一个变量名为name2，值为值2的变量存储在指定的scope范围内。
语法3：
<c:set value=”值3” target=”JavaBean对象” property=”属性名”/>
含义：把一个值为“值3”赋值给指定的JavaBean的属性名。相当与setter()方法。
语法4：
<c:set target=”JavaBean对象” property=”属性名”>
值4
</c:set>
含义：把一个值4赋值给指定的JavaBean的属性名。
从功能上分语法1和语法2、语法3和语法4的效果是一样的，只是把value值放置的位置不同，至于使用那个根据个人的喜爱，语法1和语法2是向scope范围内存储一个值，语法3和语法4是给指定的JavaBean赋值。
<c:set>标签的属性
<c:set>标签的使用范例
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <%--使用JSP的指令元素指定要使用的JavaBean --%>
5 <jsp:useBean id="person" class="javabean.Person"/>
6 <%--负责实例化Bean，id指定实例化后的对象名，可以通过${person}得到person在内存中的值
7 （或者使用person.toString()方法）。 --%>
8 <!DOCTYPE HTML>
9 <html>
10 <head>
11
12 <title>JSTL: --表达式控制标签“set”标签的使用</title>
13
14 </head>
15
16 <body>
17 <h3>代码给出了给指定scope范围赋值的示例。</h3>
18 <ul>
19 <%--通过<c:set>标签将data1的值放入page范围中。--%>
20 <li>把一个值放入page域中:<c:set var="data1" value="xdp" scope="page"/></li>
21 <%--使用EL表达式从pageScope得到data1的值。--%>
22 <li>从page域中得到值：${pageScope.data1}</li>
23
24 <%--通过<c:set>标签将data2的值放入request范围中。--%>
25 <li>把一个值放入request域中:<c:set var="data2" value="gacl" scope="request"/></li>
26 <%--使用EL表达式从requestScope得到data2的值。--%>
27 <li>从request域中得到值：${requestScope.data2}</li>
28
29 <%--通过<c:set>标签将值name1的值放入session范围中。--%>
30 <li>把一个值放入session域中。<c:set value="孤傲苍狼" var="name1" scope="session"></c:set></li>
31 <%--使用EL表达式从sessionScope得到name1的值。--%>
32 <li>从session域中得到值:${sessionScope.name1} </li>
33
34 <%--把name2放入application范围中。 --%>
35 <li>把一个值放入application域中。<c:set var="name2" scope="application">白虎神皇</c:set></li>
36 <%--使用EL表达式从application范围中取值，用<c:out>标签输出使得页面规范化。 --%>
37 <li>使用out标签和EL表达式嵌套从application域中得到值：
38 <c:out value="${applicationScope.name2}">未得到name的值</c:out>
39 </li>
40
41 <%--不指定范围使用EL自动查找得到值 --%>
42 <li>未指定scope的范围，会从不同的范围内查找得到相应的值：${data1}、${data2}、${name1}、${name2}</li>
43 </ul>
44 <hr/>
45 <h3>使用Java脚本实现以上功能</h3>
46 <ul>
47
48 <li>把一个值放入page域中。<%pageContext.setAttribute("data1","xdp");%></li>
49 <li>从page域中得到值:<%out.println(pageContext.getAttribute("data1"));%></li>
50
51 <li>把一个值放入request域中。<%request.setAttribute("data2","gacl");%></li>
52 <li>从request域中得到值:<%out.println(request.getAttribute("data2"));%></li>
53
54 <li>把一个值放入session域中。<%session.setAttribute("name1","孤傲苍狼");%></li>
55 <li>从session中域得到值:<%out.println(session.getAttribute("name1"));%></li>
56 <%--out.println()方法与<%=%>表达式输出功能一样
57 但使用表达式输出（<%=%>）明显要比使用out.println()输出更好。
58 --%>
59 <li><%=session.getAttribute("name1") %></li>
60 <li>把另一个值放入application域中。<%application.setAttribute("name2","白虎神皇");%></li>
61 <li> 从application域中得到值：<%out.println(application.getAttribute("name2"));%></li>
62 <li><%=application.getAttribute("name2")%></li>
63
64 <li>未指定scope的范围，会从不同的范围内查找得到相应的值：
65 <%=pageContext.findAttribute("data1")%>、
66 <%=pageContext.findAttribute("data2")%>、
67 <%=pageContext.findAttribute("name1")%>、
68 <%=pageContext.findAttribute("name2")%>
69 </li>
70
71 </ul>
72 <hr/>
73 <h3>操作JavaBean，设置JavaBean的属性值</h3>
74 <%--设置JavaBean的属性值，等同与setter方法，Target指向实例化后的对象，property指向要插入值的参数名。
75 注意：使用target时一定要指向实例化后的JavaBean对象，也就是要跟<jsp:useBean>配套使用，
76 也可以java脚本实例化，但这就失去了是用标签的本质意义。
77 使用Java脚本实例化：
78 <%@page import="javabean.Person"%
79 <% Person person=new Person(); %>
80 --%>
81 <c:set target="${person}" property="name">孤傲苍狼</c:set>
82 <c:set target="${person}" property="age">25</c:set>
83 <c:set target="${person}" property="sex">男</c:set>
84 <c:set target="${person}" property="home">中国</c:set>
85 <ul>
86 <li>使用的目标对象为：${person}</li>
87 <li>从Bean中获得的name值为：<c:out value="${person.name}"></c:out></li>
88 <li>从Bean中获得的age值为：<c:out value="${person.age}"></c:out></li>
89 <li>从Bean中获得的sex值为：<c:out value="${person.sex}"></c:out></li>
90 <li>从Bean中获得的home值为：<c:out value="${person.home}"></c:out></li>
91 </ul>
92 <hr/>
93 <h3>操作Map</h3>
94 <%
95 Map map = new HashMap();
96 request.setAttribute("map",map);
97 %>
98 <%--将data对象的值存储到map集合中 --%>
99 <c:set property="data" value="gacl" target="${map}"/>
100 ${map.data}
101 </body>
102 </html>jsp页面中使用到的javabean.Person类的代码如下： 1 package javabean;2
3 /**
4 * 项目名称：JSTLStudy
5 * 类名称：Person
6 * 类描述：一个只有getter和setter方法的JavaBean或者说一个pojo(简单的Java对象(Plain Old Java Objects))类，
7 * 作为一个vo（数据传输对象）。定义了四个变量age、name、sex和home。
8 */
9
10 public class Person {
11
12 private String age;
13
14 private String home;
15
16 private String name;
17
18 private String sex;
19
20 public String getAge() {
21 return age;
22 }
23
24 public String getHome() {
25 return home;
26 }
27
28 public String getName() {
29 return name;
30 }
31
32 public String getSex() {
33 return sex;
34 }
35
36 public void setAge(String age) {
37 this.age = age;
38 }
39
40 public void setHome(String home) {
41 this.home = home;
42 }
43 public void setName(String name) {
44 this.name = name;
45 }
46 public void setSex(String sex) {
47 this.sex = sex;
48 }
49 }运行结果，如图所示：
3.3.3 表达式控制标签——remove标签使用总结<c:remove>标签的功能
<c:remove>标签主要用来从指定的JSP范围内移除指定的变量。
<c:remove>标签的语法
<c:remove var=”变量名” [scope=”page|request|session|application”]/>
其中var属性是必须的，scope可以以省略。
<c:remove>标签的使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: --表达式控制标签“remove”标签的使用</title>
8 </head>
9
10 <body>
11 <ul>
12 <c:set var="name" scope="session">孤傲苍狼</c:set>
13 <c:set var="age" scope="session">25</c:set>
14 <li><c:out value="${sessionScope.name}"></c:out></li>
15 <li><c:out value="${sessionScope.age}"></c:out></li>
16 <%--使用remove标签移除age变量 --%>
17 <c:remove var="age" />
18 <li><c:out value="${sessionScope.name}"></c:out></li>
19 <li><c:out value="${sessionScope.age}"></c:out></li>
20 </ul>
21 </body>
22 </html>运行结果如下：
3.3.4 表达式控制标签——catch标签使用总结<c:catch>标签的功能
<c:catch>标签用于捕获嵌套在标签体中的内容抛出的异常。
<c:catch>标签的语法
其语法格式如下：<c:catch [var="varName"]>容易产生异常的代码</c:catch>
var属性用于标识<c:catch>标签捕获的异常对象，它将保存在page这个Web域中。
<c:catch>标签的使用范例
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: --表达式控制标签“catch”标签实例</title>
8 </head>
9
10 <body>
11 <h4>catch标签实例</h4>
12 <hr>
13 <%--把容易产生异常的代码放在<c:catch></c:catch>中，
14 自定义一个变量errorInfo用于存储异常信息 --%>
15 <c:catch var="errorInfo">
16 <%--实现了一段异常代码，向一个不存在的JavaBean中插入一个值--%>
17 <c:set target="person" property="hao"></c:set>
18 </c:catch>
19 <%--用EL表达式得到errorInfo的值，并使用<c:out>标签输出 --%>
20 异常：<c:out value="${errorInfo}" /><br />
21 异常 errorInfo.getMessage：<c:out value="${errorInfo.message}" /><br />
22 异常 errorInfo.getCause：<c:out value="${errorInfo.cause}" /><br />
23 异常 errorInfo.getStackTrace：<c:out value="${errorInfo.stackTrace}" />
24 </body>
25 </html>运行结果，如图所示：
3.3.5 流程控制标签——if标签使用总结<c:if>标签的功能
<c:if>标签和程序中的if语句作用相同，用来实现条件控制。
<c:if>标签的语法
【语法1】：没有标签体内容(body)
<c:if test="testCondition" var="varName" [scope="{page|request|session|application}"]/>
【语法2】：有标签体内容
<c:if test="testCondition" [var="varName"] [scope="{page|request|session|application}"]>
标签体内容
</c:if>
【参数说明】：
（1）test属性用于存放判断的条件，一般使用EL表达式来编写。
（2）var属性用来存放判断的结果，类型为true或false。
（3）scopes属性用来指定var属性存放的范围。
<c:if>标签的属性
<c:if>标签的使用范例
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: --流程控制标签 if标签示例</title>
8 </head>
9
10 <body>
11 <h4>if标签示例</h4>
12 <hr>
13 <form action="JSTL_if_tag.jsp" method="post">
14 <input type="text" name="uname" value="${param.uname}">
15 <input type="submit" value="登录">
16 </form>
17 <%--使用if标签进行判断并把检验后的结果赋给adminchock，存储在默认的page范围中。 --%>
18 <c:if test="${param.uname=='admin'}" var="adminchock">
19 <%--可以把adminchock的属性范围设置为session，这样就可以在其他的页面中得到adminchock的值，
20 使用<c:if text=”${adminchock}”><c:if>判断，实现不同的权限。 --%>
21 <c:out value="管理员欢迎您！"/>
22 </c:if>
23 <%--使用EL表达式得到adminchock的值，如果输入的用户名为admin将显示true。 --%>
24 ${adminchock}
25 </body>
26 </html>运行结果，如图所示：3.3.6 流程控制标签——choose标签、when标签、otherwise标签配合使用讲解<c:choose>、<c:when>和<c:otherwise>标签的功能
<c:choose>、<c:when>和<c:otherwise>这3个标签通常情况下是一起使用的，<c:choose>标签作为<c:when>和<c:otherwise>标签的父标签来使用。
使用<c:choose>，<c:when>和<c:otherwise>三个标签，可以构造类似 “if-else if-else” 的复杂条件判断结构。
语法
<c:choose>
<c:when test="条件1">
//业务逻辑1
<c:when>
<c:when test="条件2">
//业务逻辑2
<c:when>
<c:when test="条件n">
//业务逻辑n
<c:when>
<c:otherwise>
//业务逻辑
</c:otherwise>
</c:choose>
使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- choose及其嵌套标签标签示例</title>
8 </head>
9
10 <body>
11 <h4>choose及其嵌套标签示例</h4>
12 <hr/>
13 <%--通过set标签设定score的值为85 --%>
14 <c:set var="score" value="85"/>
15 <c:choose>
16 <%--使用<c:when>进行条件判断。
17 如果大于等于90，输出“您的成绩为优秀”；
18 如果大于等于70小于90，输出“您的成绩为良好”；
19 大于等于60小于70，输出“您的成绩为及格”；
20 其他（otherwise）输出“对不起，您没能通过考试”。
21 --%>
22 <c:when test="${score>=90}">
23 你的成绩为优秀！
24 </c:when>
25 <c:when test="${score>70 && score<90}">
26 您的成绩为良好!
27 </c:when>
28 <c:when test="${score>60 && score<70}">
29 您的成绩为及格
30 </c:when>
31 <c:otherwise>
32 对不起，您没有通过考试！
33 </c:otherwise>
34 </c:choose>
35 </body>
36 </html>运行结果如下：
3.3.7 循环标签——forEach标签使用总结
<c:forEach>标签的功能
该标签根据循环条件遍历集合（Collection）中的元素。
<c:forEach>标签的语法
<c:forEach
var=”name”
items=”Collection”
varStatus=”StatusName”
begin=”begin”
end=”end”
step=”step”>
本体内容
</c:forEach>
【参数解析】：
（1）var设定变量名用于存储从集合中取出元素。
（2）items指定要遍历的集合。
（3）varStatus设定变量名，该变量用于存放集合中元素的信息。
（4）begin、end用于指定遍历的起始位置和终止位置（可选）。
（5）step指定循环的步长。
<c:forEach>标签属性
其中varStatus有4个状态属性，如下表所示：
<c:forEach>使用范例
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <%@page import="java.util.ArrayList"%>
5 <!DOCTYPE HTML>
6 <html>
7 <head>
8 <title>JSTL: -- forEach标签实例</title>
9 </head>
10
11 <body>
12 <h4><c:out value="forEach实例"/></h4>
13 <%
14 List<String>list = new ArrayList<String>();
15 list.add(0, "贝贝");
16 list.add(1, "晶晶");
17 list.add(2, "欢欢");
18 list.add(3, "莹莹");
19 list.add(4, "妮妮");
20 request.setAttribute("list", list);
21 %>
22 <B><c:out value="不指定begin和end的迭代：" /></B><br>
23 <%--不使用begin和end的迭代，从集合的第一个元素开始，遍历到最后一个元素。 --%>
24 <c:forEach var="fuwa" items="${list}">
25 <c:out value="${fuwa}"/><br/>
26 </c:forEach>
27
28 <B><c:out value="指定begin和end的迭代：" /></B><br>
29 <%--指定begin的值为1、end的值为3、step的值为2，
30 从第二个开始首先得到晶晶，每两个遍历一次，
31 则下一个显示的结果为莹莹，end为3则遍历结束。 --%>
32 <c:forEach var="fuwa" items="${list}" begin="1" end="3" step="2">
33 <c:out value="${fuwa}"/><br/>
34 </c:forEach>
35
36 <B><c:out value="输出整个迭代的信息：" /></B><br>
37 <%--指定varStatus的属性名为s，并取出存储的状态信息 --%>
38 <c:forEach var="fuwa"
39 items="${list}"
40 begin="3"
41 end="4"
42 varStatus="s"
43 step="1">
44 <c:out value="${fuwa}" />的四种属性：<br>
45 所在位置，即索引：<c:out value="${s.index}" /><br>
46 总共已迭代的次数：<c:out value="${s.count}" /><br>
47 是否为第一个位置：<c:out value="${s.first}" /><br>
48 是否为最后一个位置：<c:out value="${s.last}" /><br>
49 </c:forEach>
50 </body>
51 </html>运行结果，如图所示：3.3.8 循环标签——forTokens标签使用总结<c:forTokens>标签的功能
该标签用于浏览字符串，并根据指定的字符将字符串截取。
<c:forTokens>标签的语法
语法：
<c:forTokens items=”strigOfTokens”
delims=”delimiters”
[var=”name”
begin=”begin”
end=”end”
step=”len”
varStatus=”statusName”] >
本体内容
</c:forTokens>
【参数说明】
（1）items指定被迭代的字符串。
（2）delims指定使用的分隔符。
（3）var指定用来存放遍历到的成员。
（4）begin指定遍历的开始位置（int型从取值0开始）。
（5）end指定遍历结束的位置（int型，默认集合中最后一个元素）。
（6）step遍历的步长（大于0的整型）。
（7）varStatus存放遍历到的成员的状态信息。
<c:forTokens>使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- forTokens标签实例</title>
8 </head>
9
10 <body>
11 <h4><c:out value="forToken实例"/></h4>
12 <hr/>
13 <%--提示：分隔符的作用是根据标识，截取字符串。
14 如果未设定分隔符或在字符串中没有找到分隔付，将把整个元素作为一个元素截取。
15 在实际应用中用于在除去某些符号在页面中显示。 --%>
16 <c:forTokens var="str" items="北、京、欢、迎、您" delims="、">
17 <c:out value="${str}"></c:out><br/>
18 </c:forTokens>
19 <br/>
20 <c:forTokens items="123-4567-8854" delims="-" var="t">
21 <c:out value="${t}"></c:out><br/>
22 </c:forTokens>
23 <br/>
24 <c:forTokens items="1*2*3*4*5*6*7"
25 delims="*"
26 begin="1"
27 end="3"
28 var="n"
29 varStatus="s">
30 <c:out value="${n}" />的四种属性：<br>
31 所在位置，即索引：<c:out value="${s.index}" /><br>
32 总共已迭代的次数：<c:out value="${s.count}" /><br>
33 是否为第一个位置：<c:out value="${s.first}" /><br>
34 是否为最后一个位置：<c:out value="${s.last}" /><br>
35 </c:forTokens>
36 </body>
37 </html>运行结果如下：
3.3.9 URL操作标签——import标签使用讲解<c:import>标签的功能
该标签可以把其他静态或动态文件包含到本JSP页面，与<jsp:include>的区别为：<jsp:include>只能包含同一个web应用中的文件。而<c:import>可以包含其他web应用中的文件，甚至是网络上的资源。
<c:import>标签的语法
【语法1】：
<c:import
url=”url”
[context=”context”]
[value=”value”]
[scope=”page|request|session|application”]
[charEncoding=”encoding”]/>
【语法2】：
<c:import
url=”url”
varReader=”name”
[context=”context”]
[charEncoding=”encoding”]/>
【参数说明】：
（1）URL为资源的路径，当引用的资源不存在时系统会抛出异常，因此该语句应该放在<c:catch></c:catch>语句块中捕获。
（2）引用资源有两种方式：绝对路径和相对路径。
使用绝对路径的示例如下：<c:import url=”http://www.baidu.com”>
使用相对路径的示例如下：<c:import url=”aa.txt”>，aa.txt放在同一文件目录。
（3）如果以“/”开头表示应用的根目录下。例如：tomcat应用程序的根目录文件夹为webapps。导入webapps下的文件bb.txt的编写方式为：<c:import url=”/bb.txt”>
如果访问webapps管理文件夹中其他web应用就要用context属性。
（4）context属性用于在访问其他web应用的文件时，指定根目录。例如，访问root下的index.jsp的实现代码为：<c:import url=”/index.jsp” context=”/root”>
等同于webapps/root/index.jsp
（5）var、scope、charEncoding、varReader是可选属性。
<c:import>标签的使用范例
1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- import标签实例</title>
8 </head>
9
10 <body>
11 <h4><c:out value="import实例"/></h4>
12 <hr/>
13 <h4><c:out value="绝对路径引用的实例" /></h4>
14 <%--使用绝对路径导入百度首页，
15 导入时使用<c:catch></c:catch>捕获异常。
16 --%>
17 <c:catch var="error1">
18 <c:import url="http://wwww.baidu.com" charEncoding="utf-8"/>
19 </c:catch>
20 ${error1}
21 <hr/>
22 <h4>
23 <c:out value="相对路径引用本应用中的文件" />
24 </h4>
25 <%--使用相对路径导入同一文件夹下的“JSTL的import标签使用说明”文件，
26 接收的字符编码格式使用charEncoding设置为utf-8。 --%>
27 <c:catch var="error2">
28 <c:import url="JSTL的import标签使用说明" charEncoding="utf-8"/>
29 </c:catch>
30 ${error2}
31 <hr/>
32 <h4><c:out value="使用字符串输出相对路径引用的实例，并保存在session范围内" /></h4>
33 <%--导入“JSTL的import标签使用说明.txt”，
34 使用var定义的变量接收要导入的文件，并存储在session中，
35 如果在其他页面同样也要导入该文件，只须使用<c:out>输出“JSTL的import标签使用说明.txt”的值即可。
36 --%>
37 <c:catch var="error3">
38 <c:import
39 var="myurl"
40 url="JSTL的import标签使用说明"
41 scope="session"
42 charEncoding="utf-8"/>
43 <c:out value="${myurl}"></c:out>
44 <hr/>
45 <c:out value="${myurl}" />
46 </c:catch>
47 ${error3}
48 </body>
49 </html>3.3.10 URL操作标签——url标签使用总结<c:url>标签的功能<c:url>标签用于在JSP页面中构造一个URL地址，其主要目的是实现URL重写。
<c:url>标签的语法
【语法1】：指定一个url不做修改，可以选择把该url存储在JSP不同的范围中。
<c:url
value=”value”
[var=”name”]
[scope=”page|request|session|application”]
[context=”context”]/>
【语法2】：配合 <c:param>标签给url加上指定参数及参数值，可以选择以name存储该url。
<c:url
value=”value”
[var=”name”]
[scope=”page|request|session|application”]
[context=”context”]>
<c:param name=”参数名” value=”值”>
</c:url>
<c:url>标签的主要属性
<c:url>标签使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- url标签实例</title>
8 </head>
9
10 <body>
11 <c:out value="url标签使用"></c:out>
12 <h4>使用url标签生成一个动态的url，并把值存入session中.</h4>
13 <hr/>
14 <c:url value="http://www.baidu.com" var="url" scope="session">
15 </c:url>
16 <a href="${url}">百度首页(不带参数)</a>
17 <hr/>
18 <h4>
19 配合 <c:param>标签给url加上指定参数及参数值，生成一个动态的url然后存储到paramUrl变量中
20 </h4>
21 <c:url value="http://www.baidu.com" var="paramUrl">
22 <c:param name="userName" value="孤傲苍狼"/>
23 <c:param name="pwd">123456</c:param>
24 </c:url>
25 <a href="${paramUrl}">百度首页(带参数)</a>
26 </body>
27 </html>3.3.11 URL操作标签——redirect标签使用总结<c:redirect>标签的功能
该标签用来实现请求的重定向。同时可以配合使用<c:param>标签在url中加入指定的参数。
<c:redirect>标签的语法
【语法1】：
<c:redirect url=”url” [context=”context”]/>
【语法2】：
<c:redirect url=”url”[context=”context”]>
<c:param name=”name1” value=”value1”>
</c:redirect>
【参数说明】：
（1）url指定重定向页面的地址，可以是一个string类型的绝对地址或相对地址。
（2）context用于导入其他web应用中的页面。
<c:redirect>标签的属性
<c:redirect>标签使用范例 1 <%@ page language="java" import="java.util.*" pageEncoding="UTF-8"%>
2 <%--引入JSTL核心标签库 --%>
3 <%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
4 <!DOCTYPE HTML>
5 <html>
6 <head>
7 <title>JSTL: -- redirect标签实例</title>
8 </head>
9
10 <body>
11 <c:redirect url="http://www.baidu.com">
12 <%--在重定向时使用<c:param>标签为URL添加了两个参数：uname=GACL和password=123 --%>
13 <c:param name="uname">GACL</c:param>
14 <c:param name="password">123</c:param>
15 </c:redirect>
16 </body>
17 </html>
3.3.12 <c:param>标签使用总结在JSP页面进行URL的相关操作时，经常要在URL地址后面附加一些参数。<c:param>标签可以嵌套在<c:import>、<c:url>或<c:redirect>标签内，为这些标签所使用的URL地址附加参数。
<c:param>标签在为一个URL地址附加参数时，将自动对参数值进行URL编码，例如，如果传递的参数值为“中国”， 则将其转换为“%d6%d0%b9%fa”后再附加到URL地址后面，这也就是使用<c:param>标签的最大好处。
示例1：与<c:url>标签嵌套使用 <c:url value="http://www.baidu.com" var="paramUrl">
<c:param name="userName" value="孤傲苍狼"/>
<c:param name="pwd">123456</c:param>
</c:url>
<a href="${paramUrl}">百度首页(带参数)</a> 示例2：与<c:redirect>标签嵌套使用 <c:redirect url="http://www.baidu.com">
<%--在重定向时使用<c:param>标签为URL添加了两个参数：uname=GACL和password=123 --%>
<c:param name="uname">GACL</c:param>
<c:param name="password">123</c:param>
</c:redirect>关于JSTL核心标签库中的标签掌握以上的那些标签基本上就可以应付开发了。
---------------------------------------- 我是低调的分隔线 ----------------------------------------
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- 【javaweb：el&jstl】通过模拟用户登录，使网页"登录""测试"部分变成“用户”和“退出”
- Java_Web之JSTL和EL
- Java Web day（8）之EL拓展对象JSTL及mcv，javaweb三层框架简介
- Java进阶学习第十三天——JSTL&EL学习
- 【JAVA基础】—JSTL & EL—善用帮助
- 面试题-Java Web-JSTL/EL部分
- Java Web 自定义标签 JSTL及EL语言
- Java复习第六天---EL&JSTL基础知识
- java-使用 freemarker 替换 jstl EL 开发 springmvc web项目
- JavaWeb-12 (自定义标签库开发&JSTL标签库)
- 超全面的JavaWeb笔记day13<JSTL&自定义标签>
- Java Web入门之EL、JSTL、自定义标签要点
- 关于jstl EL用法的注意点（java.lang.NumberFormatException: For input string: "userName"）
- 关于jstl EL用法的注意点（java.lang.NumberFormatException: For input string: "userName"）
- Java Web EL JSTL的用法
- javaweb之jstl+el完成数据迭代
- JAVA WEB从入门到精通day13 Jsp详解和EL，JSTL详解
- DRP问题集结（二）---【Error】JavaWeb: 严重: Failed to initialize end point associated with ProtocolHandler ["ht
- Web---JSTL(Java标准标签库)-Core核心标签库、I18N国际化、函数库
- EL&JSTL