java学习笔记——javaweb之BeanUtils、EL、JSTL
base标签的使用
Request对象的API
request.getScheme() 获取协议名
request.getServerName() 获取服务器ip
request.getServerPort() 获取服务器访问号
request.getContextPath() 获取服务器访问的工程路径
<base href="<%=request.getScheme() + "://" + request.getServerName()+ ":" + request.getServerPort() + request.getContextPath() %>/">
得到的路径是：http://127.0.0.1:80/book /
get请求获取请求行，Post请求获取请求体，他们获取参数的区别。
get请求的时候form标签中action属性?问号后面的参数会被表单中的参数覆盖。
但是post不会！！！
通常当我们在请求中，需要传递一些表单之外的参数的时候，
可以使用<input type=”hidden” /> 这个表单项进行传递
把页面动态化。（转成jsp页面）
a) 把<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>添加到所有的html页面的首行。
b) 把所有html文件的后缀都修改为.jsp
c）把页面中的 .htm l修改为 .jsp
BeanUtils第三方工具包的使用
添加.jar文件commons-beanutils-1.8.0.jar 与 commons-logging-1.1.1.jar
下载地址：https://download.****.net/download/qq_25106373/10559501
使用方法如下：
protected void login(HttpServletRequest request, HttpServletResponse response) throws ServletException, IOException {
// String username = request.getParameter("username");
// String password = request.getParameter("password");
//
// User user = new User(0, username, password, "");
//可以替代上边的几句
User user = UseBeanUtils.copyMap2Bean(request.getParameterMap(), new User());
}
public static <T> T copyMap2Bean(Map<String, Object> map, T bean) {
try {
// 把map中每个key的值，通过找到对应的set方法。实现注入
org.apache.commons.beanutils.BeanUtils.populate(bean, map);
} catch (Exception e) {
e.printStackTrace();
}
return bean;
}
BeanUtils.populate(javaBean对象, map属性值);
第一个参数是被赋值的javaBean对象。接收标准的javaBean对象，也就是有get/set方法的java对象。
第二个参数是由key和value组成的一个map。
1、EL表达式（重点*****）
1.1、什么是EL表达式
E L的全称：Expression Language，就是表达式语言。可以输出表达式的值。跟jsp的表达式脚本一样。计算表达式的值后输出。
EL表达式出现的目的是为了使JSP写起来更加简单，让jsp的代码更佳简化。
我们先来看一下EL表达式的一个Hello world 程序，看看它是如何简化jsp代码。
EL 表达式的Hello world 程序！！！
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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>Insert title here</title>
</head>
<body>
<%
//首先我们需要在request域对象中设置一个属性
request.setAttribute("hello", "这是内容");
%>
<%-- 获取请求域中的属性hello输出 --%>
jsp的输出：<%=request.getAttribute("hello") == null ? "" : request.getAttribute("hello")%><br/><br/>
<%-- 输出在域中查找输出hello的值 --%>
EL表达式的输出：${hello}<br/><br/>
</body>
</html>
页面访问后的输出内容：
从上面的程序，我们不难看出。我们要输出域中的属性，方便多了。
所以el表达式使得jsp页面的代码变得更加简洁。主要用于替换 jsp 中表达式脚本。
EL表达式的最主要功能就是从域对象中获取数据，并且输出
1.2、EL表达式，获取域对象数据（*****重点）
使用EL表达式获取数据的语法： “${标识符}”
第一点：当EL表达式输出的key不存在的时候，输出的是空串””
第二点：EL表达式在域对象中搜索属性的顺序是pageContext，request，session。Application
EL表达式可以从域对象中获取数据
1、EL表达式获取域数据的顺序
EL 表达式语句在执行时，会用标识符为关键字分别从page、request、session、application四个域中查找对应key的对象。
找到则返回相应数据。找不到则返回空串。（注意，不是null，而是空字符串）
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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>Insert title here</title>
</head>
<body>
<%
//我们在四个域对象中设置同一个属性
pageContext.setAttribute("hello", "page这是内容");
request.setAttribute("hello", "request这是内容");
session.setAttribute("hello", "session这是内容");
application.setAttribute("hello", "application这是内容");
%>
<%-- 从page，request，session，application四个作用域中顺序查找对应的key的值输出，如果没有找到就输出空串 --%>
${hello}<br/>
</body>
</html>
测试步骤：
- 写好页面代码，直接访问页面，输出pageContext中的内容。
- 注掉pageContext.setAttribute 代码。刷新页面，输出request域范围的hello属性值。
- 注掉 request.setAttribute 代码。刷新页面，输出Session域范围的hello属性值。
- 注掉 session.setAttribute 代码，并且关闭浏览器后重新打开浏览器访问页面。输出 application（ServletContext）域范围的属性值
- 注掉application.setAttribute代码，关闭服务器。然后再启动服务器。再打开浏览器，再访问页面。application中也没有数据了
2、获取javaBean普通属性、数组属性、List集合属性，以map属性中的数据。
例如：
${ user.username } // 获取user对象中。username属性值
${ list[下标] } // 访问有序集合（或数组）中给定索引的元素
${ map.key } // 访问map集合中指定key的属性值
${ map[“key”] } // 访问特殊字符串的key的属性值
注意：[] 中括号 除了可以访问带有顺序的集合和数组的元素之外。
还可以访问特殊的key值
需求：创建一个User类对象，添加字符串属性，数组属性，List集合属性。map属性。
然后创建一个对象实例添加到request域对象中测试获取
一定要记住一点，EL表达式获取数据的时候，是通过对应的get方法获取的
a) 先定义一个JavaBean对象------User类
package com.atguigu.servlet;
import java.util.Arrays;
import java.util.List;
import java.util.Map;
public class User {
private String username;
private String[] phones;
private Map<String, Object> map;
private List<String> strList;
public User(String username, String[] phones, Map<String, Object> map, List<String> strList) {
super();
this.username = username;
this.phones = phones;
this.map = map;
this.strList = strList;
}
public User() {
super();
}
public String getUsername() {
return username;
}
public void setUsername(String username) {
this.username = username;
}
public String[] getPhones() {
return phones;
}
public void setPhones(String[] phones) {
this.phones = phones;
}
public Map<String, Object> getMap() {
return map;
}
public void setMap(Map<String, Object> map) {
this.map = map;
}
public List<String> getStrList() {
return strList;
}
public void setStrList(List<String> strList) {
this.strList = strList;
}
@Override
public String toString() {
return "User [username=" + username + ", phones=" + Arrays.toString(phones) + ", map="
+ map + ", strList=" + strList + "]";
}
}
b) 在jsp页面中添加一些对象到四个域对象中，使用el表达式访问测试。
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@page import="java.util.HashMap"%>
<%@page import="com.atguigu.servlet.User"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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>Insert title here</title>
</head>
<body>
<%
// 创建一个map对象，并添加数据
HashMap<String,Object> map = new HashMap<String,Object>();
map.put("aaa", "AAAValue");
map.put("bbb", "bbbValue");
map.put("ccc", "cccValue");
map.put("ddd", "dddValue");
// 创建一个list集合对象
List<String> strList = new ArrayList<String>();
strList.add("aaa");
strList.add("bbb");
strList.add("ccc");
// 创建一个User对象
User user = new User("用户名",new String[]{"第一个电话","第二个电话","第三个电话"},map,strList);
// 把用户对象添加到请求request的属性中
request.setAttribute("user", user);
%>
<%--访问 对象的username 属性--%>
user对象的username属性值---->>>>${ user.username }<br/><br/>
<%--访问user对象中数组的第二个元素--%>
user对象中phones数组的第二个元素-------->>>>${ user.phones[1] }<br/><br/>
<%--访问 list集合 中第一个元素--%>
list集合中第一个元素-------->>>>>${ user.strList[0] }<br/> <br/>
<%--访问 user对象中map集合的aaa的属性值 --%>
user对象中map集合中aaa属性的值----->>>>>${ user.map.aaa }<br/><br/>
</body>
</html>
页面输出如下：
1.3、EL 表达式--运算。
语法：${ 运算表达式 } ， EL 表达式支持如下运算符：
- 关系运算
|
关系运算符 |
说 明 |
范 例 |
结果 |
|
== 或 eq |
等于 |
${ 5 == 5 } 或 ${ 5 eq 5 } |
true |
|
!= 或 ne |
不等于 |
${ 5 !=5 } 或 ${ 5 ne 5 } |
false |
|
< 或 lt |
小于 |
${ 3 < 5 } 或 ${ 3 lt 5 } |
true |
|
> 或 gt |
大于 |
${ 2 > 10 } 或 ${ 2 gt 10 } |
false |
|
<= 或 le |
小于等于 |
${ 5 <= 12 } 或 ${ 5 le 12 } |
true |
|
>= 或 ge |
大于等于 |
${ 3 >= 5 } 或 ${ 3 ge 5 } |
false |
2）逻辑运算
|
逻辑运算符 |
说 明 |
范 例 |
结果 |
|
&& 或 and |
与运算 |
${ 12 == 12 && 12 < 11 } 或 ${ 12 == 12 and 12 < 11 } |
false |
|
|| 或 or |
或运算 |
${ 12 == 12 || 12 < 11 } 或 ${ 12 == 12 or 12 < 11 } |
true |
|
! 或 not |
取反运算 |
${ !true } 或 ${not true } |
false |
3）算数运算
|
算数运算符 |
说 明 |
范 例 |
结果 |
|
+ |
加法 |
${ 12 + 18 } |
30 |
|
- |
减法 |
${ 18 - 8 } |
10 |
|
* |
乘法 |
${ 12 * 12 } |
144 |
|
/ 或div |
除法 |
${ 144 / 12 } 或 ${ 144 div 12 } |
12 |
|
% 或mod |
取模 |
${ 144 % 10 } 或 ${ 144 mod 10 } |
4 |
4）empty运算符（***常用）
empty运算是判断一个对象或者集合是否为空。返回boolean值。
对象为null时，返回true
如果是空的字符串，返回true
如果是空的Object数组(Object数组.length == 0)，返回true
空的集合，返回true
空的map，返回true
empty运算测试代码：
<%@page import="java.util.Map"%>
<%@page import="java.util.List"%>
<%@page import="java.util.HashMap"%>
<%@page import="java.util.ArrayList"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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>Insert title here</title>
</head>
<body>
<%
// 对象为null时，返回true
request.setAttribute("nullObject", null);
//如果是空的字符串，返回true
request.setAttribute("emptyStr", "");
//如果是空的数组，返回true
request.setAttribute("emptyArr", new Object[]{});
//空的集合，返回true
List list = new ArrayList();
request.setAttribute("emptyList", list);
//空的map，返回true
Map map = new HashMap();
request.setAttribute("emptyMap", map);
%>
<h1>EL empty 运算</h1>
对象为null，empty为真 ---->>>>${ empty nullObject }<br/>
空的字符串，empty为真------>>>>${ empty emptyStr }<br/>
空的数组，empty为真------>>>>${ empty emptyArr }<br/>
空的list集合，empty为真---->>>>${ empty emptyList }<br/>
空的map集合，empty为真----->>>>${ empty emptyMap }<br/>
</body>
</html>
浏览器运行结果：
5）三元运算
我们可以在EL 表达式中方便的使用三元运算输出。
语法：${ 表达式1 ? 表达式2 : 表达式3 }
示例：${ 12 == 12 ? "12 等于 12" : "12 ！= 12" }
我们可以很方便的在EL 表达式中使用三元运算符进行运算。
6）“.” 点 和 [] 中括号 运算符
“.” 运算符，可以取JavaBean对象的属性值，也可以取map中某个key的值。
[] 中括号，可以获取顺序集合中指定索引的元素，也可以获取特殊key的值。
当我们在map对象中存放一些特殊的key的时候。
比如说。key字符串中含有 “.” 、“+” 、“-” 、“*” 、“/” 、 “%” 等 这些运算符的时候。
会让el解析器产生歧义的时候。我们可以使用[‘key’]中括号加引号包含key的形式取值。
[] 中括号，不仅可以获取有序集合（数组和List集合）中的给定索引的元素，
还可以获取key中含有特殊意义字符的key对应的值。
比如key中含有 “.” , “+” , “_” , “*” , “/” 等的运算字符
示例：
<body>
<%
//设置
Map map = new HashMap();
map.put("a-b-c","a-b-c-Value");
map.put("a.b.c", "a.b.c.Value");
map.put("aaa","aaa-Value");
request.setAttribute("map", map);
%>
<%-- 下面我们可以通过中括号方式获取对应key的值 --%>
${ map['a.b.c'] }<br/>
${ map['a-b-c'] }<br/>
${ map.aaa }<br/>
</body>
输出为：
- b.c.Value
a-b-c-Value
aaa-Value
1.4、EL表达式中11个隐含对象。
EL表达式 中隐含11个对象，这11个对象我们都可以直接使用！！！
|
隐含对象 |
类型 |
说明 |
|
pageContext |
javax.servlet.jsp.PageContext |
就是JSP页面中的pageContext对象 |
|
pageScope |
java.util.Map<String,Object> |
Page范围属性名和属性值 |
|
requestScope |
java.util.Map<String,Object> |
Request范围属性名和属性值 |
|
sessionScope |
java.util.Map<String,Object> |
Session范围属性名和属性值 |
|
applicationScope |
java.util.Map<String,Object> |
Web应用范围属性名和属性值 |
|
param |
java.util.Map<String,String> |
对应一个请求参数 |
|
paramValues |
java.util.Map<String,String[]> |
对应一组请求参数 |
|
header |
java.util.Map<String,String> |
请求头 |
|
headerValues |
java.util.Map<String,String[]> |
请求头返回字符数组 |
|
cookie |
java.util.Map<String, Cookie> |
获取某个cookie对象 |
|
initParam |
java.util.Map<String, String> |
获取web.xml中<context-param>初始化参数 |
1.5、EL表达式获取域对象中的数据（****重点）
pageScope <=== 对应 ===> pageContext 域中的属性
requestScope <=== 对应 ===> request 域中的属性
sessionScope <=== 对应 ===> session 域中的属性
applicationScope <=== 对应 ===> ServletContext 域中的属性
我们先来看一下。如何从四个域对象中。获取各自的属性
需求：分别往四个域对象中存储数据，然后使用pageScope，requestScope，sessionScope，applicationScope中取出数据
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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>Insert title here</title>
</head>
<body>
<%
// 在四个域中存放数据，进行获取
pageContext.setAttribute("key", "pageContext-value");
request.setAttribute("key", "request-Value");
session.setAttribute("key", "session-value");
application.setAttribute("key", "application-value");
%>
<%-- 从不同的域中获取数据 --%>
page域中key的值：${ pageScope.key }<br/>
request域中key的值：${ requestScope.key }<br/>
session域中key的值：${ sessionScope.key }<br/>
application域中key的值：${ applicationScope.key }<br/>
</body>
</html>
运行的结果：
1.6、pageContext访问Jsp中内置对象（用的不多）。
通过pageContext对象。我们可以直接获取jsp中的一些内置对象，
比如：
request对象，
session对象，
Servletconfig对象，
ServletContext对象，
然后获取一些我们需要的信息。
常用的功能获取
协议：
服务器ip：
服务器端口：
获取工程路径：
获取请求方法：
获取客户端ip地址：
获取会话的id编号：
pageContext使用示例代码
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
<html>
<head>
<meta http-equiv="pragma" content="no-cache" />
<meta http-equiv="cache-control" content="no-cache" />
<meta http-equiv="Expires" content="0" />
<meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
<title>Insert title here</title>
</head>
<body>
协议：${ pageContext.request.scheme }<br/>
服务器ip：${ pageContext.request.serverName }<br/>
服务器端口：${ pageContext.request.serverPort }<br/>
获取工程路径：${ pageContext.request.contextPath }<br/>
获取请求方法：${ pageContext.request.method }<br/>
获取客户端ip地址：${ pageContext.request.remoteHost }<br/>
获取会话的id编号：${ pageContext.session.id }<br/>
</body>
</html>
pageContext对象最常用的功能就是获取上下文路径（也就是工程路径名）
工程名(上下文路径):${ pageContext.request.contextPath }
但是在实际项目中。为了缩短代码量，会把request对象放在pageContext域对象中。然后再使用，比如说
<%
// 先把request对象放到pageContext域对象中
pageContext.setAttribute(“req”,request);
%>
然后EL表达式代码改为
工程名(上下文路径):${ req.contextPath }
1.7、EL表达式其他隐含对象的使用。
|
param |
java.util.Map<String,String> |
对应一个请求参数 |
|
paramValues |
java.util.Map<String,String[]> |
对应一组请求参数 |
|
header |
java.util.Map<String,String> |
请求头 |
|
headerValues |
java.util.Map<String,String[]> |
请求头返回字符数组 |
|
cookie |
java.util.Map<String, Cookie> |
获取某个cookie对象 |
|
initParam |
java.util.Map<String, String> |
获取应用<context-param>初始化参数 |
web.xml文件中的配置内容：
<context-param>
<param-name>username</param-name>
<param-value>root</param-value>
</context-param>
使用的示例代码：
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<!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>Insert title here</title>
</head>
<body>
参数username的值：${ param.username }<br/>
参数hobby的值：${ paramValues.hobby[0] }<br/>
请求头Accept-Language的值：${ header["Accept-Language"] }<br/>
请求头Accept的值：${ headerValues["Accept"][0] }<br/>
cookie的key = ${ cookie.JSESSIONID.name } : value = ${ cookie.JSESSIONID.value } <br/>
上下文参数：${ initParam.username }<br/>
</body>
</html>
访问的显示结果：
EL表达式重点回顾：
问题1：EL表达式搜索四个域对象的顺序？
问题2：如何获取一个对象中的数组元素？
问题3：如何获取一个对象中的map中的元素？
问题4：.运算和【】运算有哪些相同和不同？
问题5：pageScope，requestScope sessionScope applicationScope param分别表示什么？
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" %>
2.1使用JSTL标签库步骤
第一步：先引入JSTL标签库的jar包类库到WEB-INF/lib目录下
下载地址：https://download.****.net/download/qq_25106373/10559496
这两个jar包，和笔记在同一个目录下。
第二步：在使用的jsp页面中使用taglib指令导入需要的标签库
以core核心标签库为例，需要在jsp页面中导入标签库的引用。
prefix属性为标签库的前缀。 c
uri属性为标签库的唯一uri地址。http://java.sun.com/jsp/jstl/core
然后我们就可以在jsp页面中愉快的使用标签库了。
2.2、core 核心库（重*****点）
使用的时候需要在jsp页面中加入
CORE 标签库
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
2.2.1、<c:set>标签
作用：
<c:set>标签 用于 添加 或 修改 域中的属性。
属性：
|
属性 |
描述 |
是否必要 |
默认值 |
|
value |
要存储或修改的值 |
否 |
主体的内容 |
|
target |
要修改的属性所属的对象 |
否 |
无 |
|
property |
要修改的属性 |
否 |
无 |
|
var |
存储信息的变量 |
否 |
无 |
|
scope |
var属性的作用域 (page , request , session , application) |
否 |
page |
如果指定了target属性，那么property属性也需要被指定。
1）在作用域中添加新属性
<c:set scope="" var="" value=""></c:set>
scope是哪个作用域
var 是属性名
value 是属性值
2）修改已存中的作用域的属性
<c:set target="" property="" value=""></c:set>
target 是要修改的目标对象
property 是要修改或者添加的属性名
value 是要修改的属性值
示例：
<body>
<%
User user = new User("username姓名",null,null,null);
session.setAttribute("user", user);
Map<String,String> map = new HashMap<String,String>();
map.put("abc", "abcValue");
pageContext.setAttribute("map", map);
%>
<%-- 在作用域里添加新的属性 --%>
<c:set scope="page" var="two" value="twovalue"></c:set>
<%-- 修改在作用域里的对象 --%>
<c:set target="${ sessionScope.user }" property="username" value="twovalue"></c:set>
<%-- 给原作用域中的map添加一个key --%>
<c:set target="${ pageScope.map }" property="bbb" value="twovalue"></c:set>
${ pageScope.two }<br/> <hr/>
${ pageScope.map }<br/> <hr/>
${ sessionScope.user }<br/> <hr/>
</body>
运行结果：
2.2.2、<c:if>标签
作用：
<c:if>标签 判断表达式的值，如果表达式的值为 true 则执行其主体内容。
属性：
|
属性 |
描述 |
是否必要 |
默认值 |
|
test |
条件 |
是 |
无 |
|
var |
用于存储条件结果的变量 |
否 |
无 |
|
scope |
var属性的作用域 |
否 |
page |
示例：
<body>
<!-- 判断 12 == 12 -->
<c:if test="${ 12 == 12 }">
<h1>12 == 12 为真</h1>
</c:if>
<!-- 把判断的结果保存到作用域中 -->
<c:if test="${ 12 == 13 }" scope="page" var="a"></c:if>
<%-- 输出page作用域中的a对象 --%>
<c:out value="${ pageScope.a }"></c:out>
</body>
运行结果：
2.2.3、<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:when>标签的属性如下：
|
属性 |
描述 |
是否必要 |
默认值 |
|
test |
条件 |
是 |
无 |
示例：
<body>
<%
// 保存一个分数
pageContext.setAttribute("score", 90);
%>
<%-- 开始判断 --%>
<c:choose>
<%-- 如果成绩大于等于 90分 --%>
<c:when test="${ pageScope.score >= 90 }">
成绩为A
</c:when>
<%-- 如果成绩大于等于 80分 --%>
<c:when test="${ pageScope.score >= 80 }">
成绩为B
</c:when>
<%-- 如果成绩大于等于 70分 --%>
<c:when test="${ pageScope.score >= 70 }">
成绩为C
</c:when>
<%-- 如果成绩大于等于 60分 --%>
<c:when test="${ pageScope.score >= 60 }">
成绩为D
</c:when>
<%-- 其他情况 --%>
<c:otherwise>
成绩为E，不及格
</c:otherwise>
</c:choose>
</body>
运行结果：
2.2.4、<c:forEach>标签（****重点）
作用：
<c:forEach>标签是迭代一个集合中的对象-可以是数组，也可以是list，也可以是map对象。
属性：
|
属性 |
描述 |
是否必要 |
默认值 |
|
items |
要被循环的数据集合-可以使用el表达式 |
否 |
无 |
|
begin |
开始的索引（0=第一个元素，1=第二个元素） |
否 |
0 |
|
end |
最后一个索引（0=第一个元素，1=第二个元素） |
否 |
Last element |
|
step |
每一次迭代的步长 |
否 |
1 |
|
var |
代表当前条目的变量名称 |
否 |
无 |
|
varStatus |
代表循环状态的变量名称 |
否 |
无 |
varStatus状态：
作用：指定保存迭代状态的对象的名字，该变量引用的是一个LoopTagStatus类型的对象
通过该对象可以获得一些遍历的状态，如下：
begin 获取begin属性里的值
end 获取end属性里的值
count 获取当前遍历的个数
index 获取当前索引值
first 获取是否是第一个元素
last 获取是否是最后一个元素
current 获取当前遍历的元素对象
练习：使用 map 模拟用户信息。 包含 编号，用户名，密码，年龄，电话信息。创建5个放到list集合中，再把list集合存放到pageContext域中，然后遍历输出
表格的格式
<style type="text/css">
table{
width: 700px;
border: 1px solid red;
border-collapse: collapse;
}
th , td{
border: 1px solid red;
}
</style>
示例：
<%@page import="java.util.ArrayList"%>
<%@page import="java.util.List"%>
<%@page import="java.util.HashMap"%>
<%@page import="java.util.Map"%>
<%@ page language="java" contentType="text/html; charset=UTF-8"
pageEncoding="UTF-8"%>
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core" %>
<!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>Insert title here</title>
<style type="text/css">
table{
width: 700px;
border: 1px solid red;
border-collapse: collapse;
}
th , td{
border: 1px solid red;
}
</style>
</head>
<body>
<%
// 模拟创建5个学生的信息
List<Map<String,Object>> list = new ArrayList<Map<String,Object>>();
for (int i = 0; i < 5; i++) {
Map<String,Object> item = new HashMap<String,Object>();
item.put("id", (i + 1));
item.put("username", "用户名" + i);
item.put("password", "密码" + i);
item.put("age", (12 + i) );
item.put("phone", "18615041888");
list.add(item);
}
// 保存学生的信息到pageContext作用域中
pageContext.setAttribute("stus", list);
%>
<table>
<tr>
<th>编号</th>
<th>姓名</th>
<th>密码</th>
<th>年龄</th>
<th>电话</th>
<th>遍历的个数</th>
<th>当前索引</th>
<th>是否第一个</th>
<th>是否最后一个</th>
</tr>
<%--
begin表示从索引0开始，
end表示到索引10结束，
step表示迭代的步长
items是遍历的集合
var是当前遍历到的对象名
varStatus是当前遍历的状态对象，是LoopTagStatus对象实例
--%>
<c:forEach begin="0" end="10" step="1" items="${ pageScope.stus }" var="item" varStatus="status">
<tr>
<td>${ item.id }</td>
<td>${ item.username }</td>
<td>${ item.password }</td>
<td>${ item.age }</td>
<td>${ item.phone }</td>
<td>${ status.count }</td>
<td>${ status.index }</td>
<td>${ status.first }</td>
<td>${ status.last }</td>
</tr>
</c:forEach>
</table>
</body>
</html>
运行结果：
2.2.5、<c:url>标签
作用：
主要是用来生成一个url地址，添加到一个域属性中。还可以在生成地址的同时添加请求参数。
如果请求的参数中带有中文，还会自动的做编码的操作
属性：
|
属性 |
描述 |
是否必要 |
默认值 |
|
value |
资源路径 |
是 |
无 |
|
context |
上下文路径（工程路径） |
否 |
当前应用程序 |
|
var |
代表URL的变量名 |
否 |
Print to page |
|
scope |
var属性的作用域page,request,session,application |
否 |
page |
特别注意：相对路径不能修改上下文
1) 生成url 直接输出 (只能有value属性和context属性)
<c:url value="" context=""/>
2) 使用绝对路径生成url保存到域对象中 (一定要以斜杠打头，可以修改上下文路径)
<c:url var="" value="/" scope="" context="" />
以上情况，都可以添加参数 <c:param name="" value="" />
示例：
<body>
<!-- 1) 使用相对路径生成url保存到 （只能在当前工程下） -->
<c:url var="url1" value="/a.jsp" scope="page" >
<c:param name="username" value="wzg168"></c:param>
<c:param name="data" value="中文"></c:param>
</c:url>
${ pageScope.url1 }<hr/>
<!-- 2) 使用绝对路径生成url保存到 (一定要以斜杠打头，可以修改上下文路径) -->
<c:url var="url2" value="/b.jsp" scope="page" context="/day08" />
${ pageScope.url2 }<hr/>
<!-- 3) 生成url 直接输出 (只能有value属性和context属性) -->
<c:url value="/c.jsp" context="/day20">
<c:param name="asd" value="asd"></c:param>
</c:url>
</body>
输出结果：
2.3、fn 函数库
fn的函数库，基本都是对字符串的操作。
要使用函数库，需要引入下面的语句在jsp页面中
FUNCTIONS 标签库
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions" %>
2.3.1、fn:contains函数 和 fn:containsIgnoreCase函数
作用：用于判断字符串中是否包含指定字符串，containsIgnoreCase忽略大小写。
语法： fn:contains(string,subString) à boolean
参数和返回值：
|
参数 |
类型 |
作用 |
|
string |
String |
源字符串 |
|
subString |
String |
要查找的字符串 |
|
返回值 |
boolean |
若string中包含subString则返回true，否则返回false |
示例：
${ fn:contains("abcde","ii") }<br/> 输出 false
${ fn:contains("abcde","ab") }<br/> 输出 true
${ fn:containsIgnoreCase("ABCDE","ab") }<br/> 输出 true
2.3.2、fn:startsWith函数 和 fn:endsWith函数
作用：判断一个字符串是否以指定字符串开头（startsWith）或结尾（endsWith）
语法： fn:startsWith(string , prefix) à boolean
fn:endsWith(string,suffix) à boolean
参数和返回值：
|
参数 |
类型 |
作用 |
|
string |
String |
源字符串 |
|
prefix 或 suffix |
String |
要查找的前缀或后缀字符串 |
|
返回值 |
boolean |
符合要求返回true，否则返回false |
示例：
${ fn:startsWith("abcde","abc") }<br/> 输出true
${ fn:startsWith("abcde","ddd") }<br/> 输出false
${ fn:endsWith("abcde","abc") }<br/> 输出false
${ fn:endsWith("abcde","de") }<br/> 输出true
2.3.3、fn:indexOf函数
作用：在一个字符串中查找指定字符串，并返回第一个符合的字符串的第一个字符的索引。
语法： fn:indexOf(string,subString) à int
参数和返回值：
|
参数 |
类型 |
作用 |
|
string |
String |
源字符串 |
|
subString |
String |
要查找的字符串 |
|
返回值 |
int |
若在string中找到subString则返回第一个符合的索引，若没有符合的则返回-1 |
示例：
${ fn:indexOf("abcdefg","cd") }<br/> 输出2，索引从0开始
${ fn:indexOf("abcdefg","id") }<br/> 输出-1，因为没有找到
2.3.4、fn:replace函数
作用：将一个字符串替换为另外一个字符串，并返回替换结果
语法： fn:replace(str , beforeSubString , afterSubString) à String
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String |
源字符串 |
|
beforeSubString |
String |
被替换的字符串 |
|
afterSubString |
String |
要替换的新字符串 |
|
返回值 |
String |
替换后的字符串 |
示例：
${ fn:replace("abcdefg" , "de" , "[]") }<br/> 输出 abc[]fg
2.3.5、fn:substring函数
作用：截取字符串
语法： fn: substring (str , beginIndex , endIndex) à String
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String |
源字符串 |
|
beginIndex |
int |
开始位置索引(包含该位置) |
|
endIndex |
int |
结束位置索引(不包含自身) |
|
返回值 |
String |
返回截取的字符串 |
示例：
${ fn:substring("abcdefg",0 , 4) }<br/> abcd 索引为0,1,2,3 都输出，不包含索引4的
2.3.6、fn:substringBefore函数 和 fn:substringAfter函数
作用：返回一个字符串指定子串之前（substringBefore）之后（substringAfter）的字符串
语法： fn: substringBefore(string,subString) à String
fn: substringAfter (string,subString) à String
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String |
源字符串 |
|
subString |
int |
指定str中的一个子串，该串之前或之后的字符串将被返回。 |
|
返回值 |
String |
返回截取的字符串 |
示例：
${ fn:substringBefore("abcdefg","cd") }<br/> 输出 ab
${ fn:substringAfter("abcdefg","cd") }<br/> 输出 efg
2.3.7、fn:split函数
作用： 将一个字符串拆分成字符串数组。
语法： fn:split(string,delimiters) à String[]
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String |
要被拆分的字符串 |
|
delimiters |
String |
指定根据什么内容拆分字符串 |
|
返回值 |
String[] |
返回拆分后的字符串数组 |
示例：
${ fn:split("a-b-c-d-e-f-g","-")[0] }<br/> 输出 a
<c:forEach items='${ fn:split("a-b-c-d-e-f-g","-")}' var="str">
<c:out value="${ str }"></c:out>
</c:forEach>
使用<c:forEach>遍历拆分后的数组，输出 a b c d e f g
2.3.8、fn:join函数
作用： 将数组中所有元素连接成一个字符串
语法： fn:join(array,sparator) à String
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String |
在操作的数组 |
|
sparator |
String |
在结果中每个元素之间的分隔符 |
|
返回值 |
String |
拼接之后的结果 |
示例：
<%
// 设置一个数组到page域对象中
pageContext.setAttribute("strArr", new String[]{"a","b","c","d"});
%>
${ fn:join( pageScope.strArr ,"--") }<br/> 输出 a--b--c--d
2.3.9、fn:toLowerCase函数 和 fn:toUpperCase函数
作用：将字符串都转换成大写（toUpperCase）或小写（toLowerCase）字符
语法：
fn: toLowerCase (str) à String
fn: toUpperCase(str) à String
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String |
源字符串 |
|
返回值 |
String |
转换为大写或小写的字符串 |
示例：
${ fn:toLowerCase("ABCDE") }<br/> 输出abcde
${ fn:toUpperCase("abcde") }<br/> 输出ABCDE
2.3.10、fn:trim函数
作用：去掉字符串的前后空格
用法：fn:trim(str) à String
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String |
源字符串 |
|
返回值 |
String |
去掉前后空格的结果 |
示例：
${ fn:trim(" 爱你一万年 ") }<br/> 输出"爱你一万年"
2.3.11、fn:length函数
作用： 返回集合或者字符串的长度
用法： fn:length(str) à int
参数和返回值：
|
参数 |
类型 |
作用 |
|
str |
String、集合、数组 |
要计算长度的目标 |
|
返回值 |
int |
集合或字符串的长度 |
参数如果是字符串，调用.length()方法 返回字符串的长度。
如果是集合，调用.size() 方法返回集合的个数。
如果是map对象，调用size() 方法返回个数。
如果是数组，返回数组的长度。
示例：
<%
List<Object> list = new ArrayList<Object>();
list.add("a");
list.add("b");
// list集合
pageContext.setAttribute("list", list);
Map<String,Object> map = new HashMap<String,Object>();
map.put("a", "a");
map.put("b", "b");
map.put("c", "c");
// 添加map集合
pageContext.setAttribute("map", map);
// 添加数组
Object[] arr = new Object[10];
arr[0] = 12;
pageContext.setAttribute("arr", arr);
%>
${ fn:length("abcde") }<br/> 输出5字符串的长度.length()方法
${ fn:length(list) }<br/> 输出2，list.size()列表中的元素个数
${ fn:length(map) }<br/> 输出3，map.size()中几对元素
${ fn:length(arr) }<br/> 输出数组的长度10