28. EL 表达式 以及 JSTL 标签库
28. EL 表达式 以及 JSTL 标签库
Devops海洋的渔夫
发布于 2021-11-19 16:13:53
发布于 2021-11-19 16:13:53
28. EL 表达式 以及 JSTL 标签库
1.EL 表达式
a)什么是 EL 表达式，EL 表达式的作用?
- EL 表达式的全称是：Expression Language。是表达式语言。
- EL 表达式的什么作用：EL 表达式主要是代替 jsp 页面中的表达式脚本在 jsp 页面中进行数据的输出。
下面我们来举例说明一下：
1.创建 a.jsp 页面，分别使用 表达式脚本 以及 EL 表达式 输出内容
image-20201129142911898
<body>
<%
request.setAttribute("key","值");
%>
表达式脚本输出key的值是：<%=request.getAttribute("key")%><br/>
EL表达式输出key的值是：${key}
</body>
浏览器访问如下：
image-20201129143032528
2.两种表达式在处理 null 的情况
image-20201129143131556
从结果来看：
- 表达式脚本输出 null 值 在浏览器直接就是 null 字符串显示
- EL表达式会进行一定的处理，浏览器不显示 null
这让用户感觉更加友好。
3.如果 表达式脚本也要将 null 值 在浏览器中不显示，那就需要写一个三元表达式，如下：
image-20201129143356923
<body>
<%
request.setAttribute("key","值");
%>
表达式脚本输出key的值是：<%=request.getAttribute("key1")==null? "":request.getAttribute("key1") %><br/>
EL表达式输出key的值是：${key1}
</body>
4.总结
- EL 表达式在输出数据的时候，要比 jsp 的表达式脚本要简洁很多。
- EL 表达式的格式是：
${表达式} - EL 表达式在输出 null 值的时候，输出的是空串。jsp 表达式脚本输出 null 值的时候，输出的是 null 字符串。
b)EL 表达式搜索域数据的顺序
EL 表达式主要是在 jsp 页面中输出数据。
主要是输出域对象中的数据。
当四个域中都有相同的 key 的数据的时候，EL 表达式会按照四个域的从小到大的顺序去进行搜索，找到就输出。
示例如下：
1.创建 b.jsp，使用四个域对象存入相同的 key 数据
image-20201129224230092
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
//往四个域中都保存了相同的 key 的数据。
request.setAttribute("key", "request");
session.setAttribute("key", "session");
application.setAttribute("key", "application");
pageContext.setAttribute("key", "pageContext");
%>
<%--使用 EL 表达式取值--%>
${ key }
</body>
</html>
2.访问 b.jsp ，查看会从四个域对象中取值
image-20201129224415206
3.注释 pageContext 对象，再次访问 b.jsp，查看取值
image-20201129224525125
4.注释 request 对象，再次访问 b.jsp ，查看取值
image-20201129224621778
5.注释 session 对象，再次访问 b.jsp , 查看取值
image-20201129224742342
6.总结：EL 表达式搜索域数据的顺序 ， pageContext > request > session > application
c)EL 表达式输出 Bean 的普通属性，数组属性。List 集 合属性，map 集合属性
需求——输出 Person 类中普通属性，数组属性。list 集合属性和 map 集合属性。
1.创建 Person 类
image-20201129230325475
package pojo;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
/**
* @author Aron.li
* @date 2020/11/29 23:01
*/
public class Person {
//定义普通属性，数组属性。list 集合属性和 map 集合属性
private String name;
private String[] phones;
private List<String> cities;
private Map<String,Object> map;
//构造器
public Person() {
}
public Person(String name, String[] phones, List<String> cities, Map<String, Object> map) {
this.name = name;
this.phones = phones;
this.cities = cities;
this.map = map;
}
// toString
@Override
public String toString() {
return "Person{" +
"name='" + name + '\'' +
", phones=" + Arrays.toString(phones) +
", cities=" + cities +
", map=" + map +
'}';
}
// getter setter
public String getName() {
return name;
}
public void setName(String name) {
this.name = name;
}
public String[] getPhones() {
return phones;
}
public void setPhones(String[] phones) {
this.phones = phones;
}
public List<String> getCities() {
return cities;
}
public void setCities(List<String> cities) {
this.cities = cities;
}
public Map<String, Object> getMap() {
return map;
}
public void setMap(Map<String, Object> map) {
this.map = map;
}
}
2.创建 c.jsp，在里面创建 Person 类对象，并使用 EL 表达式输出
image-20201129231518019
<%@ page import="pojo.Person" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page import="java.util.Map" %>
<%@ page import="java.util.HashMap" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
//创建Person对象
Person person = new Person();
//设置String属性
person.setName("肥子白");
//设置数组属性
person.setPhones(new String[]{"18610523456","18688886666","18699998888"});
//设置集合属性
List<String> cities = new ArrayList<String>();
cities.add("北京");
cities.add("上海");
cities.add("深圳");
person.setCities(cities);
//设置Map属性
Map<String,Object> map = new HashMap<>();
map.put("key1","value1");
map.put("key2","value2");
map.put("key3","value3");
person.setMap(map);
//将Person存储在pageContext域对象
pageContext.setAttribute("p", person);
%>
输出Person：${ p }<br/>
输出Person的name属性：${p.name} <br>
输出Person的pnones数组属性值：${p.phones[2]} <br>
输出Person的cities集合中的元素值：${p.cities} <br>
输出Person的List集合中个别元素值：${p.cities[2]} <br>
输出Person的Map集合: ${p.map} <br>
输出Person的Map集合中某个key的值: ${p.map.key3} <br>
</body>
</html>
浏览器访问 c.jsp，如下：
image-20201129231618876
3.EL表达式取 Bean 对象的值是基于 getter 属性的
3.1 在 Person 类中，任意写一个 getAge() 方法，如下：
image-20201129231818001
3.2 在 c.jsp 中，使用 EL 表达式读取 age 的值，如下：
image-20201129232039165
d)EL 表达式——运算
语法：${ 运算表达式 } ， EL 表达式支持如下运算符：
1. 关系运算
关系运算符 | 说明 | 范例 | 结果 |
|---|---|---|---|
== 或 eq | 等于 | 或{ 5 eq 5 } | TRUE |
!= 或 ne | 不等于 | 或{ 5 ne 5 } | FALSE |
< 或 lt | 小于 | 或{ 3 lt 5 } | TRUE |
> 或 gt | 大于 | 或{ 2 gt 10 } | FALSE |
<= 或 le | 小于等于 | 或{ 5 le 12 } | TRUE |
>= 或 ge | 大于等于 | 或{ 3 ge 5 } | FALSE |
{ 5 eq 5 }TRUE!= 或 ne不等于
{ 5 ne 5 }FALSE< 或 lt小于
{ 3 lt 5 }TRUE> 或 gt大于
{ 2 gt 10 }FALSE<= 或 le小于等于
{ 5 le 12 }TRUE>= 或 ge大于等于
{ 3 ge 5 }FALSE
1.1 创建 jsp，演示关系运算如下
image-20201129232520444
<body>
<h1>关系运算符</h1>
${ 12 == 12 } 或 ${ 12 eq 12 } <br>
${ 12 != 12 } 或 ${ 12 ne 12 } <br>
${ 12 < 12 } 或 ${ 12 lt 12 } <br>
${ 12 > 12 } 或 ${ 12 gt 12 } <br>
${ 12 <= 12 } 或 ${ 12 le 12 } <br>
${ 12 >= 12 } 或 ${ 12 ge 12 } <br>
</body>
2. 逻辑运算
逻辑运算符 | 说明 | 范例 | 结果 |
|---|---|---|---|
&& 或 and | 与运算 | { 12 == 12 && 12 < 11 } 或{ 12 == 12 and 12 < 11 } | FALSE |
|| 或 or | 或运算 | 或{ 12 == 12 or 12 < 11 } | TRUE |
! 或 not | 取反运算 | 或{not true } | FALSE |
{ 12 == 12 and 12 < 11 }FALSE|| 或 or或运算
{ 12 == 12 or 12 < 11 }TRUE! 或 not取反运算
{not true }FALSE
2.1 代码演示：
image-20201129232742809
<body>
<h1>逻辑运算</h1>
${ 12 == 12 && 12 > 11 } 或 ${ 12 == 12 and 12 > 11 } <br>
${ 12 == 12 || 12 > 11 } 或 ${ 12 == 12 or 12 > 11 } <br>
${ ! true } 或 ${ not true } <br>
</body>
3. 算数运算
算数运算符 | 说明 | 范例 | 结果 |
|---|---|---|---|
+ | 加法 | ${ 12 + 18 } | 30 |
- | 减法 | ${ 18 - 8 } | 10 |
* | 乘法 | ${ 12 * 12 } | 144 |
/ 或 div | 除法 | 或{ 144 div 12 } | 12 |
% 或 mod | 取模 | { 144 % 10 } 或{ 144 mod 10 } | 4 |
{ 144 div 12 }12% 或 mod取模
{ 144 mod 10 }4
3.1 代码演示：
image-20201129233022576
<body>
<h1>算数运算</h1>
12 + 12 = ${ 12 + 12 } <br>
12 - 12 = ${ 12 - 12 } <br>
12 * 12 = ${ 12 * 12 } <br>
18 / 12 = ${ 18 / 12 } 或 ${ 18 div 12 }<br>
18 % 12 = ${ 18 % 12 } 或 ${ 18 mod 12 } <br>
</body>
4. empty 运算
empty 运算可以判断一个数据是否为空，如果为空，则输出 true,不为空输出 false。
以下几种情况为空：
1、值为 null 值的时候，为空
2、值为空串的时候，为空
3、值是 Object 类型数组，长度为零的时候
4、list 集合，元素个数为零
5、map 集合，元素个数为零
4.1 代码演示：
image-20201130074830399
<body>
<%
// 1、值为null值的时候，为空
request.setAttribute("emptyNull", null);
// 2、值为空串的时候，为空
request.setAttribute("emptyStr", ""); // 空字符串
request.setAttribute("notEmptyStr", "hello"); // 字符串不为空
// 3、值是Object类型数组，长度为零的时候
request.setAttribute("emptyArr", new Object[]{}); // 数组长度为零
request.setAttribute("notEmptyArr", new Object[]{1,2,3}); // 数组长度不为零
// 4、list集合，元素个数为零
// 4.1 非空list
List<String> list = new ArrayList<>();
list.add("add");
request.setAttribute("notEmptyList", list);
// 4.2 空list
ArrayList<Object> list1 = new ArrayList<>();
request.setAttribute("emptyList", list1);
// 5、map集合，元素个数为零
// 5.1 非空map
Map<String,Object> map = new HashMap<String, Object>();
map.put("key1", "value1");
request.setAttribute("notEmptyMap", map);
// 5.2 空map
HashMap<String, Object> map1 = new HashMap<>();
request.setAttribute("emptyMap", map);
%>
<%--1、值为null值的时候，为空--%>
emptyNull: ${ empty emptyNull } <br/>
<%--2、值为空串的时候，为空--%>
emptyStr: ${ empty emptyStr } <br/>
notEmptyStr: ${ empty notEmptyStr } <br/>
<%--3、值是Object类型数组，长度为零的时候--%>
emptyArr: ${ empty emptyArr } <br/>
notEmptyArr: ${ empty notEmptyArr } <br/>
<%--4、list集合，元素个数为零--%>
<%--4.1 非空list--%>
notEmptyList: ${ empty notEmptyList } <br/>
<%--4.2 空list--%>
emptyList: ${ empty emptyList } <br/>
<%--5、map集合，元素个数为零--%>
notEmptyMap: ${ empty notEmptyMap } <br/>
emptyMap: ${ empty emptyMap } <br/>
</body>
5. 三元运算
表达式 1？表达式 2：表达式 3
如果表达式 1 的值为真，返回表达式 2 的值，如果表达式 1 的值为假，返回表达式 3 的值。
示例：
image-20201130075158301
<%--三元表单时--%>
${ 12 == 13 ? "12等于13" : "12不等于13" }
6. “.”点运算 和 [] 中括号运算符
.点运算，可以输出 Bean 对象中某个属性的值。
[]中括号运算，可以输出有序集合中某个元素的值。
并且[]中括号运算，还可以输出 map 集合中 key 里含有特殊字符的 key 的值。
示例:
image-20201130075955855
<body>
<%
//创建HashMap
Map<String,Object> map = new HashMap<String, Object>();
map.put("a", "a1Value");
map.put("a.a.a", "aaaValue"); // 设置特殊字符在key中
map.put("b+b+b", "bbbValue");
map.put("c-c-c", "cccValue");
request.setAttribute("map", map);
%>
<%--使用 . 获取map的值--%>
map.a: ${ map.a } <br>
<%--使用 [] 获取特殊字符key的值 --%>
map['a.a.a']: ${ map['a.a.a'] } <br>
map["b+b+b"]: ${ map["b+b+b"] } <br>
map['c-c-c']: ${ map['c-c-c'] } <br>
</body>
e)EL 表达式的 11 个隐含对象
EL 个达式中 11 个隐含对象，是 EL 表达式中自己定义的，可以直接使用。
变量 | 类型 | 作用 |
|---|---|---|
pageContext | PageContextImpl | 它可以获取 jsp 中的九大内置对象 |
pageScope | Map<String,Object> | 它可以获取 pageContext 域中的数据 |
requestScope | Map<String,Object> | 它可以获取 Request 域中的数据 |
sessionScope | Map<String,Object> | 它可以获取 Session 域中的数据 |
applicationScope | Map<String,Object> | 它可以获取 ServletContext 域中的数据 |
param | Map<String,String> | 它可以获取请求参数的值 |
paramValues | Map<String,String[]> | 它也可以获取请求参数的值，获取多个值的时候使用。 |
header | Map<String,String> | 它可以获取请求头的信息 |
headerValues | Map<String,String[]> | 它可以获取请求头的信息，它可以获取多个值的情况 |
cookie | Map<String,Cookie> | 它可以获取当前请求的 Cookie 信息 |
initParam | Map<String,String> | 它可以获取在 web.xml 中配置的上下文参数 |
1. EL 获取四个特定域中的属性
pageScope ====== pageContext 域
requestScope ====== Request 域
sessionScope ====== Session 域
applicationScope ====== ServletContext 域
示例：
image-20201130081835846
<body>
<%
// 存储EL表达式可以读取的 四个域对象数据
request.setAttribute("key2", "request");
pageContext.setAttribute("key1", "pageContext1");
pageContext.setAttribute("key2", "pageContext2");
session.setAttribute("key2", "session");
application.setAttribute("key2", "application");
%>
<%--使用EL表达式读取 四个域对象的数据--%>
<%--EL表达式读取 request域对象的值--%>
requestScope: ---- ${ requestScope } <br>
requestScope.key2: ---- ${ requestScope.key2 } <br>
<%--EL表达式读取 pageContext 域对象的值--%>
pageContext.key1: ---- ${pageScope.key1} <br>
pageContext.key2: ---- ${pageScope.key2} <br>
<%--EL表达式读取 session 域对象的值--%>
sessionScope.key1: ---- ${sessionScope.key2} <br>
<%--EL表达式读取 application 域对象的值--%>
applicationScope.key1: ---- ${applicationScope.key2} <br>
</body>
2. pageContext 对象的使用
- 协议：
- 服务器 ip：
- 服务器端口：
- 获取工程路径：
- 获取请求方法：
- 获取客户端 ip 地址：
- 获取会话的 id 编号：
示例:
image-20201130230900242
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--在表达式脚本中，使用request输出相关信息--%>
<h3>在表达式脚本中，使用request输出相关信息</h3>
request.getScheme() 它可以获取请求的协议: <%=request.getScheme()%> <br>
request.getServerName() 获取请求的服务器 ip 或域名: <%=request.getServerName()%> <br>
request.getServerPort() 获取请求的服务器端口号: <%=request.getServerPort()%> <br>
getContextPath() 获取当前工程路径: <%=request.getContextPath()%> <br>
request.getMethod() 获取请求的方式（GET 或 POST）: <%=request.getMethod()%> <br>
request.getRemoteHost() 获取客户端的 ip 地址: <%=request.getRemoteHost()%> <br>
session.getId() 获取会话的唯一标识: <%=session.getId()%> <br>
<hr>
<%--使用EL表达式，输出相关信息--%>
<h3>使用EL表达式，输出相关信息</h3>
1.协议： ${ pageContext.request.scheme }<br>
2.服务器 ip：${ pageContext.request.serverName }<br>
3.服务器端口：${ pageContext.request.serverPort }<br>
4.获取工程路径：${ pageContext.request.contextPath }<br>
5.获取请求方法：${ pageContext.request.method }<br>
6.获取客户端 ip 地址：${ pageContext.request.remoteHost }<br>
7.获取会话的 id 编号：${ pageContext.session.id }<br>
<hr>
<%--简写EL表达式的技巧--%>
<%
//首先将request域对象存储在pageContext中
pageContext.setAttribute("req", request); // 那么后续调用 ${pageContext.request} ==> ${req}
pageContext.setAttribute("session", session); // 那么后续调用 ${pageContext.session} ==> ${session}
%>
<h3>简写EL表达式</h3>
1.协议： ${ req.scheme }<br>
2.服务器 ip：${ req.serverName }<br>
3.服务器端口：${ req.serverPort }<br>
4.获取工程路径：${ req.contextPath }<br>
5.获取请求方法：${ req.method }<br>
6.获取客户端 ip 地址：${ req.remoteHost }<br>
7.获取会话的 id 编号：${ session.id }<br>
</body>
</html>
浏览器访问如下：http://127.0.0.1:8080/09_EL_JSTL/k.jsp
image-20201130230939522
3. EL 表达式其他隐含对象的使用
3.1 param 、paramValues 的使用
param Map<String,String> 它可以获取请求参数的值
paramValues Map<String,String[]> 它也可以获取请求参数的值，获取多个值的时候使用。
示例代码：
image-20201201074718047
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
输出请求参数 param 的值： ${ param } <br>
输出请求参数 username 的值：${ param.username } <br>
输出请求参数 password 的值：${ param.password } <br>
<hr>
输出请求参数 paramValues 的值: ${ paramValues } <br>
输出请求参数 username 的值：${ paramValues.username[0] } <br>
输出请求参数 hobby 的值：${ paramValues.hobby[0] } <br>
输出请求参数 hobby 的值：${ paramValues.hobby[1] } <br>
</body>
</html>
请求浏览器：
http://localhost:8080/09_EL_JSTL/param.jsp?username=libai&password=666666&hobby=java&hobby=cpp
image-20201201074758713
3.2 header 、 headerValues 的使用
header Map<String,String> 它可以获取请求头的信息
headerValues Map<String,String[]> 它可以获取请求头的信息，它可以获取多个值的情况
示例代码：
image-20201201075537464
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
输出请求头 header 的值： ${ header } <br>
输出请求头 User-Agent 的值：${ header['User-Agent'] } <br>
输出请求头 Connection 的值：${ header.Connection } <br>
<hr>
输出请求头 headerValues 的值： ${ headerValues } <br>
输出请求头 User-Agent 的值：${ headerValues['User-Agent'][0] } <br>
</body>
</html>
请求浏览器：
image-20201201075609725
3.3 cookie 的使用
cookie Map<String,Cookie> 它可以获取当前请求的 Cookie 信息
示例代码：
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
获取 Cookie 的值： ${ cookie }
<hr>
获取 Cookie.JSESSIONID: ${ cookie.JSESSIONID }
<hr>
获取 Cookie 的名称：${ cookie.JSESSIONID.name }
<hr>
获取 Cookie 的值：${ cookie.JSESSIONID.value }
<hr>
</body>
</html>
请求浏览器如下：
image-20201201080112127
3.4 initParam 的使用
initParam Map<String,String> 它可以获取在 web.xml 中配置的<context-param>上下文参数
首先需要 web.xml 中的配置：
image-20201201080451264
<context-param>
<param-name>username</param-name>
<param-value>root</param-value>
</context-param>
<context-param>
<param-name>url</param-name>
<param-value>jdbc:mysql:///test</param-value>
</context-param>
示例代码：
image-20201201080743588
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
输出 initParam 的值：${ initParam } <hr>
输出<Context-param>username 的值：${ initParam.username } <hr>
输出<Context-param>url 的值：${ initParam.url } <hr>
</body>
</html>
请求浏览器访问：
image-20201201080803712
2. JSTL 标签库
JSTL 标签库 全称是指 JSP Standard Tag Library JSP 标准标签库。是一个不断完善的开放源代码的 JSP 标签库。
EL 表达式主要是为了替换 jsp 中的表达式脚本，而标签库则是为了替换代码脚本。这样使得整个 jsp 页面变得更佳简洁。
JSTL 由五个不同功能的标签库组成。
功能范围 | URI | 前缀 |
|---|---|---|
核心标签库--重点 | http://java.sun.com/jsp/jstl/core | c |
格式化 | http://java.sun.com/jsp/jstl/fmt | fmt |
函数 | http://java.sun.com/jsp/jstl/functions | fn |
数据库(不使用) | http://java.sun.com/jsp/jstl/sql | sql |
XML(不使用) | http://java.sun.com/jsp/jstl/xml | x |
在 jsp 标签库中使用 taglib 指令引入标签库
- CORE 标签库
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
- XML 标签库
<%@ taglib prefix="x" uri="http://java.sun.com/jsp/jstl/xml" %>
- FMT 标签库
<%@ taglib prefix="fmt" uri="http://java.sun.com/jsp/jstl/fmt" %>
- SQL 标签库
<%@ taglib prefix="sql" uri="http://java.sun.com/jsp/jstl/sql" %>
- FUNCTIONS 标签库
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
f) JSTL 标签库的使用步骤
1、先导入 jstl 标签库的 jar 包。
taglibs-standard-impl-1.2.5.jar
taglibs-standard-spec-1.2.5.jar
设置Maven依赖如下：
<!-- https://mvnrepository.com/artifact/org.apache.taglibs/taglibs-standard-impl -->
<dependency>
<groupId>org.apache.taglibs</groupId>
<artifactId>taglibs-standard-impl</artifactId>
<version>1.2.5</version>
</dependency>
<!-- https://mvnrepository.com/artifact/org.apache.taglibs/taglibs-standard-spec -->
<dependency>
<groupId>org.apache.taglibs</groupId>
<artifactId>taglibs-standard-spec</artifactId>
<version>1.2.5</version>
</dependency>
2、第二步，使用 taglib 指令引入标签库。
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
image-20210228175941424
g) core 核心库使用
1. <c:set />（使用很少）
“作用：set 标签可以往域中保存数据 ”
示例代码：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--
<c:set />
作用：set 标签可以往域中保存数据域对象.setAttribute(key,value);
scope 属性设置保存到哪个域
page 表示 PageContext 域（默认值）
request 表示 Request 域
session 表示 Session 域
application 表示 ServletContext 域
var 属性设置 key 是多少
value 属性设置值
--%>
<h3>保存pageContext域对象：</h3>
保存之前：${ pageScope.abc } <br>
<c:set scope="page" var="abc" value="abcValue"/>
保存之后：${ pageScope.abc } <br>
<hr>
<h3>保存Request域对象：</h3>
保存之前：${ requestScope.abc } <br>
<c:set scope="request" var="abc" value="abcValue"/>
保存之后：${ requestScope.abc } <br>
<hr>
<h3>保存Session域对象：</h3>
保存之前：${ sessionScope.abc } <br>
<c:set scope="session" var="abc" value="abcValue"/>
保存之后：${ sessionScope.abc } <br>
<hr>
<h3>保存ServletContext域对象：</h3>
保存之前：${ applicationScope.abc } <br>
<c:set scope="application" var="abc" value="abcValue"/>
保存之后：${ applicationScope.abc } <br>
</body>
</html>
浏览器显示如下：
image-20201202124021795
2. <c:if />
“if 标签用来做 if 判断。注意：没有 else 分支。 ”
示例代码：
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/3/1
Time: 0:32
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--
<c:if />
if 标签用来做 if 判断。
test 属性表示判断的条件（使用 EL 表达式输出）
--%>
<c:if test="${ 100 == 100}">
<h3>100等于100</h3>
</c:if>
<c:if test="${ 200 == 100}">
<h3>200等于100</h3>
</c:if>
</body>
</html>
浏览器显示如下：
image-20201202124627517
3. <c:choose> <c:when> <c:otherwise>标签
“作用：多路判断。跟 switch ... case .... default 非常接近 ”
示例代码：
<%--
Created by IntelliJ IDEA.
User: Administrator
Date: 2021/3/1
Time: 0:33
To change this template use File | Settings | File Templates.
--%>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--
<c:choose> <c:when> <c:otherwise>标签
作用：多路判断。跟 switch ... case .... default 非常接近
choose 标签开始选择判断
when 标签表示每一种判断情况
test 属性表示当前这种判断情况的值
otherwise 标签表示剩下的情况
<c:choose> <c:when> <c:otherwise>标签使用时需要注意的点：
1、标签里不能使用 html 注释，要使用 jsp 注释
2、when 标签的父标签一定要是 choose 标签
--%>
<c:choose>
<%-- 不能使用 html 注释，要使用 jsp 注释 --%>
<c:when test="${ requestScope.height > 190 }">
<h2>小巨人</h2>
</c:when>
<c:when test="${ requestScope.height > 180 }">
<h2>很高</h2>
</c:when>
<c:when test="${ requestScope.height > 170 }">
<h2>还可以</h2>
</c:when>
<c:otherwise>
<%-- when 标签的父标签一定要是 choose 标签 --%>
<c:choose>
<c:when test="${requestScope.height > 160}">
<h3>大于 160</h3>
</c:when>
<c:when test="${requestScope.height > 150}">
<h3>大于 150</h3>
</c:when>
<c:when test="${requestScope.height > 140}">
<h3>大于 140</h3>
</c:when>
<c:otherwise>
其他小于 140
</c:otherwise>
</c:choose>
</c:otherwise>
</c:choose>
</body>
</html>
浏览器请求如下：
image-20201202124942107
4. <c:forEach />
“作用：遍历输出使用。 ”
1. 遍历 1 到 10，输出
示例代码:
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--
遍历 1 到 10，输出
begin 属性设置开始的索引
end 属性设置结束的索引
var 属性表示循环的变量(也是当前正在遍历到的数据)
java的基本for写法：
for (int i = 1; i <= 10; i++)
--%>
<h3>foreach遍历 1 到 10</h3>
<%--foreach遍历 1 到 10--%>
<c:forEach begin="1" end="10" var="i">
${i}
</c:forEach>
<hr>
<h3>在table表格中使用遍历 1 到 10</h3>
<table border>
<c:forEach begin="1" end="10" var="i">
<tr>
<td>第${i}行</td>
</tr>
</c:forEach>
</table>
</body>
</html>
浏览器显示如下：
image-20201202125656561
2. 遍历 Object 数组
示例代码：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%--
遍历 Object 数组
for (Object item: arr)
items 表示遍历的数据源（遍历的集合）
var 表示当前遍历到的数据
--%>
<%
//存储一个数组
request.setAttribute("arr", new String[]{"18610541354","18688886666","18699998888"});
%>
<%--遍历数组--%>
<c:forEach items="${ requestScope.arr }" var="item">
${ item } <br>
</c:forEach>
</body>
</html>
浏览器显示如下：
image-20201202223728567
3. 遍历 Map 集合
示例代码：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="java.util.Map" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%
//存储一个Map
Map<String,Object> map = new HashMap<String, Object>();
map.put("key1", "value1");
map.put("key2", "value2");
map.put("key3", "value3");
//for ( Map.Entry<String,Object> entry : map.entrySet()) {
//}
//将map保存在request域对象
request.setAttribute("map", map);
%>
<%--遍历map--%>
<c:forEach items="${ requestScope.map }" var="entry">
<h1>${entry.key} = ${entry.value}</h1>
</c:forEach>
</body>
</html>
浏览器显示如下：
image-20201202223939426
4. 遍历 List 集合---list 中存放 Student 类，有属性：编号，用户名，密码，年龄， 电话信息
4.1 创建Student类：
image-20201202224151090
package pojo;
/**
* @author Aron.li
* @date 2020/12/2 22:40
*/
public class Student {
//编号，用户名，密码，年龄，电话信息
private Integer id;
private String username;
private String password;
private Integer age;
private String phone;
//构造器
public Student(Integer id, String username, String password, Integer age, String phone) {
this.id = id;
this.username = username;
this.password = password;
this.age = age;
this.phone = phone;
}
public Student() {
}
//getter setter
public Integer getId() {
return id;
}
public void setId(Integer id) {
this.id = id;
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String getPassword() {
return password;
}
public void setPassword(String password) {
this.password = password;
}
public Integer getAge() {
return age;
}
public void setAge(Integer age) {
this.age = age;
}
public String getPhone() {
return phone;
}
public void setPhone(String phone) {
this.phone = phone;
}
// toString
@Override
public String toString() {
return "Student{" +
"id=" + id +
", username='" + username + '\'' +
", password='" + password + '\'' +
", age=" + age +
", phone='" + phone + '\'' +
'}';
}
}
4.2 创建jsp 示例：
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<%@ page import="pojo.Student" %>
<%@ page import="java.util.List" %>
<%@ page import="java.util.ArrayList" %>
<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
<title>Title</title>
</head>
<body>
<%-- 4.遍历 List 集合---list 中存放 Student 类，有属性：编号，用户名，密码，年龄，电话信息--%>
<%
//创建一个list
List<Student> studentList = new ArrayList<Student>();
for (int i = 1; i <= 10; i++) {
studentList.add(new Student(i,"username"+i ,"pass"+i,18+i,"phone"+i));
}
//将list存储在request域对象
request.setAttribute("stus", studentList);
%>
<%--
items 表示遍历的集合
var 表示遍历到的数据
begin 表示遍历的开始索引值
end 表示结束的索引值
step 属性表示遍历的步长值
varStatus 属性表示当前遍历到的数据的状态
for（int i = 1; i < 10; i+=2）
--%>
<c:forEach begin="2" end="7" step="2" varStatus="status" items="${requestScope.stus}" var="stu">
stu.id: ${stu.id} <br>
stu.username: ${stu.username} <br>
stu.password: ${stu.password} <br>
stu.age: ${stu.age} <br>
stu.phone: ${stu.phone} <br>
status.begin: ${status.begin} <br>
status.end: ${status.end} <br>
status.step: ${status.step} <br>
<hr>
</c:forEach>
</body>
</html>
浏览器显示如下：
本文参与 腾讯云自媒体分享计划，分享自微信公众号。
原始发表：2021-11-16，如有侵权请联系 cloudcommunity@tencent.com 删除
评论
登录后参与评论
推荐阅读
目录
相关产品与服务
对象存储
对象存储（Cloud Object Storage，COS）是由腾讯云推出的无目录层次结构、无数据格式限制，可容纳海量数据且支持 HTTP/HTTPS 协议访问的分布式存储服务。腾讯云 COS 的存储桶空间无容量上限，无需分区管理，适用于 CDN 数据分发、数据万象处理或大数据计算与分析的数据湖等多种场景。