《Servlet和JSP编程基础》学习笔记

第1章  JSP简介
Java Server Page(JSP)是一种创建动态网页的简单方法

第2章  配置JSP运行环境
JSP运行环境主要包括JDK和Tomcat，开发工具为Eclipse
启动Tomcat: /usr/local/src/apache-tomcat-9.0.0.M9/bin/startup.sh
Tomcat默认Web服务目录是/usr/local/src/apache-tomcat-9.0.0.M9/webapps/ROOT

第3章  JSP基本语法
3.1 Java程序片
HTML式注释的基本语法是：
<!--comment[<%=expression%>]-->
例如：
<!--当前页面的载入时间为：<%=(newjava.util.Data().toLocalString())%>-->
JSP隐藏式注释的基本语法是：
<%--comment--%>或<%/*comment*/%>
3.2 声明
声明的基本语法是：
<%!Declaration1; [Declaration2;]...%>
例如：
<%!int i=2004;%> # 此声明仅对当前页面有效
3.3 表达式
形如<%=expression%>的标签在JSP中被视为表达式，与JSP声明不同，它不使用“;”作为结束符
3.4 程序段
在JSP中程序段一般包括在<% %>之间，其基本语法为：
<%code fragment%>
3.5 JSP指令
1. include指令
include指令的基本语法是：
<%@include file="relative URL"%>
2. page指令
page指令用来设置整个JSP页面的相关属性和功能，其基本语法是：
<%@page attribute1="value1" attribute2="value2"...%>
例如：
<%@page import="java.util.*,javax.servlet.*"%>
page指令属性：
属性                      说明
language="java"           声明脚本语言种类，默认为java
extends="package.class"   定义JSP页面产生的servlet所继承的父类
import="package1.class,
  package2.class..."      声明需要导入的包
session="true|false"      指明session对象是否可用,默认为true
buffer="8kb|none|size kb  指明输出流是否有缓冲区，默认为8kb
autoFlush="true|false"    指明缓冲区是否需要自动清除，默认为true
isThreadSafe="true|false" JSP文件是否允许多线程使用，默认为true
info="text"               描述该JSP页面的相关信息
errorPage="relative URL"  指明如果该页面产生异常，应当调用的JSP页面
isErrorPage="true|false"  指明该JSP页面是否为处理异常错误的页面
ContentType="mimeType[;
charset=characterSet]"    指明MIME类型和编码属性
3. taglib指令
taglib指令允许用户自定义新的标签，其基本语法是：
<%@taglib url="relative tagLibURL" prefix="tagPrefix"%> # 其中url指明自定义标签库的存放位置，prefix是为了区分不同标签库中的相同标签名
3.6 JSP动作
1. <jsp:include>动作
<jsp:include>是在当前JSP页面中动态包含一个文件，其基本语法是：
<jsp:include page="relative URL|<%=expression%>" flush="true"/> # 其中page指明了需要包含的文件路径，flush属性必须设为true,默认为false
<jsp:include>动作与<%@include%>指令不同，前者是在页面被请求访问使才被嵌入，后者是在JSP页面转化成Servlet时嵌入文件
2. <jsp:forward>动作
<jsp:forward>动作允许将用户请求定位至其他页面，其基本语法是：
<jsp:forward page="relative URL">
3. <jsp:plugin>动作
<jsp:plugin>动作用于在客户端浏览器中执行一个Bean或者显示一个Applet,其基本语法是：
<jsp:plugin attribute1="value1" attribue2="value2"...>
例如：
<jsp:plugin type="applet" code="Clock.class" codebase="applet" jreversion="1.2" width="160" height="150">
    <jsp:fallback>APPLET载入出错！<jsp:fallback>
</jsp:plugin>
<jsp:plugin>属性：
属性                                                 说明
type="bean/applet"                                   指定被执行插件的类型，没有默认值，固必须指定
code="classFileName"                                 将被插件执行的Java类文件名，该文件必须位于codebase属性指定的目录中
codebase="classFileBase"                             被执行的Java类文件所在目录，默认值为使用<jsp:plugin>的JSP页面所在路径
name="instanceName"                                  Bean或Applet的名字
align="bottom|top|middle|left|right                  Bean或Applet对象的位置
height="heightPixels" width="widthPixels"            Bean或Applet对象将要显示的长宽值
hspace="leftrightPixels" vspace="topbottomPixels"    Bean或Applet对象显示时距屏幕左右、上下的距离
archive="archiveList"                                一些用逗号分隔开的路径名，这些路径名用于预先加载一些将要使用的Class以提高Applet的性能
iepluginurl="iepluginURL" nspluginurl="nspluginURL"  分别用来指明IE用户和Netscape Navigator用户能够使用的JRE URL地址
jreversion="versionnumber"                           运行Applet或Bean所需JRE的版本，默认值为1.2
<jsp:fallback>message<jsp:fallback>                  当插件无法显示给用户的提示信息
<jsp:params>
    <jsp:param name="parameterName"
        value="parameterValue <%=expression%>"/>
</jsp:params>                                        需要向Applet或Bean对象传递的参数
4. <jsp:param>动作
<jsp:param>用来提供参数信息，其基本语法是：
<jsp:param name="parameterName" value="parameterValue"> # 其中，name属性就是参数的名称，value属性就是参数值
例如：
<jsp:param name="username" value="张三">
3.7 字符使用惯例
特殊字符的替代：
需要替换的字符  用于替换的字符
\               \\
<%              <\%
%>              %\>
'               \'
"               \"
3.8 JSP异常
javax.servlet.jsp包中有两类错误异常，JspError和JspException
JspError发生在JSP文件转换成Servlet文件时，通常称为“转换期错误”，这类错误通常都是由语法错误引起，导致无法编译，在页面中报“HTTP 500”类型的错误，其原型为：
public class JspError extends JspException
JspException发生在编译后的Servlet Class文件在处理Request请求时，因为逻辑上的错误而导致“请求期异常”，其原型为：
public class JspException extends java.lang.Exception

第4章  JSP内置对象
4.1 request对象
request对象是对HTTP请求包的封装
request对象的常用方法：
getProtocol(): 用于获取通信协议
gerServletPath(): 用于获取客户请求的JSP页面文件的目录
getContentLength(): 用于获取客户提交的整个信息的长度
getMethod(): 用于获取客户提交信息的方式
getHeader(String s): 用于获取HTTP头文件中由参数s指定的头名字的值
getHeaderNames(): 用于获取头名字的一个枚举
getHeaders(String s): 用于获取头文件中指定头名字的全部值的一个枚举
getRemoteAddr(): 用于获取客户的IP地址
getRemoteHost(): 用于获取客户机的名字
getServerName(): 用于获取服务器的名字
getServerPort(): 用于获取服务器的端口号
getParameterNames(): 用于获取客户提交的信息体部分的name参数值的一个枚举
4.2 response对象
response对象：服务器响应客户时，即向客户发送信息时，使用的是HTTP响应包，系统将HTTP响应包封装为response对象
response对象常用的方法：
addHeader(String head,String value):向包里添加一个头（head）及对应值（value）
SendRedirect(URL url): 实现客户重定向
SetStatus(int n): 设置响应的状态代码
响应包的状态行：
服务器响应客户时，它发送到客户端的首行被称为状态行，状态行由3位数的状态代码和描述状态代码的文字组成，下面是对状态代码的分类描述
1xx: 1开头的3位数字，主要用于实验
2xx: 2开头的3位数字，表明客户端的请求成功
3xx: 3开头的3位数字，表明处理客户的请求以前，应做一些别的处理
4xx: 4开头的3位数字，表明浏览器请求是非法或无效
5xx: 5开头的3位数字，表明服务器出现问题
4.3 session对象
session对象记录了每个客户与服务器的连接信息
1.会话
从一个客户打开浏览器连接到服务器的某个服务目录，到客户关闭浏览器，这一过程称为一个会话
2.客户的session对象与服务目录
当一个客户首次访问服务目录中的一个JSP页面时，JSP引擎为该客户创建一个session对象
3.session对象与Cookie对象
当JSP引擎为客户创建一个session对象后，这个session对象被分配了一个String类型的ID号，JSP引擎同时将此ID号发送到客户端，存放在Cookie中
4.session对象与线程
一个客户对应一个线程，每个线程对应一个session对象，每个线程的session对象不同
5.session对象生命周期
从一个客户会话开始到会话结束（即客户访问某Web目录下的页面到关闭浏览器，离开该Web目录）这段时间称为session对象的生命周期
6.session对象的常用方法
public void setAttribute(String key, Object obj):session对象类似于散列表，该方法将参数Object指定的对象obj添加到session对象中，并为添加的对象指定一个索引关键字key
public Object getAttribute(String key): 获取session对象中含有关键字key的对象
public Enumeration getAttributeName(): session对象调用该方法可以产生一个枚举对象，该对象使用nextElement()遍历session对象所含有的全部对象
public long getCreateTime(): 获取session对象的创建时间，单位是毫秒，从1970年7月1日午夜起至该对象创建时刻所走过的毫秒数
public int getMaxInactiveInterval(): 获取session对象的生存时间
public void setMaxInactiveInterval(): 设置session对象的生存时间，单位是秒
public void removeAttribute(String key): 从当前session对象中删除关键字key的对象
public String getID(): 获取session对象的编号
invalidate(): 使session对象无效
public boolean isNew(): 判断是否是一个新用户
4.4 application对象
application对象在服务器启动后产生，客户的application对象是相同的一个，即所有客户共享这个内置的application对象
1.application对象生命周期
application对象的生命周期指从application对象创建到服务器关闭这段时间
2.application对象与线程
当多个客户单击同一个页面时，JSP引擎为每个客户启动一个线程，这些线程共享同一个application对象
3.application对象的常用方法
public void setAttribute(String key, Object obj): 将参数Object指定的对象obj添加到application对象中，并为添加到的对象指定一个索引关键字key
public Object getAttribute(String key): 获取application对象中含有的关键字为key的对象
public Enumeration getAttributeNames(): 产生一个枚举对象，该枚举对象使用nextElements()方法遍历application对象所含有的全部对象
public void removeAttribute(String key): 从当前application对象中删除关键字是key的对象
public String getServletInfo(): 获取Servlet编译器的当前版本信息
4.5 page对象
page对象代表JSP页面本身，更确切地说，代表JSP被转译后的Servlet
4.6 out对象
out对象是一个输出流，用来向客户端输出数据

第5章  数据库操作
5.1 JDBC简介
JDBC(Java DataBase Connectivity)是一种用于访问数据库和执行SQL语句的Java API
5.3 JDBC接口
1.Driver
Sun公司定义了4种JDBC驱动：
JDBC-ODBC桥
原始API驱动
JDBC网络纯Java驱动
原始协议纯Java驱动
第一种：JDBC-ODBC桥
它通过ODBC驱动提供对数据库的JDBC访问
第二种：原始API驱动
原始API驱动直接将JDBC命令转换成DBMS所指定的代码调用
第三种：JDBC网络纯Java驱动
这种驱动将JDBC命令转换成独立于数据库的网络协议，协议传送给中间服务器，然后服务器将独立于DBMS的协议转换成具体的DBMS的协议，发送给数据库，结果沿原路返回
第四种：原始协议纯Java驱动
直接同数据库提供商的数据库通信的纯Java驱动，将JDBC命令直接转换成数据库引擎的本地协议
import java.sql.*; # 导入有关SQL的类
Class.forName("sun.jdbc.odbc.JdbcOdbcDriver"); # 使用JDBC-ODBC Bridge Driver时，加载驱动
Class.forName("driver_class_name"); # 使用JDBC Driver时，加载驱动
Class.forName("org.gjt.mm.mysql.Driver"); # 使用JDBC Driver时，加载mysql数据库驱动
Class.forName("org.mariadb.jdbc.Driver"); # 使用JDBC Driver时，加载mariadb数据库驱动
2.DriverManager
用DriverManager的getConnection()方法可以创建一个数据库连接对象，它的一般形式如下：
Connection connection_name=DriverManager.getConnection("驱动类型：数据源","用户名","密码"); # 其中驱动类型，在使用JDBC-ODBC驱动时就用jdbc:odbc,如果是JDBC驱动则根据使用的数据库决定
Connection con = DriverManager.getConnection("jdbc:mysql://主机:端口号;DatabaseName=数据库名称","用户名","密码"); # 使用JDBC驱动时，mysql数据库getConnection()声明
Connection con = DriverManager.getConnection("jdbc:maridb://localhost:3306/grade", "root", ""); # 使用JDBC驱动时，mariadb数据库getConnection()声明
3.Connection
一个Connection表示与一个特定数据库的会话，Connection对象代表与数据库的连接，也就是在已经加载的Driver和数据库之间建立连接
Connection方法：
close(): 关闭数据库的连接
commit(): 提交对数据库的更改，使更改生效，这个方法只有调用了setAutoCommit(false)方法后才生效，否则对数据库的更改会自动提交到数据库
createStatement(): 创建SQL语句对象，调用方法如下：
Statement sql_statement_name=connection_name.createStatement();
GetAutoCommit(): 获得当前自动提交状态，如果是自动提交模式则返回true,否则返回false
isClosed(): 判断连接是否已经关闭，如果已经关闭则返回true,否则返回false
isReadOnly(): 检测该连接是否在只读状态，如果是只读状态则返回true,否则返回false
prepareCall(): 创建一个CallableStatement对象，用来处理一个SQL存储过程调用语句，调用方法如下：
connectionObjectName.prepareStatement(String sqlString); # 其中sqlString是一个SQL语句
rollback(): 回滚上一次提交/回滚操作后的所有更改，并释放Connection当前保持的任何数据库锁，只有当禁止自动提交时可以使用该方法
setAutoCommit(): 设置连接是否处于自动提交状态，其调用方法如下：
connectionObjectName.setAutoCommit(boolean autoCommit); # 参数autoCommit如果为true则启动自动提交，否则禁止自动提交
setReadOnly(): 可以把一个连接设置为只读模式，调用方法如下：
connectionObjectName.setReadOnly(boolean readOnly); # 参数readOnly如果为true则启动只读模式，若false则禁止只读模式
4.Statement
Statement类对象代表SQL语句，可用于将SQL语句发送至数据库，其中存在三种Statement对象：
Statement, 用来执行基本的SQL语句
PreparedStatement, 它从Statement继承，用于提供和查询信息一起预编译的语句
CallableStatement, 它继承自PreparedStatement, 用来执行数据库中的存储过程
Statement对象用于执行一条静态的SQL语句并获取它产生的结果，任何时候每条语句仅能打开一个ResultSet, ResultSet是语句执行后返回的记录结果集
Statement类的常用方法：
cancel(): 用于一个线程取消另一个线程正在执行的一条语句
close(): 用来关闭语句，同时立即释放该语句的数据库和JDBC资源，如果它有相应产生的ResultSet, 则ResultSet也会被关闭
execute(): 执行一条可能返回多个结果的SQL语句，返回一个布尔值，如果下一个结果是ResultSet, 则返回true, 如果它是一个更新数量或没有其他结果，则返回false, 调用方法如下：
StatementObjName.execute(String sqlString); # 其中sqlString是一个SQL语句
StatementObjName.executeQuery(String sqlString); # 执行一个返回单个ResultSet的SQL语句，返回值是由查询SELECT产生的数据集ResultSet
StatementObjName.executeUpdate(String sqlString); # 执行一条INSERT、UPDATE或DELETE语句或是没有返回值的SQL语句，返回语句影响的行数，如果没有影响的行数则返回0
StatementObjName.getResultSet(); # 得到当前的ResultSet结果
StatementObjName.getUpdateCount(); # 得到更新的数量，如果结果是一个ResultSet或没有其他结果，则返回-1，返回值是int型数据
PreparedStatement类对象封装一条预编译的SQL语句，可用于高效地多次执行该语句，其常用方法：
PreparedStatementObjectName.clearParamenters(); # 立即释放当前参数值使用的资源
PreparedStatementObjectName.execute(); # 执行一条可能返回多个结果的SQL语句，返回一个布尔值，如果下一个结果是ResultSet, 则返回true, 如果它是一个更新数量或没有其他结果，则返回false
PreparedStatementObjectName.executeQuery(); # 执行准备好的SQL查询SELECT并返回ResultSet
PreparedStatementObjectName.executeUpdate(); # 执行一条INSERT、UPDATE或DELETE语句或是没有返回值的SQL语句，返回语句影响的行数，如果没有影响的行数则返回0
PreparedStatementObjectName.setBoolean(int parameterIndex, boolean x); # 设置一个参数的布尔值，驱动程序把该值发送到数据库时，将该值转换为一个BIT值，其中，parameterIndex是参数的索引号，第一个参数是1，第二个参数是2..., x是对应这个参数的布尔值
PreparedStatementObjectName.setByte(int parameterIndex, byte x); # 设置一个参数的字节值，当驱动程序把该值发送到数据库时，将该值转换为一个tinyint值
PreparedStatementObjectName.setBytes(int parameterIndex, byte x[]); # 设置一个参数的字节数组值，当驱动程序把该值发送到数据库时，将该值转换为integer值
PreparedStatementObjectName.setDate(int parameterIndex, Date x); # 设置一个参数的日期值，当驱动程序把该值发送到数据库时，将该值转换为一个date值
PreparedStatementObjectName.setDouble(int parameterIndex, double x); # 设置一个参数的双精度值，当驱动程序把该值发送到数据库时，将该值转换为一个double值
PreparedStatementObjectName.setFloat(int parameterIndex, float x); # 设置一个参数的单精度值
PreparedStatementObjectName.setInt(int parameterIndex, int x); # 设置一个参数的整型值
PreparedStatementObjectName.setShort(int parameterIndex, short x); # 设置一个参数的short值
5. ResultSet
ResultSet类可用来接收执行SQL查询语句后得到的记录集，用它的get方法可得到记录中不同列的数据，用它的next()方法可把当前记录指针往下移动一行
ResultSet类的常用方法：
ResultsetObjectName.absolute(int row); # 移动记录指针到指定的行，参数row如果是正数，则从记录的开始起移动指定的行数，如果为负数则表示倒数，该方法返回一个布尔值，当移动到第一行的前面或最后一行的后面时返回false
ResultsetObjectName.afterLast(); # 移动当前记录指针至最后一行的后面
ResultsetObjectName.beforeFirst(); # 移动当前记录指针至第一行的前面
ResultsetObjectName.close(); # 立即释放该语句的数据库和JDBC资源
ResultsetObjectName.first(); # 移动当前记录指针至第一行
ResultsetObjectName.getBoolean(int columnIndex);
或
ResultsetObjectName.getBoolean(String columnIndex); # 把当前行的列值作为一个Boolean值获取，如果列值为空则返回false
ResultsetObjectName.getByte(int columnIndex);
或
ResultsetObjectName.getByte(String columnName); # 把当前行的列值作为一个Byte值获取，如果列值为空则返回null
ResultsetObjectName.getBytes(int columnIndex);
或
ResultsetObjectName.getBytes(String columnName); # 把当前行的列值作为一个Byte值获取，如果列值为空则返回null
ResultsetObjectName.getDate(int columnIndex);
或
ResultsetObjectName.getDate(String columnName); # 把当前行的列值作为一个Date值获取，如果列值为空则返回null
ResultsetObjectName.getDouble(int columnIndex);
或
ResultsetObjectName.getDouble(String columnName); # 把当前行的列值作为一个Double值获取，如果列值为空则返回0
ResultsetObjectName.getFloat(int columnIndex);
或
ResultsetObjectName.getFloat(String columnName); # 把当前行的列值作为一个Float值获取，如果列值为空则返回0
ResultsetObjectName.getInt(int columnIndex);
或
ResultsetObjectName.getInt(String columnName); # 把当前行的列值作为一个Int值获取，如果列值为空则返回0
ResultsetObjectName.getLong(int columnIndex);
或
ResultsetObjectName.getLong(String columnName); # 把当前行的列值作为一个Long值获取，如果列值为空则返回0
ResultsetObjectName.getRow(); # 移动当前记录指针所指向的行号，行号从1开始，如果记录集中没有记录则返回0
ResultsetObjectName.getShort(int columnIndex);
或
ResultsetObjectName.getShort(String columnName); # 把当前行的列值作为一个Short值获取，如果列值为空则返回0
ResultsetObjectName.getString(int columnIndex);
或
ResultsetObjectName.getString(String columnName); # 把当前行的列值作为一个String值获取，如果列值为空则返回null
ResultsetObjectName.isAfterLast(); # 判断当前记录指针是否在最后一行之后
ResultsetObjectName.isBeforeFirst(); # 判断当前记录指针是否在第一行之前
ResultsetObjectName.isFirst(); # 判断当前记录指针是否在第一行
ResultsetObjectName.isLast(); # 判断当前记录指针是否在最后一行
ResultsetObjectName.last(); # 移动当前记录指针到最后一行
ResultsetObjectName.next(); # 把当前记录指针往下移动一行，ResultSet初始定位于它的第一行之前，如果当前行有效，返回true，如果没有更多的行则返回false
ResultsetObjectName.previous(); # 把当前记录指针向上移动一行，当移动到第一行之前时返回false, 否则返回true
5.4 数据库事务处理
1. 数据查询
Statement stmt=conn.createStatement(int type, int concurrency); # 创建语句对象
String sql="select * from tablename where expression";
ResultSet rs=stmt.executeQuery(sql); # 获得查询结果集
2. 数据更新
Statement stmt=conn.createStatement(int type, int concurrency); # 创建语句对象
String sql="sqlStatement";
int number=stmt.executeUpdate(sql); # 执行更新
需要说明的是：
在数据查询、数据更新事务中，一般采用无参的createStatement()方法创建语句对象，如果事务是随即查询、游动查询或用结果集更新数据库，则应采用带参数的createStatement(int type, int concurrency)方法创建语句对象，其中:
type的取值决定滚动方式，即结果集中的游标是否能上下滚动
ResultSet.TYPE_FORWORD_ONLY: 表示结果集的游标只能向下滚动
ResultSet.TYPE_SCROLL_INSENSITIVE: 表示结果集的游标可以上下移动，当数据库变化时，当前结果集不变
ResultSet.TYPE_SCROLL_SENSITIVE: 表示返回可滚动的结果集，当数据库变化时，当前结果集同步改变
concurrency的取值决定是否能用结果集更新数据库
ResultSet.CONCUR_READ_ONLY: 表示不能用结果集更新数据库中的表
ResultSet.CONCUR_UPDATABLE: 表示能用结果集更新数据库中的表

第6章  JSP中Bean的使用
6.1 Bean的概念
Bean本身是遵循一定规范的Java类，是一个可以重复使用的组件
Bean作为类必须遵循的规范：
Bean必须是public类
Bean必须有一个共有的无参构造方法
Bean必须实现接口Serializable或Externalizable,以确保组件的持续性
6.2 编写Bean
为了让JSP引擎知道Bean的属性和方法，Bean的方法命名必须遵守以下规则：
1. 假设Bean类的成员变量名是xxx，则访问该变量的两个方法命名为：
getXxx(): 获取xxx的值
setXxx(): 设置xxx的值
2. 若成员变量xxx是布尔类型，则只有一个访问方法，其命名是:
isXxx()
部署Bean:
1. 给Bean起包名small.dog
2. 把编译后的字节码文件Triangle.class复制到存放Bean的目录下，即/usr/local/src/apache-tomcat-9.0.0.M9/webapps/ROOT/WEB-INF/classes/small/dog目录中
6.3 JSP使用Bean
1. 将Bean字节码存放在正确的目录中
(1) 将Bean字节码文件存放在公有目录中，Tomcat5.0/common/classes
(2) 将Bean字节码文件存放在私有目录中，test/WEB-INF/classes, 只有test目录下的JSP页面才能访问
2. 在JSP页面中使用动作标签useBean获得一个Bean对象
<jsp:useBean id = "boy" class = "small.dog.Circle" scope = "session">
</jsp:useBean> # 其中，id为Bean对象名，class为类名，scope为作用域，默认是page, 取值为request时，Bean只对当前用户的请求有效，Bean的生命周期是在客户请求开始到对请求作出响应这段时间，取值为page时，Bean在当前页有效，Bean的生命周期是客户进入页面到客户离开这个页面这段时间，取值为session时，Bean在当前Web目录下的所有页面有效，Bean的生命周期是客户访问Web目录到客户离开这个Web目录这段时间，取值为application时，Bean在所有的页面有效，Bean的生命周期是从Bean分配给客户到服务器关闭这段时间
6.4 访问Bean属性
访问Bean属性值的方法有两种：第一种方式，通过Bean的方法访问Bean的属性值；第二种方式，使用JSP动作标签访问Bean属性的值
1. 读取Bean属性值（getProperty标签）
<jsp:getProperty name = "bean的名字" property = "bean的属性名" />
2. 设置Bean属性值（setProperty标签）
<jsp:setProperty name = "bean的名字" property = "bean的属性名" value = "<%expression%>" /> # 使用字符串或表达式直接给Bean属性赋值
<jsp:setProperty name = "bean的名字" property = "*" /> # 不具体指定每个Bean属性的名字，系统会自动根据表单中数据组件名字与Bean的成员变量名字一一对应赋值
<jsp:setProperty name = "bean的名字" property = "属性名字" param = "参数名字" /> # 要求表单中提供参数的数据组件名与setProperty标签中的param属性值名称相同

第7章  Servlet技术
7.1 什么是Servlet
Servlet是用Java编写的服务器端程序，是由服务器端调用和执行的、按照Servlet自身规范编写的Java类
7.3 Servlet的生命周期
Servlet的生命周期概括为以下几个阶段：
1. 装载Servlet
2. 调用Servlet的init()方法
3. 调用service()方法
4. 服务器调用destroy()方法
7.4 部署一个Servlet
Servlet文件ServletTest.java目录：/usr/local/src/apache-tomcat-9.0.0.M9/webapps/ROOT/WEB_INF/classes/servlettest/ServletTest.java
在WEB-INF/Web.xml文件中添加如下内容：
<servlet>
    <servlet-name>servlettest</servlet-name>
        <servlet-class>servlettest.ServletTest</servlet-class>
</servlet>
<servlet-mapping>
        <servlet-name>servlettest</servlet-name>
        <url-pattern>/ServletTest</url-pattern>
</servlet-mapping>
在浏览器中输入：http://localhost:8080/ServletTest

第8章  JSTL应用开发
8.1 JSTL技术概述
JSTL:JSP Standard Tag Library, JSP标准标签库
JSTL标签库中的标签主要有如下5类：
1. 核心标签库
2. XML操作标签库
3. 格式化/国际化标签库
4. 数据库操作标签库
5. 函数标签库
安装JSTL：
http://jakarta.apache.org/site/downloads_taglibs-standard.cgi
解压缩，将lib目录下的jstl.jar和standard.jar复制到WEB-INF/lib目录下
8.2 表达式相关标签
需在JSP页面首部加入：
<%@taglib prefix = "c" uri = "http://java.sun.com/jsp/jstl/fmt"%>
8.2.1 <c:out>
<c:out>标签用于把表达式计算的结果输出到JSP页面中，语法格式为：
<c:out value = "Expression" [escapeXml = "true|false"] [default = "defaultValue"]/> # 没有body的形式，在default属性中设置要输出的默认值
<c:out value = "Expression" [escapeXml = "true|false"]> defaultValue </c:out> # 有body的形式，body中的内容就是要输出的默认值，当Expression为null时，输出默认值
escapeXml为默认值true时，转换字符"<", ">", "'", "&", """为实体代码，设置为false时则不转换
特殊字符转换对应情况：
字符    实体代码
<    &lt;
>    &gt;
'    &#039;
"    &#034;
&    &amp;
8.2.2 <c:set>
<c:set>标签用于在某个范围(request, page, session, application) 中设置某个值，调用方法为：
<c:set value = "Expression" var = "varName" [scope = "{request|page|session|application}"]/> # 设置范围scope(默认值page)中变量var的值为value
<c:set var = "varName" [scope = "{request|page|session|application}"]>valueExpression</c:set> # 同上
<c:set value = "Expression" target = "targetName" property = "propertyName"/> # 设置变量target的属性property的值为value
<c:set target = "targetName" property = "propertyName">valueExpression</c:set> # 同上
8.2.3 <c:remove>
<c:remove>标签用于删除某个范围(request, page, session, application)中设置的某个值，调用方法如下：
<c:remove var = "varName" [scope = "{page|request|session|application}"]/> # 其中scope默认值为page
8.2.4 <c:catch>
<c:catch>标签用于捕获嵌套在它里面的程序代码抛出的异常，从而进行相应的处理，调用方法如下：
<c:catch [var = "varName"]>
    需要捕获异常的标签语句、Java程序、HTML代码等
</c:catch> # 其中，var用于标识捕获的异常
8.3 流程控制标签
8.3.1 <c:if>
<c:if>标签用于条件判断，语法如下：
<c:if test = "testBooleanExpression" [var = "varName"] [scope = "{request|page|session|application}"]/>
<c:if test = "testBooleanExpression" [var = "varName"] [scope = "{request|page|session|application}"]>testBooleanExpression为真时执行的语句、Java程序、HTML代码等
</c:if> # 其中var接收testBooleanExpression的结果true或false, scope为var的有效范围
8.3.2 <c:choose>与<c:when>, <c:otherwise>
<c:choose>标签类似于Java中的switch语句
<c:choose>
    ...
    <c:when test = "testBooleanExpression">
        testBooleanExpression为真时执行的语句、Java程序、HTML代码等
    </c:when>
    ...
    [<c:otherwise>
        标签语句、Java程序、HTML代码等
    </c:otherwise>
    ...]
</c:choose> # 其中，<c:when>标签可以有一个或多个，<c:otherwise>可以有0个或多个，当多个<c:when>标签为真时，则只执行最前一个
8.4 迭代标签
<c:forEach>标签类似于Java中的for循环
<c:forEach [var = "varName"] item = "collection" [varStatus = "varStatusName"] [begin = "begin"] [end = "end"] [step = "step"]>
    标签语句、Java程序、HTML代码等
</c:forEach> # 第一种形式用于在集合collection中进行迭代，begin, end 为集合中元素的下表值
<c:forEach [var = "varName"] [varStatus = "varStatusName"] [begin = "begin"] [end = "end"] [step = "step"]>
    标签语句、Java程序、HTML代码等
</c:forEach> # 第二种形式用于迭代固定次数，varStatus中存放当前迭代的状态信息主要有4个属性，index当前索引号, count当前迭代的次数, first当前是否是第一次迭代, last当前是否是最后一次迭代
8.4.2 <c:forTokens>
<c:forTokens>标签用于处理由某一符号分隔的字符串，从其中拆分出子字符串
<c:forTokens items = "stringOfTokens" delims = "delimeters" [var = varName] [varStatus = "varStatusName"] [begin = "begin"] [end = "end"] [step = "step"]>
    标签语句、Java程序、HTML代码等
</c:forTokens> # items是进行处理的字符串，delims是拆分处理的分隔符，var用来存放当前迭代到所指向的成员值，varStatus存放当前迭代的状态信息
8.5 URL相关标签
8.5.1 <c:import>与<c:param>
<c:import url = "urlString" [context = "context"] [var = "varName"] [scope = request|page|session|application] [charEncoding = "charEncoding"]>
    [<c:param>标签语句]
</c:import> # 第一种形式，把文件的内容以String类型存入变量var中
<c:import url = "urlString" [context = "context"] [varReader = "varReaderName"] [charEncoding = "charEncoding"]>
    [<c:param>标签语句]
</c:import> # 第二种形式，把文件的内容以Reader类型的方式向外暴露出来，以供读取
url可以是网址，也可以是服务器上文件，如果以"/"开头，表示相对Web服务器的根目录的路径；<c:param>标签语句用于向导入的页面中传入参数
8.5.2 <c:redirect>
<c:redirect>标签用于把客户端发来的请求重定向到另一个页面
<c:redirect url = "urlString" [context = "context"]/>
<c:redirect url = "urlString" [context = "context"]>
    [<c:param>标签语句]
</c:redirect> # 可以向目标URL通过<c:param>标签带入参数, context用于当要重定向目标网页为其他Web应用的网页时指出应用名
8.5.3 <c:url>
<c:url>标签用于生成一个URL
<c:url value = "urlString" [context = "context"] var = "varName" [scope = "{page|request|session|application}"]/>
<c:url value = "urlString" [context = "context"] var = "varName" [scope = "{page|request|session|application}"]>
    [<c:param>标签语句]
</c:url> # 可通过<c:param>标签语句增加URL中的参数，value是要生成的URL，context用于URL为其他Web应用中的网页情况，它指出应用名，var是存入生成的URL字符串的变量名称
8.6 国际化格式标签库
需在JSP页面首部加入：
<%@taglib prefix = "fmt" uri = "http://java.sun.com/jsp/jstl/fmt"%>
8.6.1 <fmt:setLocale>标签用于设置用户的语言国家(或地区)
<fmt:setLocale value = "localecode" [variant = "variant"] [scope = "{page|request|session|application}"]/> # localecode是语言代码，variant设置浏览器类型
常用国家或地区代码：
代码    名称
en    英文
en_US    英文(美国)
zh_TW    中文(台湾)
zh_CN    中文(中国)
zh_HK    中文(香港)
zh_SG    中文(新加坡)
fr    法语
de    德语
ja    日语
vi    越南语
ko    朝鲜语
8.6.2 <fmt:requestEncoding>
<fmt:requestEncoding>标签用于设置请求中数据的字符集
<fmt:requestEncoding value = "charsetName" /> # value为要设置的字符集名称
8.6.3 <fmt:bundle>
<fmt:bundle>标签用于绑定数据源.properties文件，.properties文件的内容形如key=value，即键值对，通常将.properties文件放于当前应用的WEB-INF/classes目录下，这样文件就不能直接被客户端访问，安全性较高
<fmt:bundle basename = "bundleResourceName" prefix = "prefix">
    标签语句、Java程序、HTML代码等
</fmt:bundle> # basename是要绑定的数据源.properties, prefix是要获取的.properties文件的前缀
8.6.4 <fmt:message>与<fmt:param>
<fmt:message key = "messageKeyName" [bundle = "bundleResourceName"] [var = "varName"] [scope = "{page|request|session|application}"]/>
<fmt:message key = "messageKeyName" [bundle = "bundleResourceName"] [var = "varName"] [scope = "{page|request|session|application}"]>
    [<fmt:param>标签语句]
</fmt:message> # key为键名称，var用来存放取出的键值，<fmt:param>用于设定键的动态值，用法为：
<fmt:param value = "keyValue">
<fmt:param>
    keyValue
</fmt:param> # value是要设置的键值
8.6.5 <fmt:setBundle>
<fmt:setBundle>标签用来设置默认的数据源
<fmt:setBundle basename = "bundleResourceName" [var = "varName"] [scope = "{page|request|session|application}"]/> # var代表绑定的数据源
8.6.6 <fmt:formatNumber>
<fmt:formatNumber>标签用于根据设定的区域将数据格式化输出
<fmt:formatNumber value = "numbericValue" # value是要格式化的数字
[type = "number|currency|percent"] # type用于指定数字的单位，number(标准数字), currency(当地货币), percent(百分比)
[pattern = "customPattern"] # pattern设置显示模式
[currencyCode = "currencyCode"] # currencyCode设置ISO-4217码
[currencySymbol = "currencySymbol"] # currencySymbol设置货币符号
[groupingUsed = "{true|false}"] # grouningUsed设置是否在显示数字时分隔开
[maxIntegerDigits = "maxIntegerDigits"] # maxIntegerDigits设置最多的整数位
[minIntegerDigits = "minIntegerDigits"] # minIntegerDigits设置最少的整数位
[maxFractionDigits = "maxFractionDigits"] # maxFractionDigits设置最多的小数位数
[minFractionDigits = "minFractionDigits"] # minFractionDigits设置最少的小数位数
[var = "varName"] # var用于存放格式化后的数字
[scope = "page|request|session|application}"]/> # 设置var的有效范围，默认值为page
<fmt:formatNumber
[type = "number|currency|percent"]
[pattern = "customPattern"]
[currencyCode = "currencyCode"]
[maxIntegerDigits = "maxIntegerDigits"]
[minIntegerDigits = "minIntegerDigits"]
[maxFractionDigits = "maxFractionDigits"]
[minFractionDigits = "minFractionDigits"]
[var = "varName"]
[scope = "{page|request|session|application}"]>
    numbericValue
</fmt:formatNumber>
8.6.7 <fmt:formatDate>
<fmt:formatDate>标签用于格式化输出日期和时间
<fmt:formatDate value = "date" # value是要格式化输出的日期和时间
[type = "time|date|both"] # type设置输出的部分（日期、时间或两者）
[pattern = "customPattern"] # pattern定义日期和时间输出的模式
[dateStyle = "default|short|medium|long|full"] # dateStyle设置日期输出的格式
[timeStyle = "default|short|medium|long|full"] # timeStyle设置时间输出的格式
[timeZone = "timeZone"] # timeZone是要设定时间的时区
[var = "varName"] # var接收格式化时的日期和时间
[scope = "{page|request|session|application}"]/> # scope设置var的有效范围
常用日期和时间输出模式：
模式                示例数据
yyyy.mm.dd G 'at' HH:mm:ss z    2006.04.13 公元 at 11:21:08 CST
h:mm a                11:21 上午
Hh'时', 'a, zzzz        11时, 上午, 中国标准时间
yyMMddHHmmssZ            060413112108+0800
8.6.8 <fmt:parseDate>
<fmt:parseDate>标签用于把字符串类型的日期和时间转换成日期型数据类型
<fmt:parseDate value = "dateString"
type = "{date|time|both}"
[pattern = "customPattern"]
[dateStyle = "default|short|medium|long|full"]
[timeStyle = "default|short|medium|long|full"]
[parseLocale = "parseLocale"]
[timeZone = "timeZone"]
[var = "varName"]
[scope = "{page|request|session|application}"]/>
<fmt:parseDate
type = "{date|time|both}"
[pattern = "customPattern"]
[dateStyle = "default|short|medium|long|full"]
[timeStyle = "default|short|medium|long|full"]
[parseLocale = "parseLocale"]
[timeZone = "timeZone"]
[var = "varName"]
[scope = "{page|request|session|application}"]>
    dateString
</fmt:parseDate>
8.6.9 <fmt:parseNumber>
<fmt:parseNumber>标签用于把字符串中表示的数字、货币、百分比转换成数字数据类型
<fmt:parseNumber
value = "numbericValue"
[type = "number|currency|percent"]
[pattern = "customPattern"]
[parseLocale = "parseLocal"]
[integerOnly = "true|false"]
[var = "varName"]
[scope = "{page|request|session|application}"]/>
<fmt:parseNumber
[type = "number|currency|percent"]
[pattern = "customPattern"]
[parseLocale = "parseLocale"]
[integerOnly = "true|false"] # 设置是否只输出整数部分
[var = "varName"]
[scope = "{page|request|session|application}"]>
    numbericValue
</fmt:parseNumber>
8.6.10 <fmt:setTimeZone>
<fmt:setTimeZone>用于设置默认的时区
<fmt:setTimeZone
value = "timeZone" # value为要设置的时区
[var = "varName"] # var接收时区设置
[scope = "{page|request|session|application}"]/>
8.6.11 <fmt:timeZone>
<fmt:timeZone>标签用于设定在本标签体内有效的时区
<fmt:timeZone value = "timeZone">
    标签语句、Java程序、HTML代码等
</fmt:timeZone>
8.7 SQL相关标签
需在JSP页面首部加入：
<%@taglib prefix = "sql" uri = "http://java.sun.com/jsp/jstl/sql"%>
8.7.1 <sql:setDataSource>
<sql:setDataSource>标签用来设定要操作的数据源
<sql:setDataSource
dataSource = "dataSource" # 已有数据源的名称
[var = "varName"] # 为建立起数据源后代表此数据源的名称
[scope = "{page|request|session|application}"]/> # 第一种方式：使用已存在的数据源
<sql:setDataSource
url = "jdbcURL" # 数据库的连接字符串
driver = "driverName" # 连接数据库驱动程序的名称
[user = "userName"]
[password = "password"]
[var = "varName"]
[scope = "{page|request|session|application}"]/> # 第二种方式：用JDBC的方式来建立起数据库连接
8.7.2 <sql:query>
<sql:query>标签用于查询数据库中的数据
<sql:query
sql = "sqlQuery" # 要查询的SQL语句
var = "varName" # 用于存放SQL查询的结果
[scope = "{page|request|session|application}"] # var的有效范围
[dataSource = "dataSource"] # 连接的数据源名称
[maxRows = "maxRows"] # 最多可存放的记录条数
[startRow = "startRow"]/> # 设置数据结果集从查询结果的第几条记录开始
<sql:query
var = "varName"
[scope = "{page|request|session|application}"]
[dataSource = "dataSource"]
[maxRows = "maxRows"]
[startRow = "startRow"]>
    sqlQuery
</sql:query>
查询结果存放在var中，var共有5个属性：
1. rows: 以字段名称来读取查询结果记录集
2. rowsByIndex:
3. columnNames: 字段名称集
4. rowCount: 查询结果记录集中记录的条数
5. limitByMaxRows: 如果查询到的记录条数大于maxRows时，值为true, 否则为false
8.7.3 <sql:dateParam>与<sql:param>
<sql:dataParam>与<sql:param>标签用于设置SQL语句中的动态值
<sql:param value = "value"/> # value是要设置的动态参数的值
<sql:param> value </sql:param>
<sql:dataParam value = "value" [type = "{timestamp|time|date}"]/> # timestamp表示日期和时间
例如：
<sql:query var = "rs">
    select * from userTable where username = ? and password = ?
    <sql:param value = "${username}"/>
    <sql:param value = "${password}"/>
</sql:query>
8.7.4 <sql:update>
<sql:update>标签用于修改数据库中的数据
<sql:update
sql = "sqlUpdate" # 更新数据库的SQL语句
[var = "varName"] # 存放数据库更新的记录条数
[scope = "{page|request|session|application}"] # var的有效范围
[dateSource = "dateSource"]/>
<sql:update
[var = "varName"]
[scope = "{page|request|session|application}"]
[dateSource = "dateSource"]>
    sqlUpdate
</sql:update>
8.7.5 <sql:transatciton>
<sql:transaction>标签可保证其间的<sql:query>和<sql:update>标签语句修改数据库时的事务一致性
<sql:transaction
    [dataSource = "dataSource"]
    [isolation = "{read_uncommitted|read_committed|repeatable_read|serializable}"] # 设置事务的级别
    [<sql:query>标签语句或<sql:update>标签语句]
</sql:transaction>
8.8 XML标签
需在JSP文件首部加入：
<%@taglib prefix = "x" uri = "http://java.sun.com/jsp/jstl/xml"%>
8.8.1 XPath
XPath的含义是指UNIX操作系统下的目录
用XPath方式表示XML文件中的内容：
位置            表示方式
根元素            /
文件元素        ./
父结点            ../
子结点            结点名称
兄弟结点        ../结点名称
所有同一名称的结点    //结点名称
属性            @属性名称
全局            *
8.8.2 <x:parse>
<x:parse>标签用来解析XML文件
<x:parse
{doc = "XMLDocument" | xml = "XMLDocument"} # 要解析的XML文件内容
{var = "varName" | [scope = "{page|request|session|application}"] | varDom = "varName" [scope = "{page|request|session|application}"]} # 存放解析后的XML文件，如果为varDom，则类型为org.w3c.dom.Document
[sustemId = "systemId"] # XML文件的URI
[filer = "filer"]/> # 一个org.xml.sax.XMLFilter过滤器
<x:parse
{var = "varName" [scope = "{page|request|session|application}"] | varDom = "varName" [scope = "{page|request|session|application}"]}
[sustemId = "systemId"]
[filer = "filer"]>
    XMLDocument
</x:parse>
8.8.3 <x:out>
<x:out>标签用于根据XPath表达式，输出XML文件中对应的内容
<x:out select = "XPathExpression" [escapeXML = "{true|false}"]/> # select为XPath表达式，escapeXML默认值为true
8.8.4 <x:set>
<x:set>标签用于把XML文件中的部分内容存放到一个变量中
<x:set
select = "XPathExpression"
var = "varName"
[scope = "{page|request|session|application}"]/> # select为XPath表达式，var存放从XML文件中取出的内容
8.8.5 <x:if>
<x:if>标签用于对XPath表达式作出判断
<x:if
select = "XPathExpression"
var = "varName"
[scope = "{page|request|session|application}"]/>
<x:if
select = "XPathExpression" # 要判断的XPath表达式
var = "varName" # 存放XPath表达式的结果
[scope = "{page|request|session|application}"]>
    XPathExpression为真时执行的标签语句、Java程序、HTML代码等
</x:if>
8.8.6 <x:choose>, <x:when>和<x:otherwise>
<x:choose>
    <x:when>和<x:otherwise>语句
</x:choose>
<x:when select = "XPathExpression">
    标签语句、Java程序、HTML代码等
</x:when>
8.8.7 <x:forEach>
<x:forEach select = "XPathExpression" [var = "varName"] [varStatus = "varStatusName"] [begin = "begin"] [end = "end"] [step = "step"]>
    标签语句、Java程序、HTML代码等
</x:forEach>

第9章  过滤器与监听器
9.1 过滤器
9.1.2 相关类介绍
开发过滤器相关的应用，主要与如下的接口或类有关：
javax.servlet包中的Filter接口、FilterConfig接口、FilterChain接口、ServletRequestWrapper类、ServletResponseWrapper类
javax.servlet.http包中的HttpServletRequestWrapper类、HttpServletResponseWrapper类
1. Filter接口
Filter接口常用方法：
(1) init(): 用来初始化过滤器
public void init(FilterConfig filterConfig) throws ServletException
(2) doFilter(): 实现对请求和响应中数据的处理
public void doFilter(ServletRequest request, ServletResponse response, FilterChain chain) throws java.io.IOException, ServletException # request代表客户端的请求，response代表对请求的响应，chain是过滤器链对象
(3) destroy(): 用于释放过滤器中使用的资源
2. FilterConfig接口
FilterConfig接口用于在过滤器初始化时向过滤器传递一些信息，接口方法有：
(1) getFilterName(): 用于得到过滤器的名字
public String getFilterName()
(2) getInitParameter(): 得到Web应用的配置文件中配置的过滤器初始化参数值
public String getInitParameter(String name) # name为初始化参数的名字
(3) getInitParameterNames(): 得到过滤器配置的所有初始化参数名字的枚举集合
public Enumeration getInitParameterNames()
(4) getServlet(): 得到Servlet上下文件对象
public ServletContext getServlet()
3. FilterChain接口
此接口只有一个方法：
public void doFilter(ServletRequest request, ServletResponse response) throws java.io.Exception, ServletException # 将使用过滤器链的下一个过滤器继续工作
9.1.3 开发与部署方法
2. 部署过滤器
在Web应用的web.xml文件中配置过滤器，配置方法如下：
<!--过滤器配置-->
<filter>
    <filter-name>过滤器的名称</filter-name>
    <filter-class>过滤器的实现类</filter-class>
    <!--过滤器的初始化参数-->
    <init-param>
        <param-name>参数名称</param-name>
        <param-value>对应的参数值</param-value>
    </init-param>
</filter>
<!--过滤器映射-->
<filter-mapping>
    <filter-name>过滤器的名称</filter-name>
    <url-pattern>URL样式</url-pattern>
    或
    <servlet-name>servlet名称</servlet-name>
    <dispatcher>请求方式</dispatcher> # 请求方式有REQUEST、INCLUDE、FORWARD、ERROR四种，默认为REQUEST
</filter-mapping>
9.2 监听器
用监听器可以监听Web容器中正在执行的程序，根据发生的事件作出特定的响应
9.2.2 开发与部署方法
在Web应用的web.xml文件中配置监听器：
<!--监听器配置-->
<listener>
    <listener-class>
        listener.myServletContextListener
    </listener-class>
</listener> # listener元素位于所有的servlet元素之前，以及所有filter-mapping元素之后
9.2.3 ServletContext监听器
其生命周期如同隐含对象application
1. ServletContextListener接口
(1) abstract public void contextInitialized(ServletContextEvent arg) # 通知监听器Web应用已经加载和初始化
(2) abstract public void contextDestroyed(ServletContextEvent arg) # 通知监听器已关闭Web应用
2. ServletContextAttributeListener接口
(1) abstract public void attributeAdded(ServletContextAttributeEvent arg) # 通知监听器一个对象或变量被加入到application范围
(2) abstract public void attributeReplaced(ServletContextAttributeEvent arg) # 通知监听器一个对象或变量被更改
(3) abstract public void attributeRemoved(ServletContextAttributeEvent arg) # 通知监听器一个对象或变量被删除
9.2.4 HttpSession监听器
其生命周期如同隐含变量session
1. HttpSessionBindingListener接口
(1) abstract public void valueBound(HttpSessionBindingEvent event) # 通知监听器已绑定一个session范围的对象或变量
(2) abstract public void valueUnbound(HttpSessionBindingEvent event) # 通知监听器已对一个session范围的对象或变量解除绑定
2. HttpSessionAttributeListener接口
(1) abstract public void attributeAdded(HttpSessionBindingEvent event) # 通知监听器已加入一个session范围的对象或变量
(2) abstract public void valueReplaced(HttpSessionBindingEvent event) # 通知监听器已更改一个session范围的对象或变量
(3) abstract public void valueRemoved(HttpSessionBindingEvent event) # 通知监听器已删除一个session范围的对象或变量
3. HttpSessionListener接口
(1) abstract public void sessionCreated(HttpSessionEvent event) # 通知监听器产生一个新的会话
(2) abstract public void sessionDestroyed(HttpSessionEvent event) # 通知监听器消除一个会话
4. HttpSessionActivationListener接口
(1) abstract public void sessionDidActivate(HttpSessionEvent event) # 通知监听器会话已变为有效状态
(2) abstract public void sessionWillPassivate(HttpSessionEvent event) # 通知监听器会话已变为无效状态
9.2.5 ServletRequest监听器
1. ServletRequestListener接口
可对请求的产生和消除进行监听
(1) abstract public void requestInitialized(ServletRequestEvent event) # 通知监听器一个请求对象已被加载
(2) abstract public void requestDestroyed(ServletRequestEvent event) # 通知监听器一个请求对象已被消除
2. ServletRequestAttributeListener接口
可对request范围的对象或变量的变化进行监听
(1) abstract public void attributeAdded(ServletRequestAttributeEvent event) # 通知监听器已加入一个request范围的对象或变量
(2) abstract public void attributeReplaced(ServletRequestAttributeEvent event) # 通知监听器已更改一个request范围的对象或变量
(3) abstract public void attributeRemoved(ServletRequestAttributeEvent event) # 通知监听器已删除一个request范围的对象或变量