第02章-WEB技术-JSP

学习目标

掌握 JSP 的使用 重点
掌握四大作用域的特征重点
掌握 EL 表达式的使用重点

JSP 基础

JSP 简介

JSP全称（Java Server Pages），是一种动态网页开发技术。它使用JSP标签在HTML网页中插入Java代码。

（1）JSP 的本质是一个 Servlet，Servlet 能做的事情 JSP 都能做。

（2）JSP 能够以 HTML 页面的方式呈现数据，是一个可以嵌入 Java 代码的 HTML。

（3）JSP 不同于 HTML，不能使用浏览器直接打开，而必须运行在 Servlet 容器中。

JSP 运行原理

（1）WEB容器JSP页面的访问请求时，它将把该访问请求交给JSP引擎去处理。Tomcat中的JSP引擎就是一个Servlet程序，它负责解释和执行JSP页面。

（2）每个JSP页面在第一次被访问时，JSP引擎先将它翻译成一个Servlet源程序，接着再把这个Servlet源程序编译成Servlet的class类文件，然后再由WEB容器像调用普通Servlet程序一样的方式来装载和解释执行这个由JSP页面翻译成的Servlet程序。

JSP 标记

（1） <% %>叫做脚本，其中写的内容会翻译在Servlet的Service方法中，可以在Service方法中定义局部变量或者调用其他方法，但是不能在Service中再定义其他的方法。

（2）<%! %>称作声明，其中写的内容将来会直接翻译在Servlet类中，所以我们可以在<%!%>中声明**方法**、**属性**、**全局变量**。

（3） <%= %>称作输出表达式，用于将已经声明的**变量**或者**表达式**输出到网页上面。

（4）<%-- --%> 注释语句

（5）<%@ %> 指令语句 <%@ page import="java.util.*" %>

（6）直接写在jsp页面中的代码称作模板元素，将会被Servlet的Service方法中的out.write("___")中，作为输出内容。

如：

1
2
3
4
<%@ page language="java"
    contentType="text/html;charset=UTF-8"
    pageEncoding="UTF-8"
    import="java.util.Date"%>

JSP 生命周期

理解JSP底层功能的关键就是去理解它们所遵守的生命周期。

JSP生命周期就是从创建到销毁的整个过程，类似于servlet生命周期，区别在于JSP生命周期还包括将JSP文件编译成servlet。

以下是JSP生命周期中所走过的几个阶段：

编译阶段：
servlet容器编译servlet源文件，生成servlet类
初始化阶段：
加载与JSP对应的servlet类，创建其实例，并调用它的初始化方法
执行阶段：
调用与JSP对应的servlet实例的服务方法
销毁阶段：
调用与JSP对应的servlet实例的销毁方法，然后销毁servlet实例

很明显，JSP生命周期的四个主要阶段和servlet生命周期非常相似。

JSP编译

当浏览器请求JSP页面时，JSP引擎会首先去检查是否需要编译这个文件。如果这个文件没有被编译过，或者在上次编译后被更改过，则编译这个JSP文件。

编译的过程包括三个步骤：

解析JSP文件。
将JSP文件转为servlet。
编译servlet。

JSP初始化

容器载入JSP文件后，它会在为请求提供任何服务前调用jspInit()方法。

如果您需要执行自定义的JSP初始化任务，复写jspInit()方法就行了

一般来讲程序只初始化一次，servlet也是如此。

通常情况下您可以在jspInit()方法中初始化数据库连接、打开文件和创建查询表。

JSP执行

这一阶段描述了JSP生命周期中一切与请求相关的交互行为，直到被销毁。

当JSP网页完成初始化后，JSP引擎将会自动调用_jspService()方法。

_jspService()方法在每个request中被调用一次并且负责产生与之相对应的response，并且它还负责产生所有7个HTTP方法的回应，比如GET、POST、DELETE等等。

JSP清理

JSP生命周期的销毁阶段描述了当一个JSP网页从容器中被移除时所发生的一切。

jspDestroy()方法在JSP中等价于servlet中的销毁方法。当您需要执行任何清理工作时复写jspDestroy()方法，比如释放数据库连接或者关闭文件夹等等。

案例：生命周期

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<html>
<head>
	<title>life.jsp</title>
</head>
<body>
	<%!
    private int initVar = 0;
	private int serviceVar = 0;
	private int destroyVar = 0;
    %>
&lt;%!
<span class="hljs-comment">/*当页面对应的servlet第一次被创建的时候执行————由用户自定义*/</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">jspInit</span><span class="hljs-params">()</span> </span>{
	initVar++;
	System.out.println(<span class="hljs-string">"jspInit(): JSP被初始化了"</span> + initVar + <span class="hljs-string">"次"</span>);
}
%&gt;

&lt;%
!<span class="hljs-comment">/*当页面对应的servlet被自动销毁的时候执行————由用户自定义*/</span>
<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">jspDestroy</span><span class="hljs-params">()</span> </span>{
	destroyVar++;
	System.out.println(<span class="hljs-string">"jspDestroy(): JSP被销毁了"</span> + destroyVar + <span class="hljs-string">"次"</span>);
}
%&gt;

&lt;%
	<span class="hljs-comment">/*当页面对应的servlet被自动销毁的时候执行————由系统自动调用，用户不可自定义*/</span>
	serviceVar++;
	System.out.println(<span class="hljs-string">"_jspService(): JSP共响应了"</span> + serviceVar + <span class="hljs-string">"次请求"</span>);
	String content1 = <span class="hljs-string">"初始化次数 : "</span> + initVar;
	String content2 = <span class="hljs-string">"响应客户请求次数 : "</span> + serviceVar;
	String content3 = <span class="hljs-string">"销毁次数 : "</span> + destroyVar;
%&gt;
&lt;h1&gt;JSP 测试实例&lt;/h1&gt;
&lt;p&gt;&lt;%=content1%&gt;&lt;/p&gt;
&lt;p&gt;&lt;%=content2%&gt;&lt;/p&gt;
&lt;p&gt;&lt;%=content3%&gt;&lt;/p&gt;

</body>

</html>

JSP 三种指令

指令	描述
`<%@ page ... %>`	定义网页依赖属性，比如脚本语言、error页面、缓存需求
`<%@ include ... %>`	包含其他文件
`<%@ taglib ... %>`	引入标签库的定义

Page指令

Page指令为容器提供当前页面的使用说明。一个JSP页面可以包含多个page指令。

格式：

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>

Page指令相关的属性：

属性	描述
buffer	指定out对象使用缓冲区的大小
autoFlush	控制out对象的缓存区
contentType	指定当前JSP页面的MIME类型和字符编码
errorPage	指定当JSP页面发生异常时需要转向的错误处理页面
isErrorPage	指定当前页面是否可以作为另一个JSP页面的错误处理页面
extends	指定servlet从哪一个类继承
import	导入要使用的Java类
info	定义JSP页面的描述信息
isThreadSafe	指定对JSP页面的访问是否为线程安全
language	定义JSP页面所用的脚本语言，默认是Java
session	指定JSP页面是否使用session
isELIgnored	指定是否执行EL表达式
isScriptingEnabled	确定脚本元素能否被使用

Include指令

JSP可以通过include指令来包含其他文件。被包含的文件可以是JSP文件、HTML文件或文本文件。包含的文件就好像是该JSP文件的一部分，会被同时编译执行。

Include指令的语法格式如下：

<%@ include file="文件相对 url 地址" %>

等价的XML语法：

<jsp:directive.include file="文件相对 url 地址" />

include 指令中的文件名实际上是一个相对的 URL 地址。如果您没有给文件关联一个路径，JSP编译器默认在当前路径下寻找。

静态包含：把其它资源包含到当前页面中。

<%@ include file="/include/header.jsp" %>

动态包含：

<jsp:include page="/include/header.jsp"></jsp:include>

两者的区别：

翻译的时间段不同
前者：在翻译时就把两个文件合并
后者：不会合并文件，当代码执行到include时，才包含另一个文件的内容。

原则：能用静的就不用动的。

Taglib指令

JSP API允许用户自定义标签，一个自定义标签库就是自定义标签的集合。

Taglib指令引入一个自定义标签集合的定义，包括库路径、自定义标签。

Taglib指令的语法：

1
2
jsp
 <%@ taglib uri="uri" prefix="prefixOfTag" %>

uri属性确定标签库的位置，prefix属性指定标签库的前缀。等价的XML语法：

<jsp:directive.taglib uri="uri" prefix="prefixOfTag" />

JSP的动作

标签分为JSP自带内置的标签，和通过taglib指令来使用JSP标签库，或者自定义标签。

JSP内置的标签就被称为JSP动作（行为） (JSP Actions)

JSP行为其实是对常用的JSP功能的抽象与封装，可以取代jsp脚本，让JSP中就少一些嵌入java代码的地方。

格式：

<jsp:action_name attribute="value" />

JSP 动作语法：

语法	描述
jsp:include	在页面被请求的时候引入一个文件。
jsp:useBean	寻找或者实例化一个`JavaBean`。
jsp:setProperty	设置`JavaBean`的属性。
jsp:getProperty	输出某个`JavaBean`的属性。
jsp:forward	把请求转到一个新的页面。
jsp:plugin	根据浏览器类型为`Java`插件生成`OBJECT`或`EMBED`标记。
jsp:element	定义动态`XML`元素
jsp:attribute	设置动态定义的`XML`元素属性。
jsp:body	设置动态定义的`XML`元素内容。
jsp:text	在`JSP`页面和文档中使用写入文本的模板

`jsp:include`引入文件

<jsp:include>动作元素用来包含静态和动态的文件。该动作把指定文件插入正在生成的页面。语法格式如下：

1
2
jsp
 <jsp:include page="相对 URL 地址" flush="true" />

include指令和include行为的区别：

include指令，它是在JSP文件被转换成Servlet的时候引入文件，
jsp:include动作，插入文件的时间是在页面被请求的时候。

<jsp:include>属性

属性	描述
page	包含在页面中的相对URL地址。
flush	布尔属性，定义在包含资源前是否刷新缓存区。

被引入的文件

1
2
3
4
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<p>
	今天的日期是:<%=(new java.util.Date()).toLocaleString()%>
</p>

引入其他文件

1
2
3
4
5
6
7
8
9
10
11
12
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title> </title>
</head>
<body>
	<h2>include 动作实例</h2>
	<jsp:include page="date.jsp" flush="true" />
</body>
</html>

`jsp:useBean`引入实体bean

jsp:useBean 动作用来加载一个将在JSP页面中使用的JavaBean。

<jsp:useBean id="name" class="package.class" />

相关属性

属性	描述
id	必选项，指定bean的变量名
class	指定Bean的完整包名。
type	指定将引用该对象变量的类型。
beanName	通过 java.beans.Beans 的 instantiate() 方法指定Bean的名字。
scope	作用域：page、request、session、application

`jsp:setProperty`设置bean的值

jsp:setProperty用来设置已经实例化的Bean对象的属性，有两种用法。

首先，可以在jsp:useBean元素的外面（后面）使用jsp:setProperty

1
2
3
4
jsp
 <jsp:useBean id="myName" ... >
   <jsp:setProperty name="myName" property="someProperty" .../>
 </jsp:useBean>

相关属性

属性	描述
name	name属性是必需的。它表示要设置属性的是哪个Bean。
property	property属性是必需的。它表示要设置哪个属性。有一个特殊用法：如果property的值是"*“，表示所有名字和Bean属性名字匹配的请求参数都将被传递给相应的属性set方法。 \| \| value \| value 属性是可选的。该属性用来指定Bean属性的值。字符串数据会在目标类中通过标准的valueOf方法自动转换成数字、boolean、Boolean、 byte、Byte、char、Character。例如，boolean和Boolean类型的属性值（比如”true“）通过 Boolean.valueOf转换，int和Integer类型的属性值（比如”42"）通过Integer.valueOf转换。　　value和param不能同时使用，但可以使用其中任意一个。
param	param 是可选的。它指定用哪个请求参数作为Bean属性的值。如果当前请求没有参数，则什么事情也不做，系统不会把null传递给Bean属性的set方法。因此，你可以让Bean自己提供默认属性值，只有当请求参数明确指定了新值时才修改默认属性值。

`jsp:getProperty`获取bean的值

jsp:getProperty动作提取指定Bean属性的值，转换成字符串，然后输出

1
2
3
<jsp:useBean id="myName" ... >
	<jsp:getProperty name="myName" property="someProperty" .../>
</jsp:useBean>

相关属性

属性	描述
name	要检索的Bean属性名称。Bean必须已定义。
property	表示要提取Bean属性的值

案例：使用实体bean

实体 bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
package com.jsp;
public class User {

private String username;

private String password;
<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">getUsername</span><span class="hljs-params">()</span> </span>{
	<span class="hljs-keyword">return</span> username;
}

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">setUsername</span><span class="hljs-params">(String username)</span> </span>{
	<span class="hljs-keyword">this</span>.username = username;
}

<span class="hljs-function"><span class="hljs-keyword">public</span> String <span class="hljs-title">getPassword</span><span class="hljs-params">()</span> </span>{
	<span class="hljs-keyword">return</span> password;
}

<span class="hljs-function"><span class="hljs-keyword">public</span> <span class="hljs-keyword">void</span> <span class="hljs-title">setPassword</span><span class="hljs-params">(String password)</span> </span>{
	<span class="hljs-keyword">this</span>.password = password;
}

}

JSP 使用实体 bean

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title></title>
</head>
<body>
	<h2>Jsp 使用 JavaBean 实例</h2>
	<jsp:useBean id="MyUser" class="com.jsp.User" />
	<jsp:setProperty name="MyUser" property="username" value="张三" />
	<p>输出信息....</p>
	<jsp:getProperty name="MyUser" property="username" />
</body>
</html>

效果展示

`jsp:forward` 跳转

jsp:forward动作把请求转到另外的页面。jsp:forward标记只有一个属性page。

<jsp:forward page="相对 URL 地址" />

相关属性

属性	描述
page	page属性包含的是一个相对URL。page的值既可以直接给出，也可以在请求的时候动态计算，可以是一个JSP页面或者一个 Java Servlet.

<jsp:forward page="date.jsp" />

`jsp:plugin`动作元素

jsp:plugin动作用来根据浏览器的类型，插入通过Java插件运行Java Applet所必需的OBJECT或EMBED元素。

如果需要的插件不存在，它会下载插件，然后执行Java组件。 Java组件可以是一个applet或一个JavaBean。

plugin动作有多个对应HTML元素的属性用于格式化Java 组件。param元素可用于向Applet 或 Bean 传递参数。

<fallback>元素是一个新元素，在组件出现故障的错误时发送给用户错误信息。

如：

1
2
3
4
5
<jsp:plugin type="applet" codebase="dirname" code="MyApplet.class" width="60" height="80">
   <jsp:param name="fontcolor" value="red" />
   <jsp:param name="background" value="black" />
   <jsp:fallback>不能初始化插件</jsp:fallback>
</jsp:plugin>

`jsp:elemen`定义元素

`jsp:attribute>`定义元素属性

`jsp:body>`定义元素内容

<jsp:element> 、 <jsp:attribute>、 <jsp:body>动作元素动态定义XML元素。动态是非常重要的，这就意味着XML元素在编译时是动态生成的而非静态。

案例：自定义元素

1
2
3
4
5
6
7
8
9
10
11
12
13
14
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title></title>
</head>
<body>
	<jsp:element name="xmlElement">
		<jsp:attribute name="xmlElementAttr">属性值</jsp:attribute>
		<jsp:body>XML 元素的主体</jsp:body>
	</jsp:element>
</body>
</html>

`jsp:text`显示文字

<jsp:text>动作元素允许在JSP页面和文档中使用写入文本的模板，语法格式如下：

<jsp:text>模板数据</jsp:text>

里面只能包含文本和EL表达式，不能包含“<”、“>”等符号。

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
	<meta charset="utf-8">
	<title></title>
</head>
<body>
	<jsp:element name="xmlElement">
		<jsp:attribute name="xmlElementAttr">属性值</jsp:attribute>
		<jsp:body>XML 元素的主体</jsp:body>
	</jsp:element>
	<jsp:text>jsp:text的文字</jsp:text>
	普通的文字
</body>
</html>

JSP 九大隐式对象

#####

Servlet与JSP九大内置对象的对应关系

JSP对象	Servlet中怎样获得
out	resp.getWriter
request	service方法中的req参数
response	service方法中的resp参数
session	req.getSession()函数
application	getServetContext()函数
exception	Throable
page	this
pageContext	PageContext
config	getServletConfig

request对象

request 对象是 javax.servlet.httpServletRequest类型的对象。该对象代表了客户端的请求信息，主要用于接受通过HTTP协议传送到服务器的数据。（包括头信息、系统信息、请求方式以及请求参数等）。request对象的作用域为一次请求。

1
2
3
4
5
6
7
8
9
10
11
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
	//获得用户名
	String name = request.getParameter("username");
	String pwd = request.getParameter("pwd");
	if ("guoyanan".equals(name) && "123".equals(pwd)) {
		out.print("<h1>登录成功</h1>");
	} else {
		out.print("<h1>登录失败</h1>");
	}
%>

response对象

response 代表的是对客户端的响应，主要是将JSP容器处理过的对象传回到客户端。response对象也具有作用域，它只在JSP页面内有效。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
	response.setHeader("Cache-Control", "no-store");
	response.setDateHeader("Expires", 0);
	//1.    设置页面自动刷新
	response.setHeader("refresh", "2");
	//2.    定时跳转网页
	//response.setHeader("refresh","5;url=login.jsp");
	//设置mime类型
	//response.setContentType(String  type);
	//Type可选类型：text/html、text/plain、application/x_msexcel、application/msword等。
	//页面重定向
	//response.sendRedirect(String  path);
	out.print("<h1>两秒自动刷新一次</h1>");
%>

session对象

session 对象是由服务器自动创建的与用户请求相关的对象。

服务器为每个用户都生成一个session对象，用于保存该用户的信息，跟踪用户的操作状态。

session对象内部使用Map类来保存数据，因此保存数据的格式为 “Key/value”。

session对象的value可以使复杂的对象类型，而不仅仅局限于字符串类型。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
    //存储数据：
    session.setAttribute("name","张三");
    //Name：存放数据的变量名。
    //Obj:存放的对象。
    //获取数据:
    session.getAttribute("name");
    //Name:获取数据的变量。同时获取值。
    //移除对话中的数据：
    //session.removeAttribute("name");
    //Name:需要删除的变量名。
    //设置会话的有效时间：
    //Tomact服务器默认会话时间为30分钟。不过session也可以自己设置会话时间。
    //Time:指有效时间，单位为秒。
    session.setMaxInactiveInterval(10);
%>
<p><%=session.getAttribute("name") %></p>

application对象

application 对象可将信息保存在服务器中，直到服务器关闭，否则application对象中保存的信息会在整个应用中都有效。与session对象相比，application对象生命周期更长，类似于系统的“全局变量”。

1
2
3
4
5
6
7
8
9
10
11
12
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
    //存储数据：
    application.setAttribute("data","保存的共享数据");
    //获取application对象使用的属性名和属性值：
    application.getAttributeNames();
    //根据属性名获取值
    application.getAttribute("data");
    //根据变量名删除数据：
    application.removeAttribute("datas");
%>
<p><%=application.getAttribute("data") %></p>

out 对象

out 对象用于在Web浏览器内输出信息，并且管理应用服务器上的输出缓冲区。在使用 out 对象输出数据时，可以对数据缓冲区进行操作，及时清除缓冲区中的残余数据，为其他的输出让出缓冲空间。待数据输出完毕后，要及时关闭输出流。

1
2
3
4
5
6
7
8
9
10
11
12
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
    //管理缓冲区
    out.clear();//清除缓冲区中的内容
    out.clearBuffer();//清除当前缓冲区的内容
    out.isAutoFlush();//检测当前缓冲区已满时是自动清空，还是抛出异常
    out.flush();//刷新流
    out.getBufferSize();//获取缓冲区的大小
    //输出数据。
    out.print("输出数据1");
    out.println("输出数据2");
%>

pageContext 对象

pageContext 对象的作用是取得任何范围的参数，通过它可以获取 JSP页面的out、request、reponse、session、application 等对象。pageContext对象的创建和初始化都是由容器来完成的，在JSP页面中可以直接使用 pageContext对象。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<%
    //pageContext.forward("main.jsp");    //把页面转发到另一个页面
    pageContext.setAttribute("name","李四");    //为指定范围内的属性设置属性值
    pageContext.getAttribute("name");    //获取参数值
    pageContext.getAttributeNamesInScope(2);    //获取某范围的参数名称的集合，返回值为java.util.Enumeration对象
    pageContext.getException();    //返回exception对象
    pageContext.getRequest();    //返回request对象
    pageContext.getResponse();    //返回Response对象
    pageContext.getSession();    //返回Session对象
    pageContext.getOut();    //返回out对象
    pageContext.getServletConfig();    //返回Config对象
    pageContext.removeAttribute("xxx");    //删除指定范围内的指定属性
%>
<p><%=pageContext.getAttribute("name") %></p>

config 对象

config 对象的主要作用是取得服务器的配置信息。

通过 pageConext对象的 getServletConfig() 方法可以获取一个config对象。

当一个Servlet 初始化时，容器把某些信息通过 config对象传递给这个 Servlet。

开发者可以在web.xml 文件中为应用程序环境中的Servlet程序和JSP页面提供初始化参数。

1
2
3
4
5
6
7
8
9
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%
	config.getServletContext();//获取Servlet上下文
	config.getServletName();//获取Servlet服务器名
	config.getInitParameter("name");//获取服务器所有初始参数名称，返回值为java.util.Enumeration对象
	config.getInitParameterNames();//获取服务器中name参数的初始值
%>
<p><%=config.getInitParameter("name")%></p>

page 对象

page 对象代表JSP本身，只有在JSP页面内才是合法的。 page隐含对象本质上包含当前 Servlet接口引用的变量，类似于Java编程中的 this 指针。

1
2
3
4
5
6
7
8
<%@ page language="java" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%
	page.getClass();//返回当前Object的类
	page.hashCode();//返回该Object的哈希代码
	page.toString();//把该Object类转换为字符串
%>
<p><%=page.getClass()%></p>

exception 对象

exception 对象的作用是显示异常信息，只有在包含 isErrorPage=“true” 的页面中才可以被使用，在一般的JSP页面中使用该对象将无法编译JSP文件。

excepation对象和Java的所有对象一样，都具有系统提供的继承结构。

exception 对象几乎定义了所有异常情况。

在Java程序中，可以使用try/catch关键字来处理异常情况；如果在JSP页面中出现没有捕获到的异常，就会生成 exception 对象，并把 exception 对象传送到在page指令中设定的错误页面中，然后在错误页面中处理相应的 exception 对象。

1
2
3
4
5
6
7
8
9
<%@ page language="java" isErrorPage="true" contentType="text/html; charset=UTF-8"
	pageEncoding="UTF-8"%>
<%
	exception.getMessage();//返回exception对象的异常信息字符串
	exception.getLocalizedMessage();//返回本地化的异常错误
	exception.toString();//返回关于异常错误的简单信息描述
	exception.fillInStackTrace();//重写异常错误的栈执行轨迹
%>
<p><%=exception.getMessage()%></p>

JSP四大作用域

这四个作用域的作用范围，由上到下越来越大。

page作用域
request作用域
session作用域
application作用域

page作用域

（每个页面每次在打开期间）

page直译就是**当前页面**的意思，所以page作用域就比较好理解了——page作用域表示只在当前页面有效。

当程序运行跑出了当前的页面，你就无法在其它的页面访问当前页面设置的属性值。

JSP最终会被编译成Servlet文件。在Servlet容器中，每个Servlet都只存在一个实例。但是对于page作用域的属性来说，在当前页面设置的属性只在本次访问该页面有效，当你再次访问该页面时，又会重新初始化页面的属性。

注：pageContext代表jsp页面的上下文关系，能够调用、存取其他隐含对象；page代表处理当前请求的时候，这个页面的实现类的实例。

request作用域

（每各请求从发送到相应期间）

request表示一次客户端的请求。

一次请求的生命周期从客户端发起到服务器接收并响应该请求，或者将该请求forward到另一个页面或者Servlet进行处理而结束。

在此期间，本次请求的参数，属性都是有效的；一旦客户端刷新浏览器，重新发起请求，则之前的请求参数和属性都将失效。

特别需要注意的是，当我们使用<jsp:forward .../>动作将当前请求转向另一个页面或者Servlet的时候，该请求的参数和属性也一并转过去，并不会因为<jsp:forward .../>动作而丢失request的参数和属性。

session作用域

（每台电脑每个浏览器在指定时间内）

我一直都在强调session是一个非常重要的概念。

当我们向服务器发送第一个请求开始，只要页面不关闭，或者会话未过期（默认30分钟），或者未调用HttpSession的invalidate()方法，接下来的操作都属于同一次会话的范畴。

在JSP中，每当向服务器发送一个请求，服务器响应这个请求的时候，会在客户端的Cookie中写一个session id值。每次发送请求的时候，会将该session id值一起发送到服务器端，服务器端根据该session id值来判断每次请求是否属于同一个session的范畴之内。

application作用域

（每个服务器后台启动期间）

application的作用域是最广的，它代表着整个Web应用的全局变量，对每一个页面，每一个Servlet都是有效的。

当我们在application中设置属性时，这个属性在任意的一个页面都是可以访问的。

在application作用域中设置的属性如果不手动调用removeAttribute函数进行删除的话，那么application中的属性将永远不会删除，如果Web容器发生重启，此时application范围内的所有属性都将丢失。

JSP EL表达式

JSP表达式语言（EL）使得访问存储在JavaBean中的数据变得非常简单。JSP EL既可以用来创建算术表达式也可以用来创建逻辑表达式。在JSP EL表达式内可以使用整型数，浮点数，字符串，常量true、false，还有null。

使用EL表达式会更加简单，如：

${expr}

expr指的是表达式。在JSP EL中通用的操作符是 . 和 {} 。这两个操作符允许您通过内嵌的JSP对象访问各种各样的JavaBean属性。

举例来说

<jsp:setProperty name="box" property="perimeter" value="100"/>

上面的<jsp:setProperty>标签可以使用表达式语言改写成如下形式：

<jsp:setProperty name="box" property="perimeter" value="${2*box.width+2*box.height}"/>

当JSP编译器在属性中见到“${}”格式后，它会产生代码来计算这个表达式，并且产生一个替代品来代替表达式的值。

想要停用对EL表达式的评估的话，需要使用page指令将isELIgnored属性值设为true：

<%@ page isELIgnored ="true|false" %>

这样，EL表达式就会被忽略。若设为false，则容器将会计算EL表达式。

EL 基础操作符

EL表达式支持大部分Java所提供的算术和逻辑操作符：

操作符	描述
`.`	访问一个Bean属性或者一个映射条目
`[]`	访问一个数组或者链表的元素
`( )`	组织一个子表达式以改变优先级
`+`	加
`-`	减或负
`*`	乘
`/ or div`	除
`% or mod`	取模
`== or eq`	测试是否相等
`!= or ne`	测试是否不等
`< or lt`	测试是否小于
`> or gt`	测试是否大于
`<= or le`	测试是否小于等于
`>= or ge`	测试是否大于等于
`&& or and`	测试逻辑与
`\\|\\| or or`	测试逻辑或
`! or not`	测试取反
`empty`	测试是否空值

EL隐含对象

JSP EL支持下表列出的隐含对象：

隐含对象	描述
pageScope	page 作用域
requestScope	request 作用域
sessionScope	session 作用域
applicationScope	application 作用域
param	Request 对象的参数，字符串
paramValues	Request对象的参数，字符串集合
header	HTTP 信息头，字符串
headerValues	HTTP 信息头，字符串集合
initParam	上下文初始化参数
cookie	Cookie值
pageContext	当前页面的pageContext

pageContext对象

pageContext对象是JSP中pageContext对象的引用。

通过pageContext对象，可以访问request对象。

比如，访问request对象传入的查询字符串，就像这样：

${pageContext.request.queryString}

Scope对象

pageScope，requestScope，sessionScope，applicationScope变量用来访问存储在各个作用域层次的变量。

举例来说，如果您需要显式访问在applicationScope层的box变量，可以这样来访问：applicationScope.box。

param和paramValues对象

param和paramValues对象用来访问参数值，通过使用request.getParameter方法和request.getParameterValues方法。

举例来说，访问一个名为order的参数，可以这样使用表达式：${param.order}，或者${param["order"]}。

接下来的例子表明了如何访问request中的username参数：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<%@ page import="java.io.*,java.util.*" %>
<%
    String title = "Accessing Request Param";
%>
<html>
<head>
	<title><% out.print(title); %></title>
</head>
<body>
	<center>
		<h1><% out.print(title); %></h1>
	</center>
	<div align="center">
		<p>${param["username"]}</p>
	</div>
</body>
</html>

param对象返回单一的字符串，而paramValues对象则返回一个字符串数组。

header和headerValues对象

header和headerValues对象用来访问信息头，通过使用 request.getHeader方法和request.getHeaders方法。

举例来说，要访问一个名为user-agent的信息头，可以这样使用表达式：${header.user-agent}，或者${header["user-agent"]}。

接下来的例子表明了如何访问user-agent信息头：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
<%@ page import="java.io.*,java.util.*" %>
<%
    String title = "User Agent Example";
%>
<html>
<head>
	<title><% out.print(title); %></title>
</head>
<body>
	<center>
		<h1><% out.print(title); %></h1>
	</center>
	<div align="center">
		<p>${header["user-agent"]}</p>
	</div>
</body>
</html>

JSP 标准标签库（JSTL）

JSP标准标签库（JSTL）是一个JSP标签集合，它封装了JSP应用的通用核心功能。

JSTL支持通用的、结构化的任务，比如迭代，条件判断，XML文档操作，国际化标签，SQL标签。除了这些，它还提供了一个框架来使用集成JSTL的自定义标签。

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

核心标签
FMT格式化标签
SQL 标签
XML 标签
JSTL 函数

下载地址：https://tomcat.apache.org/download-taglibs.cgi

下载并引入impl、spec、jstlel三个jar包。Compat是兼容包，可以不用。

如果不需要使用jstl 1.0的标签，可以不引入jstlel包。

如果需要使用XML库,还需要添加Apache Xalan 2.7.1或更高版本依赖：

下载地址：http://xalan.apache.org/xalan-j/downloads.html

镜像下载地址：https://mirrors.tuna.tsinghua.edu.cn/apache/xalan/xalan-j/

xalan-2.7.1.jar
serializer-2.7.1.jar

使用前需要先分别引入5种标签：

1
2
3
4
5
6
7
8
9
10
<!--核心库-->
<%@ 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"%>
<!--函数库-->
<%@ taglib prefix="fn" uri="http://java.sun.com/jsp/jstl/functions"%>

核心标签

核心标签是最常用的 JSTL标签。

标签	描述
c:out	用于在JSP中显示数据，就像<%= … >
c:set	用于保存数据
c:remove	用于删除数据
c:catch	用来处理产生错误的异常状况，并且将错误信息储存起来
c:if	与我们在一般程序中用的if一样
c:choose	本身只当做c:when和c:otherwise的父标签
c:when	c:choose的子标签，用来判断条件是否成立
c:otherwise	c:choose的子标签，接在c:when标签后，当c:when标签判断为false时被执行
c:import	检索一个绝对或相对 URL，然后将其内容暴露给页面
c:forEach	基础迭代标签，接受多种集合类型
c:forTokens	根据指定的分隔符来分隔内容并迭代输出
c:param	用来给包含或重定向的页面传递参数
c:redirect	重定向至一个新的URL.
c:url	使用可选的查询参数来创造一个URL

c:out

<c:out value="<string>" default="<string>" escapeXml="<true|false>"/>

相关属性

属性	描述	是否必要	默认值
value	要输出的内容	是	无
default	输出的默认值	否	主体中的内容
escapeXml	是否忽略XML特殊字符	否	true

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
<h1>&lt;c:out&gt; 实例</h1>
<p>
    <c:out value="escapeXml=true（默认）:会忽略HTML|XML标记" escapeXml="true" default="默认值"></c:out>
</p>
<p>
    <c:out value="escapeXml=false:不会忽略HTML|XML标记" escapeXml="false" default="默认值"></c:out>
</p>
<p>
    <c:out value="${null}" escapeXml="false">如果表达式结果为null，则输出该默认值</c:out>
</p>
<p>
    <c:out value="${null}" escapeXml="false" default="如果表达式结果为null，则输出该默认值"/>
</p>

c:set

<c:set var="<string>" value="<string>" target="<string>" property="<string>" scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	要存储的值	否	主体的内容
target	要修改的属性所属的对象	否	无
property	要修改的属性	否	无
var	存储信息的变量	否	无
scope	var属性的作用域	否	page

注：

scope作用域大小依次为：application > session > request > page(默认)
jsp处理变量的先后依次为：page(默认) -> request -> session -> application

如：

1
2
3
4
5
6
7
8
<h1>&lt;c:set&gt; 实例</h1>
<jsp:useBean id="MyUser" class="com.jsp.User" scope="page"/>
<jsp:setProperty name="MyUser" property="username" value="张三" />
<p>设置变量salary=2000*2</p>
<c:set var="salary" scope="session" value="${2000*2}" />
<p><c:out value="out输出：salary=${salary}" /></p>
<c:set property="username" target="${MyUser}" value="王麻子"/>
<p><c:out value="out输出：salary=${MyUser.username}" /></p>

c:remove

<c:remove var="<string>" scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
var	要移除的变量名称	是	无
scope	变量所属的作用域	否	所有作用域

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
<h1>&lt;c:remove&gt; 实例</h1>
<jsp:useBean id="MyUser1" class="com.jsp.User" scope="page"/>
<c:set var="page" scope="page" value="页面1"/>
<c:set var="password" scope="request" value="13465789"/>
<c:set var="appid" scope="session" value="id165875"/>
<c:set var="user" scope="application" value="${MyUser1}"/>
<p>page:<c:out value="${page}"/></p>
<p>password:<c:out value="${password}"/></p>
<p>appid:<c:out value="${appid}"/></p>
<p>user:<c:out value="${user}"/></p>
<c:remove var="page" scope="page"/>
<c:remove var="password" scope="request"/>
<c:remove var="appid" scope="session"/>
<c:remove var="user" scope="application"/>
<p>删除 page 变量后的值: <c:out value="${page}"/></p>
<p>删除 password 变量后的值: <c:out value="${password}"/></p>
<p>删除 appid 变量后的值: <c:out value="${appid}"/></p>
<p>删除 user 变量后的值: <c:out value="${user}"/></p>

c:if

<c:if test="<boolean>" var="<string>" scope="<string>">...</c:if>

相关属性

属性	描述	是否必要	默认值
test	条件	是	无
var	用于存储条件结果的变量	否	无
scope	var属性的作用域	否	page

如：

1
2
3
4
<c:set var="age" scope="session" value="${20}"/>
<c:if test="${age > 18}">
	<p>我<c:out value="${age}"/>岁已经成年了<p>
</c:if>

c:catch

1
2
3
4
<c:catch var="<string>">...</c:catch>
<c:if test = "${catchException != null}">
   <p>异常为 : ${catchException}异常信息: ${catchException.message}</p>
</c:if>

c:choose

c:when

c:otherwise

1
2
3
4
5
<c:choose>
    <c:when test="<boolean>">... </c:when>
    <c:when test="<boolean>">... </c:when>
 	<c:otherwise>... </c:otherwise>
</c:choose>

c:choose标签没有属性。
c:when标签只有一个属性，test 条件默认：无。
c:otherwise标签没有属性。

如：

1
2
3
4
5
6
7
8
<h1>&lt;c:set&gt; 实例</h1>
<c:set var="salary1" scope="session" value="${2000*2}"/>
<p>你的工资为 : <c:out value="${salary1}"/></p>
<c:choose>
   	<c:when test="${salary1 <= 0}">太惨了。</c:when>
   	<c:when test="${salary1 > 1000}">不错的薪水，还能生活。</c:when>
   	<c:otherwise>什么都没有。</c:otherwise>
</c:choose>

c:import

<jsp:include page=""/> action和<c:import url=""/> jstl tag都是动态加载。

c:import则更为灵活。
jsp:include只能include当前web app下的页面，
c:import则可以从外部容器加载内容。

相关属性

属性	描述	是否必要	默认值
url	待导入资源的URL，可以是相对路径和绝对路径，并且可以导入其他主机资源	是	无
context	当使用相对路径访问外部context资源时，context指定了这个资源的名字。	否	当前应用程序
charEncoding	所引入的数据的字符编码集	否	ISO-8859-1
var	用于存储所引入的文本的变量	否	无
scope	var属性的作用域	否	page
varReader	可选的用于提供java.io.Reader对象的变量	否	无

如：

1
2
3
4
5
6
7
<c:import
   url="<string>"
   var="<string>"
   scope="<string>"
   varReader="<string>"
   context="<string>"
   charEncoding="<string>"/>

案例：页面拆分

header.jsp

1
2
3
4
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<div style="background-color: green; height: 60px; text-align: center; line-height: 60px">
    头部
</div>

footer.jsp

1
2
3
4
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<div style="background-color: green; height: 60px; text-align: center; line-height: 60px">
    底部
</div>

index.jsp

1
2
3
4
5
6
7
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!--核心库-->
<%@ taglib prefix="c" uri="http://java.sun.com/jsp/jstl/core"%>
<h1>&lt;c:import&gt; 实例</h1>
<c:import url="header.jsp" charEncoding="utf-8" />
<c:import var="foot" url="footer.jsp" />
<c:out value="${foot}" escapeXml="false"></c:out>

c:forEach

1
2
3
4
5
6
7
<c:forEach
    items="<object>"
    begin="<int>"
    end="<int>"
    step="<int>"
    var="<string>"
    varStatus="<string>">

相关属性

属性	描述	是否必要	默认值
items	要被循环的信息	否	无
begin	开始的元素（0=第一个元素，1=第二个元素）	否	0
end	最后一个元素（0=第一个元素，1=第二个元素）	否	Last element
step	每一次迭代的步长	否	1
var	代表当前条目的变量名称	否	无
varStatus	代表循环状态的变量名称	否	无

c:forTokens

1
2
3
4
5
6
7
8
<c:forTokens
    items="<string>"
    delims="<string>"
    begin="<int>"
    end="<int>"
    step="<int>"
    var="<string>"
    varStatus="<string>">

相关属性

属性	描述	是否必要	默认值
items	要被循环的信息	否	无
begin	开始的元素（0=第一个元素，1=第二个元素）	否	0
end	最后一个元素（0=第一个元素，1=第二个元素）	否	Last element
step	每一次迭代的步长	否	1
var	代表当前条目的变量名称	否	无
varStatus	代表循环状态的变量名称	否	无
delims	分隔符	是	无

如：

1
2
3
4
5
6
7
8
9
<h1>&lt;c:forEach&gt; 实例</h1>
<c:forEach var="i" begin="1" end="5">
	<p><c:out value="${i}"/></p>
</c:forEach>
<h1>&lt;c:forTokens&gt; 实例</h1>

<c:forTokens items="准备,进行,完成,交接,结束" delims="," var="status">

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

</c:forTokens>

`c:url`、`c:param`

<c:url>标签将URL格式化为一个字符串，然后存储在一个变量中。

1
2
3
4
5
<c:url
  var="<string>"
  scope="<string>"
  value="<string>"
  context="<string>"/>

<c:param>标签用于在<c:url>标签中指定参数，而且与URL编码相关。

在<c:param>标签内，name属性表明参数的名称，value属性表明参数的值。

<c:param name="<string>" value="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	基础URL	是	无
context	本地网络应用程序的名称	否	当前应用程序
var	代表URL的变量名	否	Print to page
scope	var属性的作用域	否	Page

如：

1
2
3
4
5
6
7
<h1>&lt;c:url&gt实例</h1>
<a href="<c:url value="http://www.baidu.com"/>">百度</a>
<c:url var="url" value="http://www.baidu.com">
	<c:param name="name" value="张三"/>
	<c:param name="pswd" value="123456"/>
</c:url>
<a href="${url}">百度</a>

c:redirect

<c:redirect>标签通过自动重写URL来将浏览器重定向至一个新的URL，它提供内容相关的URL，并且支持c:param标签。

<c:redirect url="<string>" context="<string>"/>

相关属性

属性	描述	是否必要	默认值
url	目标URL	是	无
context	紧接着一个本地网络应用程序的名称	否	当前应用程序

如：

1
2
3
4
5
<h1>&lt;c:redirect&gt实例</h1>
<c:redirect url="http://www.baidu.com">
	<c:param name="name" value="张三"/>
    <c:param name="pswd" value="123456"/>
</c:redirect>

格式化标签

JSTL格式化标签用来格式化并输出文本、日期、时间、数字。引用格式化标签库的语法如下：

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

标签	描述
fmt:formatNumber	使用指定的格式或精度格式化数字
fmt:parseNumber	解析一个代表着数字，货币或百分比的字符串
fmt:formatDate	使用指定的风格或模式格式化日期和时间
fmt:parseDate	解析一个代表着日期或时间的字符串
fmt:bundle	绑定资源
fmt:setLocale	指定地区
fmt:setBundle	绑定资源
fmt:timeZone	指定时区
fmt:setTimeZone	指定时区
fmt:message	显示资源配置文件信息
fmt:requestEncoding	设置request的字符编码

fmt:formatNumber

<fmt:formatNumber>标签用于格式化数字，百分比，货币。

1
2
3
4
5
6
7
8
9
10
11
12
13
<fmt:formatNumber
  value="<string>"
  type="<string>"
  pattern="<string>"
  currencyCode="<string>"
  currencySymbol="<string>"
  groupingUsed="<string>"
  maxIntegerDigits="<string>"
  minIntegerDigits="<string>"
  maxFractionDigits="<string>"
  minFractionDigits="<string>"
  var="<string>"
  scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	要显示的数字	是	无
type	NUMBER，CURRENCY，或 PERCENT类型	否	Number
pattern	指定一个自定义的格式化模式用与输出	否	无
currencyCode	货币码（当type=“currency”时）	否	取决于默认区域
currencySymbol	货币符号 (当 type=“currency”时)	否	取决于默认区域
groupingUsed	是否对数字分组 (TRUE 或 FALSE)	否	true
maxIntegerDigits	整型数最大的位数	否	无
minIntegerDigits	整型数最小的位数	否	无
maxFractionDigits	小数点后最大的位数	否	无
minFractionDigits	小数点后最小的位数	否	无
var	存储格式化数字的变量	否	Print to page
scope	var属性的作用域	否	page

如果type属性为percent或number，那么就可以使用其它几个格式化数字属性。

maxIntegerDigits属性和minIntegerDigits属性允许指定整数的长度。
若实际数字超过了maxIntegerDigits所指定的最大值，则数字将会被截断。

有一些属性允许指定小数点后的位数。

minFractionalDigits属性和maxFractionalDigits属性允许指定小数点后的位数。

若实际的数字超出了所指定的范围，则这个数字会被截断。

数字分组可以用来在每三个数字中插入一个逗号。

groupingIsUsed属性用来指定是否使用数字分组。
当与minIntegerDigits属性一同使用时，就必须要很小心地来获取预期的结果了。

使用pattern属性。这个属性可以让您在对数字编码时包含指定的字符。接下来的表格中列出了这些字符。

符号	描述
0	代表一位数字
E	使用指数格式
#	代表一位数字，若没有则显示 0，前导 0 和追尾 0 不显示。
.	小数点
,	数字分组分隔符
;	分隔格式

| - | 使用默认负数前缀 |
| % | 百分数 |
| ? | 千分数 |
| ¤ | 货币符号，使用实际的货币符号代替 |
| X | 指定可以作为前缀或后缀的字符 |
| ’ | 在前缀或后缀中引用特殊字符 |

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
<h3>数字格式化:</h3>
<c:set var="balance" value="120000.2309" />
<p>1:<fmt:formatNumber value="${balance}" type="currency"/></p>
<p>2:<fmt:formatNumber type="number" maxIntegerDigits="3" value="${balance}" /></p>
<p>3:<fmt:formatNumber type="number" maxFractionDigits="3" value="${balance}" /></p>
<p>4:<fmt:formatNumber type="number" groupingUsed="false" value="${balance}" /></p>
<p>5:<fmt:formatNumber type="percent" maxIntegerDigits="3" value="${balance}" /></p>
<p>6:<fmt:formatNumber type="percent" minFractionDigits="10" value="${balance}" /></p>
<p>7:<fmt:formatNumber type="percent" maxIntegerDigits="3" value="${balance}" /></p>
<p>8:<fmt:formatNumber type="number" pattern="###.###E0" value="${balance}" /></p>
<p>美元:<fmt:setLocale value="en_US"/>
	<fmt:formatNumber value="${balance}" type="currency"/>
</p>

fmt:parseNumber

<fmt:parseNumber>标签用来解析数字，百分数，货币。

1
2
3
4
5
6
7
8
<fmt:parseNumber
  value="<string>"
  type="<string>"
  pattern="<string>"
  parseLocale="<string>"
  integerOnly="<string>"
  var="<string>"
  scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	要解析的数字	否	Body
type	NUMBER,，CURRENCY，或 PERCENT	否	number
parseLocale	解析数字时所用的区域	否	默认区域
integerOnly	是否只解析整型数（true）或浮点数（false）	否	false
pattern	自定义解析模式	否	无
timeZone	要显示的日期的时区	否	默认时区
var	存储待解析数字的变量	否	Print to page
scope	var属性的作用域	否	page

如：

1
2
3
4
5
6
<h3>数字解析:</h3>
<c:set var="balance" value="1250003.350" />
<fmt:parseNumber var="i" type="number" value="${balance}" />
<p>1:<c:out value="${i}"/></p>
<fmt:parseNumber var="i" integerOnly="true" type="number" value="${balance}" />
<p>2:<c:out value="${i}"/></p>

fmt:formatDate

<fmt:formatDate>标签用于使用不同的方式格式化日期。

1
2
3
4
5
6
7
8
9
<fmt:formatDate
  value="<string>"
  type="<string>"
  dateStyle="<string>"
  timeStyle="<string>"
  pattern="<string>"
  timeZone="<string>"
  var="<string>"
  scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	要显示的日期	是	无
type	DATE, TIME, 或 BOTH	否	date
dateStyle	FULL, LONG, MEDIUM, SHORT, 或 DEFAULT	否	default
timeStyle	FULL, LONG, MEDIUM, SHORT, 或 DEFAULT	否	default
pattern	自定义格式模式	否	无
timeZone	显示日期的时区	否	默认时区
var	存储格式化日期的变量名	否	显示在页面
scope	存储格式化日志变量的范围	否	页面

<fmt:formatDate> 标签格式模式

码	描述	实例
G	时代标志	AD
y	不包含纪元的年份。如果不包含纪元的年份小于 10，则显示不具有前导零的年份。	2002
M	月份数字。一位数的月份没有前导零。	April & 04
d	月中的某一天。一位数的日期没有前导零。	20
h	12 小时制的小时。一位数的小时数没有前导零。	12
H	24 小时制的小时。一位数的小时数没有前导零。	0
m	分钟。一位数的分钟数没有前导零。	45
s	秒。一位数的秒数没有前导零。	52
S	毫秒	970
E	周几	Tuesday
D	一年中的第几天	180
F	一个月中的第几个周几	2 (一个月中的第二个星期三)
w	一年中的第几周r	27
W	一个月中的第几周	2
a	a.m./p.m. 指示符	PM
k	小时(12 小时制的小时)	24
K	小时(24 小时制的小时)	0
z	时区	中部标准时间
‘ \| \| 转义文本 \| \| ’’		单引号

如：

1
2
3
4
5
6
7
8
9
<h3>日期格式化:</h3>
<c:set var="now" value="<%=new java.util.Date()%>"/>
<p>1:<fmt:formatDate type="time" value="${now}"/></p>
<p>2:<fmt:formatDate type="date" value="${now}"/></p>
<p>3:<fmt:formatDate type="both" value="${now}"/></p>
<p>4:<fmt:formatDate type="both" dateStyle="short" timeStyle="short" value="${now}"/></p>
<p>5:<fmt:formatDate type="both" dateStyle="medium" timeStyle="medium" value="${now}"/></p>
<p>6:<fmt:formatDate type="both" dateStyle="long" timeStyle="long" value="${now}"/></p>
<p>7:<fmt:formatDate pattern="yyyy-MM-dd" value="${now}"/></p>

fmt:parseDate

<fmt:parseDate> 标签用于解析日期。

1
2
3
4
5
6
7
8
9
10
<fmt:parseDate
   value="<string>"
   type="<string>"
   dateStyle="<string>"
   timeStyle="<string>"
   pattern="<string>"
   timeZone="<string>"
   parseLocale="<string>"
   var="<string>"
   scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	要显示的日期	是	无
type	DATE, TIME, 或 BOTH	否	date
dateStyle	FULL, LONG, MEDIUM, SHORT, 或 DEFAULT	否	default
timeStyle	FULL, LONG, MEDIUM, SHORT, 或 DEFAULT	否	default
pattern	自定义格式模式	否	无
timeZone	显示日期的时区	否	默认时区
var	存储格式化日期的变量名	否	显示在页面
scope	存储格式化日志变量的范围	否	页面

如：

1
2
3
4
<h3>日期解析:</h3>
<c:set var="now" value="20-10-2019"/>
<fmt:parseDate value="${now}" var="parsedEmpDate" pattern="dd-MM-yyyy"/>
<p>解析后的日期为: <c:out value="${parsedEmpDate}"/></p>

fmt:bundle

<fmt:bundle>标签用于载入指定文件资源

<fmt:bundle baseName="<string>" prefix="<string>"/>

相关属性

属性	描述	是否必要	默认值
basename	指定被载入的资源束的基础名称	是	无
prefix	指定`<fmt:message>`标签key属性的前缀	否	无

fmt:setBundle

<fmt:setBundle>标签用来载入一个资源束，然后将它存储在作用域中已命名的变量或bundle配置变量中。

<fmt:setBundle baseName="<string>" var="<string>" scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
basename	资源束家族基础名称，暴露给作用域变量或配置变量	是	无
var	存储新资源束的变量	否	Replace default
scope	变量的作用域	否	Page

fmt:message

<fmt:message>标签映射一个<fmt:bundle>指定文件资源中的变量

相关属性

1
2
3
4
5
<fmt:message
   key="<string>"
   bundle="<string>"
   var="<string>"
   scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
key	要检索的消息关键字	否	Body
bundle	要使用的资源束	否	默认资源束
var	存储局部消息的变量名	否	Print to page
scope	var属性的作用域	否	Page

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
package com.jsp;
import java.util.ListResourceBundle;
public class Bundle extends ListResourceBundle{

public Object[][] getContents() {

return contents;

}

static final Object[][] contents =

{

{ "count.one", "One" },

{ "count.two", "Two" },

{ "count.three", "Three" }

};

}

JSP 使用

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
<h3>bundle引入资源，带前缀:</h3>
<fmt:bundle basename="com.jsp.Bundle" prefix="count.">
	<fmt:message key="one" />
	<br />
	<fmt:message key="two" />
	<br />
	<fmt:message key="three" />
	<br />
</fmt:bundle>
<h3>bundle引入资源，不带前缀:</h3>
<fmt:bundle basename="com.jsp.Bundle">
	<fmt:message key="count.one" />
	<br />
	<fmt:message key="count.two" />
	<br />
	<fmt:message key="count.three" />
	<br />
</fmt:bundle>
<h3>setBundle引入资源:</h3>

<fmt:setBundle basename="com.jsp.Bundle" var="lang" />

<fmt:message key="count.one" bundle="${lang}" />

<br />

<fmt:message key="count.two" bundle="${lang}" />

<br />

<fmt:message key="count.three" bundle="${lang}" />

<br />

fmt:timeZone

fmt:setTimeZone

<fmt:timeZone>标签用来指定时区，供其它标签使用。

<fmt:setLocale value="<string>" variant="<string>" scope="<string>"/>

<fmt:setTimeZone>标签用来复制一个时区对象至指定的作用域。

<fmt:setTimeZone value="<string>" var="<string>" scope="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	时区	是	无
var	存储新时区的变量名	否	Replace default
scope	变量的作用域	否	Page

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
<c:set var="now" value="<%=new java.util.Date()%>" />
<table border="1" width="100%">
	<tr>
		<td width="100%" colspan="2" bgcolor="#0000FF">
			<p align="center">
				<b> 
					<font color="#FFFFFF" size="4">Formatting: 
						<fmt:formatDate value="${now}" type="both" timeStyle="long" dateStyle="long" />
					</font>
				</b>
			</p>
		</td>
	</tr>
&lt;c:forEach var=<span class="hljs-string">"zone"</span>
	items=<span class="hljs-string">"&lt;%=java.util.TimeZone.getAvailableIDs()%&gt;"</span>&gt;
	&lt;tr&gt;
		&lt;td width=<span class="hljs-string">"51%"</span>&gt;&lt;c:out value=<span class="hljs-string">"${zone}"</span> /&gt;&lt;/td&gt;
		&lt;td width=<span class="hljs-string">"49%"</span>&gt;
			&lt;fmt:timeZone value=<span class="hljs-string">"${zone}"</span>&gt;
				&lt;fmt:formatDate value=<span class="hljs-string">"${now}"</span> timeZone=<span class="hljs-string">"${zn}"</span> type=<span class="hljs-string">"both"</span> /&gt;
			&lt;/fmt:timeZone&gt;
		&lt;/td&gt;
	&lt;/tr&gt;
&lt;/c:forEach&gt;

</table>

<p>

当前时区时间:

<fmt:formatDate value="${now}" type="both" timeStyle="long" dateStyle="long" />

</p>

<p>修改为 GMT-8 时区:</p>

<fmt:setTimeZone value="GMT-8" />

<p>

改变后的时区为:

<fmt:formatDate value="${now}" type="both" timeStyle="long" dateStyle="long" />

</p>

fmt:requestEncoding

<fmt:requestEncoding>标签用来指定返回给Web应用程序的表单编码类型。

<fmt:requestEncoding value="<string>"/>

使用<fmt:requestEncoding>标签来指定字符集，用于解码来自表单的数据。在字符集不是ISO-8859-1时必须使用这个标签。由于大多数浏览器在它们的请求中不包含Content-Type头，所以需要这个标签。

<fmt:requestEncoding>标签的目的就是用来指定请求的Content-Type。您必须指定一个Content-Type，就算response是通过Page指令的contentType属性来编码。这是因为response的实际区域可能与Page指令所指定的不同。

<fmt:requestEncoding value="UTF-8" />

SQL标签

JSTL SQL标签库提供了与关系型数据库（Oracle，MySQL，SQL Server等等）进行交互的标签。

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

相关属性

标签	描述
sql:setDataSource	指定数据源
sql:query	运行SQL查询语句
sql:update	运行SQL更新语句
sql:param	将SQL语句中的参数设为指定值
sql:dateParam	将SQL语句中的日期参数设为指定的java.util.Date 对象值
sql:transaction	在共享数据库连接中提供嵌套的数据库行为元素，将所有语句以一个事务的形式来运行

sql:setDataSource

1
2
3
4
5
6
7
8
<sql:setDataSource
  var="<string>"
  scope="<string>"
  dataSource="<string>"
  driver="<string>"
  url="<string>"
  user="<string>"
  password="<string>"/>

*属性*	*描述*	*是否必要*	*默认值*
driver	要注册的JDBC驱动	否	无
url	数据库连接的JDBC URL	否	无
user	数据库用户名	否	无
password	数据库密码	否	无
dataSource	事先准备好的数据库	否	无
var	代表数据库的变量	否	默认设置
scope	var属性的作用域	否	Page

sql:query

1
2
3
4
5
6
7
<sql:query
  var="<string>"
  scope="<string>"
  sql="<string>"
  dataSource="<string>"
  startRow="<string>"
  maxRows="<string>"/>

属性	描述	是否必要	默认值
sql	需要执行的SQL命令（返回一个ResultSet对象)	否	Body
dataSource	所使用的数据库连接（覆盖默认值）	否	默认数据库
maxRows	存储在变量中的最大结果数	否	无穷大
startRow	开始记录的结果的行数	否	0
var	代表数据库的变量	否	默认设置
scope	var属性的作用域	否	Page

sql:update

<sql:update var="<string>" scope="<string>" sql="<string>" dataSource="<string>"/>

相关属性

属性	描述	是否必要	默认值
sql	需要执行的SQL命令（不返回ResultSet对象）	否	Body
dataSource	所使用的数据库连接（覆盖默认值）	否	默认数据库
var	用来存储所影响行数的变量	否	无
scope	var属性的作用域	否	Page

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
<sql:setDataSource var="snapshot" driver="com.mysql.cj.jdbc.Driver"
	url="jdbc:mysql://localhost/mvc?serverTimezone=GMT" user="root"
	password="" />
<sql:update dataSource="${snapshot}" var="count">

INSERT INTO tb_student(studentName,sex,tel) VALUES('李四',0,'18654856698');

</sql:update>
<sql:query dataSource="${snapshot}" var="result">

select * from tb_student;

</sql:query>
<table border="1" width="100%">

<tr>

<th>ID</th>

<th>姓名</th>

<th>性别</th>

<th>电话</th>

</tr>

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

<tr>

<td><c:out value="${row.id}" /></td>

<td><c:out value="${row.studentName}" /></td>

<td><c:out value="${row.sex}" /></td>

<td><c:out value="${row.tel}" /></td>

</tr>

</c:forEach>

</table>

sql:param

<sql:param value="<string>"/>

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
<sql:setDataSource var="snapshot" driver="com.mysql.cj.jdbc.Driver"
	url="jdbc:mysql://localhost/mvc?serverTimezone=GMT" user="root"
	password="" />
<c:set var="name" value="王五"/>

<c:set var="sex" value="1"/>

<c:set var="tel" value="18569457856"/>
<sql:update dataSource="${snapshot}" var="count">

INSERT INTO tb_student(studentName,sex,tel) VALUES(?,?,?);

<sql:param value="${name}" />

<sql:param value="${sex}" />

<sql:param value="${tel}" />

</sql:update>
<sql:query dataSource="${snapshot}" var="result">

select * from tb_student;

</sql:query>
<table border="1" width="100%">

<tr>

<th>ID</th>

<th>姓名</th>

<th>性别</th>

<th>电话</th>

</tr>

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

<tr>

<td><c:out value="${row.id}" /></td>

<td><c:out value="${row.studentName}" /></td>

<td><c:out value="${row.sex}" /></td>

<td><c:out value="${row.tel}" /></td>

</tr>

</c:forEach>

</table>

sql:dateParam

<sql:dateParam value="<string>" type="<string>"/>

相关属性

属性	描述	是否必要	默认值
value	需要设置的日期参数（java.util.Date）	否	Body
type	DATE （只有日期），TIME（只有时间）， TIMESTAMP （日期和时间）	否	TIMESTAMP

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
<sql:setDataSource var="snapshot" driver="com.mysql.cj.jdbc.Driver"
	url="jdbc:mysql://localhost/mvc?serverTimezone=GMT" user="root"
	password="" />
<c:set var="name" value="王五" />

<c:set var="sex" value="1" />

<c:set var="tel" value="18569457856" />
<%

Date birthday = new Date();

%>
<sql:update dataSource="${snapshot}" var="count">

INSERT INTO tb_student(studentName,sex,birthday,tel) VALUES(?,?,?,?);

<sql:param value="${name}" />

<sql:param value="${sex}" />

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

<sql:param value="${tel}" />

</sql:update>
<sql:query dataSource="${snapshot}" var="result">

select * from tb_student;

</sql:query>
<table border="1" width="100%">

<tr>

<th>ID</th>

<th>姓名</th>

<th>性别</th>

<th>生日</th>

<th>电话</th>

</tr>

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

<tr>

<td><c:out value="${row.id}" /></td>

<td><c:out value="${row.studentName}" /></td>

<td><c:out value="${row.sex}" /></td>

<td><c:out value="${row.birthday}" /></td>

<td><c:out value="${row.tel}" /></td>

</tr>

</c:forEach>

</table>

<sql:transaction>

<sql:transaction>标签用来将<sql:query>标签和<sql:update>标签封装至事务中。可以将大量的<sql:query>和<sql:update>操作装入<sql:transaction>中，使它们成为单一的事务。

确保对数据库的修改不是被提交就是被回滚。

<sql:transaction dataSource="<string>" isolation="<string>"/>

相关属性

属性	描述
dataSource	所使用的数据库（覆盖默认值）
isolation	事务隔离等级（READ_COMMITTED,，READ_UNCOMMITTED， REPEATABLE_READ或 SERIALIZABLE）

如：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
<sql:setDataSource var="snapshot" driver="com.mysql.cj.jdbc.Driver"
	url="jdbc:mysql://localhost/mvc?serverTimezone=GMT" user="root"
	password="" />
<c:set var="name" value="王五" />

<c:set var="sex" value="1" />

<c:set var="tel" value="18569457856" />
<%

Date birthday = new Date();

%>

<sql:transaction dataSource="${snapshot}">

<sql:update var="count">

UPDATE tb_student SET studentName = '范冰冰'  WHERE id = 2;

</sql:update>
&lt;sql:update var=<span class="hljs-string">"count"</span>&gt;
	<span class="hljs-function">INSERT INTO <span class="hljs-title">tb_student</span><span class="hljs-params">(studentName,sex,birthday,tel)</span> <span class="hljs-title">VALUES</span><span class="hljs-params">(?,?,?,?)</span></span>;
	&lt;sql:param value=<span class="hljs-string">"${name}"</span> /&gt;
	&lt;sql:param value=<span class="hljs-string">"${sex}"</span> /&gt;
	&lt;sql:param value=<span class="hljs-string">"&lt;%=birthday%&gt;"</span> /&gt;
	&lt;sql:param value=<span class="hljs-string">"${tel}"</span> /&gt;
&lt;/sql:update&gt;

</sql:transaction>
<sql:query dataSource="${snapshot}" var="result">

select * from tb_student;

</sql:query>
<table border="1" width="100%">

<tr>

<th>ID</th>

<th>姓名</th>

<th>性别</th>

<th>生日</th>

<th>电话</th>

</tr>

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

<tr>

<td><c:out value="${row.id}" /></td>

<td><c:out value="${row.studentName}" /></td>

<td><c:out value="${row.sex}" /></td>

<td><c:out value="${row.birthday}" /></td>

<td><c:out value="${row.tel}" /></td>

</tr>

</c:forEach>

</table>

JSTL函数

JSTL包含一系列标准函数，大部分是通用的字符串处理函数。引用JSTL函数库的语法如下：

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

相关属性

函数	描述
fn:contains()	测试输入的字符串是否包含指定的子串
fn:containsIgnoreCase()	测试输入的字符串是否包含指定的子串，大小写不敏感
fn:endsWith()	测试输入的字符串是否以指定的后缀结尾
fn:escapeXml()	跳过可以作为XML标记的字符
fn:indexOf()	返回指定字符串在输入字符串中出现的位置
fn:join()	将数组中的元素合成一个字符串然后输出
fn:length()	返回字符串长度
fn:replace()	将输入字符串中指定的位置替换为指定的字符串然后返回
fn:split()	将字符串用指定的分隔符分隔然后组成一个子字符串数组并返回
fn:startsWith()	测试输入字符串是否以指定的前缀开始
fn:substring()	返回字符串的子集
fn:substringAfter()	返回字符串在指定子串之后的子集
fn:substringBefore()	返回字符串在指定子串之前的子集
fn:toLowerCase()	将字符串中的字符转为小写
fn:toUpperCase()	将字符串中的字符转为大写
fn:trim()	移除首尾的空白符

案例

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
<c:set var="str" value="我叫super超人，我在贵州贵阳" />
<c:if test="${fn:contains(str, '超人')}">

<p>看，有超人</p>

</c:if>
<c:if test="${fn:containsIgnoreCase(str, 'SUper')}">

<p>找到 super超人</p>

</c:if>
<c:if test="${fn:startsWith(str, '我叫')}">

<p>他叫super超人</p>

</c:if>
<c:if test="${fn:endsWith(str, '贵阳')}">

<p>super超人来自贵阳</p>

</c:if>
<!--  -->
<c:set var="string1" value="This is first String." />

<c:set var="string2" value="This <abc>is second String.</abc>" />
<p>使用 escapeXml() 函数:</p>

<p>string (1) : ${fn:escapeXml(string1)}</p>

<p>string (2) : ${fn:escapeXml(string2)}</p>
<p>不使用 escapeXml() 函数:</p>

<p>string (1) : ${string1}</p>

<p>string (2) : ${string2}</p>
<p>fn:indexOf()函数:</p>

<p>Index (1) : ${fn:indexOf(string1, "first")}</p>

<p>Index (2) : ${fn:indexOf(string2, "second")}</p>
<c:set var="string3" value="${fn:replace(string1,  'String', 'Glod')}" />

<p>替换后的字符串 : ${string3}</p>
<c:set var="string4" value="${fn:substring(string1, 5, 15)}" />

<p>生成的子字符串为 : ${string4}</p>
<c:set var="string5" value="${fn:substringAfter(string1, 'is')}" />

<p>生成的子字符串 : ${string5}</p>
<c:set var="string6" value="${fn:substringBefore(string1, 'first')}" />

<p>生成的子字符串 : ${string6}</p>
<c:set var="string7" value="${fn:toLowerCase(string1)}" />

<p>字符串为 : ${string7}</p>
<c:set var="string8" value="${fn:toUpperCase(string1)}" />

<p>字符串为 : ${string8}</p>
<c:set var="string1" value="  This is first String.  " />

<c:set var="string9" value="${fn:trim(string1)}" />

<p>string1 长度 : ${fn:length(string1)}</p>

<p>string9 长度 : ${fn:length(string9)}</p>

<p>字符串为 : ${string9}</p>
<!--  -->

<c:set var="string1" value="aaa bbb 111 222" />

<c:set var="string2" value="${fn:split(string1, ' ')}" />

<c:set var="string3" value="${fn:join(string2, '-')}" />
<p>字符串为 : ${string3}</p>

作业

使用 JSP 实现购物车功能

    </article>

第02章-WEB技术-JSP

jsp:include引入文件

jsp:useBean引入实体bean

jsp:setProperty设置bean的值

jsp:getProperty获取bean的值

jsp:forward 跳转

jsp:plugin动作元素

jsp:elemen定义元素

jsp:attribute>定义元素属性

jsp:body>定义元素内容

jsp:text显示文字

c:url、c:param

公告

`jsp:include`引入文件

`jsp:useBean`引入实体bean

`jsp:setProperty`设置bean的值

`jsp:getProperty`获取bean的值

`jsp:forward` 跳转

`jsp:plugin`动作元素

`jsp:elemen`定义元素

`jsp:attribute>`定义元素属性

`jsp:body>`定义元素内容

`jsp:text`显示文字

`c:url`、`c:param`