JavaEE复习资料(2)_JSP&Servlet

注：以下信息是从各种渠道收集来的信息进行整合！！！

第一部分 开发环境和配置概述

JavaEE复习资料(1)_开发环境和配置概述

第二部分 Jsp&Servlet

第1章 JDBC

1. JDBC简介

1.1 JDBC中主要接口

java.sql.DriverManager：处理驱动程序的调入和管理
java.sql.Connection：负责连接数据库
java.sql.Statement：负责执行数据库 SQL 语句
java.sql.ResultSet：负责存放查询结果

2 JDBC使用

2.1 JDBC操作

1. 加载驱动程序——Class.forName()
2. 建立数据库连接——DriverManager.getConnection()
3. 创建SQL容器——createStatement()
4. 使用SQL容器执行SQL语句——executeQuery()、executeUpdate()、execute()
5. 处理结果——next()、get…()
6. 关闭结果集、容器、数据库连接——close()

JSP示例：

<%@ page language="java" import="java.util.*" pageEncoding="GB2312"%>
<%@ page import="java.sql.*"%>
<%
    String url ="jdbc:mysql://localhost:3306/school"; 	// 数据库连接字符串 
    String sql="select * from teacher";   				// SQL语句
    
    Class.forName(" com.mysql.jdbc.Driver ");  			// 加载驱动程序
    Connection conn = DriverManager.getConnection(url,"root","dba");  // 建立连接
    Statement stmt = conn.createStatement();   			// 创建SQL容器
    ResultSet rs = stmt.executeQuery(sql);   			// 获得结果集  
    
    while( rs.next() ) {   		// 处理结果集
        out.print(rs.getString("id")+"  ");
        out.print(rs.getString("name")+"  ");
        out.print(rs.getString("address")+"  ");
        out.print(rs.getString("year")+"<br>");
    }
    
    // 关闭
    rs.close();     
    stmt.close();    
    conn.close();   
    %>

2.2 带参数的查询语句

  PreparedStatement 是 Statement 的子接口，功能与 Statement 类似，它在 sql 语句中使用了?代替了需要插入的参数。
  用 PreperedStatement 的 setString(n,参数)方法可以将第 n （n从1开始）个?用传进的参数代替。这样做增加了程序的可维护性，也增加了程序的安全性。

示例：

	String sql="select * from 表 where 字段=?";
	PreparedStatement  pStmt = conn.prepareStatement(sql); 
	pStmt.setString(1, parm1);
	ResultSet rs= pStmt.executeQuery( );  

2.3 JDBC事务管理

Connection类的3个控制事务的方法：

  setAutoCommit(boolean autoCommit): 设置是否自动提交事务，默认自动提交事务
  commit(): 提交事务
  rollback(): 回滚事务

注：JDBC API中默认：每条更新语句是一项事务，是自动提交事务

示例：

try{
	……
	con=DriverManager.getConnection(dburl,dbuser,dbpassword);
    con.setAutoCommit(false);
    stmt=con.createStatement();
    stmt.executeUpdate(sql1);
    stmt.executeUpdate(sql2);
    con.commit();
}
catch(SQLException e){
     e.printStackTrace();
     try{
     	con.rollback();
     }
     catch(SQLException ex){
     	System.out.println(“回滚失败”);
     }
}
finally{
    try{
    	stmt.close();
    	con.close()
    }
    catch(SQLException e){  
    	System.out.println(“关闭资源失败”);  
    }
}

第2章 Web应用和JSP

1. B/S结构和C/S结构简介

B/S结构：请求 / 响应架构
C/S结构：客户端 / 服务器架构
区别：
  收集用户输入数据的方式不一样；
  状态是不连续的。请求/响应的架构只有当客户端发出请求时，服务器才可生成响应，服务器无法主动更新客户端状态；
  生成显示时，服务器只能生成HTML标签，由浏览器根据HTML标签显示。

2. Web应用结构

  Java Web 应用的文件结构，必须要有个 WEB-INF目录 ，下面有 classes子目录 (存放 java 编译后的 class 文件)、lib 子目录（存放一些数据库驱动、第三方框架等 jar 文件）、web.xml（web 最重要的配置文件，主要配置 servlet、filter、listener 和首页等）。

3. JSP技术原理

1. JSP是Servlet的一种特殊形式，每个JSP页面就是一个Servlet实例(默认情况下只实例化一次)。JSP页面由系统编译成Servlet， Servlet再负责响应用户请求。
2. 使用JSP时，其实还是使用Servlet，因为Web应用中的每个JSP页面都会由Servlet容器生成对应的Servlet。
3. JSP 文件必须在 JSP 服务器内运行。
4. JSP文件必须生成Servlet才能执行。
5. 每个JSP页面的第一个访问者速度很慢，因为必须等待JSP编译成Servlet。（懒加载）
6. JSP页面的访问者无须安装任何客户端，甚至不需要可以运行 Java的运行环境，因JSP页面输送到客户端的是标准HTML页面。

第3章 JSP基本语法

JSP注释：<%– 注释内容 –%>    HTML注释：<!– 注释内容 –>
JSP声明：<%! 声明部份 %>    —— 相当于将代码写到类中
JSP输出表达式：<%=表达式%>
JSP脚本：<% 脚本代码部分 %>    —— 相当于将代码写到方法中

1. JSP注释

JSP注释的格式如下：

  <%-- 注释内容 --%>

JSP注释是不会输出到客户端的。
与JSP注释形成对比的是HTML注释，HTML注释的格式是：

  <!-- 注释内容 -->

HTML的注释内容会发送到客户端的。

2. JSP声明语法

2.1 JSP声明

JSP声明语法如下：

  <%! 声明部份 %>

声明部分的变量可以使用访问控制符，如private、protected、public等修饰。
声明部分可以定义方法。
声明部分可以使用static修饰。
声明部分可以定义内部类。

2.2 JSP声明与Servlet的关系

  JSP声明可以声明变量、方法，并且会转换成Servlet的成员变量或成员方法。

  JSP页面会编译成一个Servlet类，每个Servlet在容器中只有一个实例；而在JSP中声明的变量是类的成员变量，成员变量只在创建实例时初始化，该变量值将一直保存，直到实例销毁。

3. 输出表达式

JSP提供了一种输出表达式值的简单方法，输出表达式的格式如下：

  <%=表达式%>

上面的表达式等同于<%out.print(表达式);%>，生成的Servlet里代码完全相同。

4. JSP脚本

4.1 JSP脚本简介

JSP脚本最常用，功能比较强大；
JSP脚本的应用非常广泛，可通过Java代码镶嵌在HTML代码中，即使用JSP脚本；
所有能在Java程序中执行的代码，都可以通过JSP脚本执行，包括连接数据库和执行数据库操作。

JSP脚本语法格式如下：

  <% 脚本代码部分 %>

4.2 JSP脚本与Servlet的关系

  JSP脚本部分对应Servlet类里的_jspService方法里的执行代码；JSP页面中的HTML部分的静态内容可由_jspService方法的输出语句输出到页面中。

4.3 JSP脚本规则

1. JSP脚本可以定义变量，定义的变量都是局部变量；
2. JSP脚本中的变量是局部变量，不能使用访问控制符修饰；
3. JSP脚本中不允许定义方法；
4. JSP脚本中不可以使用static修饰；
5. JSP脚本中不可以定义内部类。

第4章 三个编译指令

1 JSP的编译指令

  JSP的编译指令是通知JSP引擎的消息，它不直接生成输出。
  编译指令都有默认值，因此开发人员无须为每个指令设置值。
常见的编译指令有三个：

page：该指令是针对当前页面的指令。
include：用于指定如何包含另一个页面。
taglib：用于定义和访问自定义标签。

2 JSP编译指令的语法

JSP编译指令的语法格式如下：
<%@ 编译指令名 属性名=“属性值”…… %>

3 page指令

  page指令，通常位于JSP页面的顶端，同一个页面可以有多个page指令。
page指令的语法格式如下：

<%@ page
[import=“package.*,……”] 可以用逗号隔开各 api
[contentType=“text/html; charSet=utf-8”]
[pageEncoding=“utf-8”]
%>

其中，常用的属性如下：
import：用于导包(API)的。
contentType: 用于设定生成网页的文件格式和编码方式，默认的字符集为ISO-8859-1,一般需要改成 utf-8。
pageEncoding：设置 jsp 页面存储的编码，默认的字符集为 ISO-8859-1,一般需要改成 utf-8。

示例：

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

4 include指令

  使用include指令，可以将一个外部文件嵌入到当前JSP文件中，同时解析这个页面中的JSP语句（如果有的话）。

这是个静态的include语句，其特征如下：

1. 会导入目标页面的编译指令。
2. 目标页面的代码会完全融入本页面。

include编译指令的语法格式如下：
<%@ include file=“relativeURLSpec” %>

注意：如果两个页面的编译指令不一样，就会出错

示例：

<%@ include file="../../include/admin/adminHeader.jsp"%>

5 taglib指令

  tablib指令是用于定义和访问自定义标签的。

使用标签库分成以下两步：
  导入标签库：使用taglib编译指令导入标签。
  使用标签：在JSP页面中使用自定义标签。

taglib编译指令的语法格式如下：

<%@ taglib uri=“tagliburi” prefix=“tagPrefix” %>

uri属性确定标签库定义文件的URI，这个URI就是在web.xml文件中为标签库定义的URI。
prefix属性确定的是标签前缀，即在JSP页面中使用标签时，该标签库负责处理的标签前缀。

使用标签的语法格式如下：

<tagPrefix : tagName tagAttribute=“tagValue”…>
  <tagBody>
</tagPrefix>

如果该标签没有标签体，则可以使用如下语法格式：

<tagPrefix : tagName tagAttribute=“tagValue”…/>

示例：

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

...  

<c:forEach items="${orders}" var="o">

第5章 七个动作指令

动作指令与编译指令不同，编译指令是通知Servlet引擎的处理消息，而动作指令只是运行时的脚本动作。
编译指令在将JSP编译成Servlet时起作用；
动作指令通常可替换成Java脚本，是JSP脚本的标准化写法。

1. forward指令

forward指令用于将页面响应控制转发给另外的页面。
forward指令只能是一次请求有效。
forward指令即可以转发给静态的HTML页面，也可以转发到动态的JSP页面，或者转发到容器中的Servlet。

1.1 语法

<jsp:forward page =“{ relativeURL | <%=expression%>}”
  {<jsp:param …/>}
</jsp:forward>

  输出表达式相当于地址变量。
  第二种语法用于在转发时增加额外的请求参数。增加的请求参数的值可以通过HttpServletRequest类的getParameter方法获取。如下JSP页面：

<jsp:forward page="forward-result.jsp">
	<jsp:param name="age" value="29"/>
</jsp:forward>  

  如果要在forward-result.jsp页面上获取参数名为age的值，只需在其页面上增加以下代码：

<%=request.getParameter("age")%>

1.2 特征

1. 依然是一次请求；
2. 目标页面依然可访问请求参数；
3. 地址栏里请求的URL没变。

2. include指令

  include指令是一个动态include指令，是将目标页面的body部分的内容引入进来，插入到自己的页面中。
  include指令不会导入被include页面的其他编译指令。

2.1 语法

include指令的语法格式如下：

<jsp:include page=“{relativeURL | <%=expression%>}” fluse=“true”/>

或者

<jsp:include page=“{relativeURL | <%=expression%>}” fluse=“true”>
  <jsp:param name=“parameterName” value=“patameterValue”/>
</jsp:include>

flush属性用于指定输出缓存是否转移到被导入文件中。如果指定为true，则包含在被导入文件中；如果指定为false，则包含在原文件中。对于JSP1.1旧版本，只能设置为false。
对于第二种语法格式，可用于在导入页面中加入参数值。

2.2 静态include和动态include区别

静态include：

1. 导入目标页面编译指令
2. 目标页面内容融入本页面，最后形成一个页面

动态include：

1. 不会导入目标页面编译指令，只会引入目标页面body部分的内容
2. 通过一个方法来插入目标页面

2.3 include和forward的区别

1. include是用于导入某个页面；即将目标页面插入当前页面中。
2. forward是将某个页面动态导入到当前页面；用目标页面完全代替当前页面。

3. useBean指令

useBean指令用于在JSP页面中初始化一个Java实例；

3. 1 语法

<jsp:useBean id=“name” class=“classname” scope=“page | request | session | application” />

其中id属性是JavaBean的实例名，class属性确定JavaBean的实现类。
scope属性用于确定JavaBean实例的生存范围，该范围有以下四个值：

page：该JavaBean实例仅在该页面有效。
request：该JavaBean实例在本次请求有效。
session：该JavaBean实例在本次session内有效，即本次会话有效。
application：该JavaBean实例在本应用内一直有效，一个web应用里面只能有一个application对象。

4. setProperty指令

setProperty指令用于修改JavaBean实例的属性；

4.1 语法

<jsp:setProperty name=“BeanName” property=“propertyName” value=“value” />

其中name属性确定需要设定JavaBean的实例名；
property属性确定需要设置的属性名；
value属性则确定需要设置的属性值。

5. getProperty指令

getProperty用于获取、并输出JavaBean实例的属性。

5.1 语法

<jsp:getProperty name=“BeanName” property=“propertyName” />

其中name属性确定需要输出的JavaBean的实例名；
property属性确定需要输出的属性名。

6. plugin指令

  plugin指令主要用于下载服务器的JavaBean或Applet到客户端执行。由于程序在客户端执行，因此客户端必须安装虚拟机。

7. param指令

param指令用于设置参数值，这个指令本身不能单独使用，因为单独的param指令没有实际意义。

param指令可以与以下三个指令结合使用：
jsp:include
jsp:forward
jsp:plugin

当与include指令结合使用时，param指令用于将参数值传入被导入的页面；
当与forward指令结合使用时， param指令用于将参数值传入被转向的页面；
当与plugin指令结合使用时，则用于将参数传入页面中的JavaBean实例或Applet实例。

7.1 语法

<jsp:param name=“paramName” value=“paramValue” />

第6章 9个内置对象

  JSP页面中包含9个内置对象，这9个内置对象都是Servlet API的类或者接口的实例，只是JSP规范将它们完成了默认初始化，即它们已经是对象，可以直接使用。
  在JSP脚本和JSP输出表达式中可以用内置对象
  在JSP声明部分不能用内置对象。

1. application对象

  appliction对象是javax.servlet.ServletContext的实例，该实例代表JSP所属的Web应用本身，可用于JSP页面，或者Servlet之间交换信息。

  操作application范围内的属性，对应的方法是：

setAttribute(String attName, Object attValue)：将一个值放入某个属性，该属性的值对整个Web应用有效；
getAttribute(String attName)：在Web应用的每个JSP页面或Servlet都可以访问该属性。

  获取Web应用所在服务器上的物理路径，对应的方法是：

getRealPath()：获取Web应用在服务器上的物理路径。

  获取Web应用的配置参数，对应的方法是：

getInitParameter(String paramName)：获取Web应用的配置参数。
  application使用context-param元素配置参数，其中子元素param-name配置参数名， param-value配置参数值。

注意：通过这种方式，可以将一些配置信息放在web.xml文件中配置，避免使用硬编码方式写在代码中，从而更好地提高程序解耦。

2. config对象

  config: javax.servlet.ServletConfig的实例，该实例代表该JSP的配置信息。

常用的方法有getInitParameter(String paramName)及getInitParameterNames()等方法。

事实上，JSP页面通常无须配置，也就不存在配置信息。因此，该对象更多地在Servlet中有效。

3. exception对象

  exception对象是java.lang.Throwable的实例，该实例代表其他页面中的异常和错误。
只有当页面是错误处理页面，即page编译指令的isErrorPage属性为true时，该对象才可以使用。

常用的方法有** getMessage() 和printStackTrace()**等。

  如果JSP脚本出现异常，系统自动转到page编译指令errorPage所指定的页面（异常处理页面）。
如果page指令的isErrorPage为true，即错误处理页面，JSP脚本中多了一个内置对象exception。

注意： exception对象仅在错误处理页面中才有效。 exception对应于异常处理结构里catch块中所捕获的异常。

4. out对象

  out对象是javax.servlet.jsp.JspWriter的实例，该实例代表JSP页面的输出流，用于输出内容，形成HTML页面。

  out对象代表一个页面输出流，通常用于在页面上输出变量值及常量。
  一般使用输出表达式值的地方，都可以使用out对象来达到同样效果。

所有使用out的地方，都可以使用输出表达式输出的方式代替，而且使用输出表达式更加简洁。
通过out对象的系统介绍，读者可以更好地理解表达式输出的原理。

常用的方法为：out.println()

5. page对象

  page对象代表该页面本身，通常没有太大用处。也就是Servlet 中的this，用于代表该Servlet实例本身。
其类型就是生成的Servlet类。

6. pageContext对象

  pageContext对象是javax.servlet.jsp.PageContext的实例，该对象代表该JSP页面上下文，使用该对象可以访问页面中的共享数据。

  常用的方法有setServletContext()和getServletConfig()、setAttribute()、getAttribute(String name,int scope)等。

  这个对象代表页面上下文，该对象主要用于访问页面共享数据。使用pageContext可以直接访问request，session，application范围的属性。

如果使用pageContext获取各属性所在的范围，那么这些范围获取的都是整型变量，这些整型变量分别对应几个生存范围：

1. 对应page生存范围。
2. 对应request生存范围。
3. 对应session生存范围。
4. 对应application生存范围。

7. request对象

  request对象是javax.servlet.http.HttpServletRequest的实例，该对象封装了一次请求，客户端的请求参数都被封装在该对象里。

  这是一个常用的对象，获取客户端请求参数必须使用该对象。
常用的方法有：

1. getParameter(String paramName)
2. getParameterValues(String paramName)
3. setAttribute(String attributeName, Object attributeValue),
4. getAttribute(String attributeName)
5. setCharacterEncoding(String env)

  获取请求参数值是最常见的情况，一旦用户提交请求，表单的信息将会提交给对应的处理程序。
在页面中可大量使用request对象来获取请求参数的值，获取请求参数的值有如下两个方法：

• String getParameter(String paramName)：获取表单域的值。
• String[] getParameterValues(String paramName)：获取表单域的数组值。

  在获取表单域的值之前，先设置request的解码方式，因为获取的参数是简体中文，因此使用utf-8的解码方式，设置解码方式时使用如下方法：

  setCharacterEncoding(“utf-8”)：设置解码方式。

表单的提交方式一定是post。

HttpServletRequest还包含用于设置和获取请求属性的两个方法：

• void setAttribute(String attName, Object attValue)。
• Object getAttribute(String attName)。

当forward用户请求时，请求的参数和请求属性都不会丢失。

HttpServletRequest类提供了一个**getRequestDispatcher(String path)**方法，其中path就是希望forward或者include的目标路径，该方法返回RequestDispatcher该对象提供了如下两个方法：

• forward(ServletRequest request, ServletResponse response)：执行forward。
• include(ServletRequest request, ServletResponse response)：执行include。

8. response对象

  response对象是javax.servlet.HttpServletResponse的实例，代表服务器对客户端的响应。它的三个常用作用：

• 生成二进制响应。
• 执行重定向。
• 添加Cookie。

sendRedirect(String path))：重定向到某个页面

8.1 重定向和请求转发的区别

response 重定向(sendRedirect)特征：

• 两次请求；
• 目标页面不可访问上一次请求的请求参数；
• 地址栏里改为重定向的 URL，相当于重新输入地址，然后回车。

请求转发（forward）特征：

• 依然是一次请求；
• 目标页面依然可访问请求参数；
• 地址栏里请求的 URL 没变 。

8.2 使用response增加Cookie

Cookie通常用于网站记录客户的某些信息，比如客户的用户名及客户的喜好等。
增加Cookie的步骤：

• 创建Cookie实例；
• 设置Cookie的生命期限；
• 向客户端写Cookie。

Cookie不要加中文，若真要加，必须用加java.net.URLEncoder.encode来加码，用java.net.URLDecoder.decode来解码。

访问Cookie有以下两个步骤：

• 通过request对象的getCookies()方法来访问Cookie，该方法将返回Cookie的数组；
• 遍历该数组的每个元素，找出希望访问的Cookie即可。

注意：千万不要把银行帐号、密码等敏感信息写到Cookie中去。因为Cookie不安全。
使用Cookie对象必须设置其生存期限，否则Cookie将会随浏览器的关闭而自动消失。

9. session对象

  session对象是javax.servlet.http.HttpSession的实例，该对象代表一次会话。一次用户会话的含义是：从客户端浏览器连接服务器开始，到客户端浏览器与服务器断开为止，这个过程就是一次会话。

session是把客户状态信息放在服务器端。
session通常用于跟踪用户的会话信息，如判断用户是否登录系统，或者在购物车应用中，系统是否跟踪用户购买的商品等。
session里的属性可以在多个页面的跳转之间共享。一旦关闭浏览器，即session结束，session里的属性将全部清空。
session对象的两个常用方法如下：

• **setAttribute(String attName, Object attValue)：**设置一个session属性。
• **getAttribute(String attName)：**返回一个session属性的值。

注意：session的value必须是可序列化的。

第7章 Servlet介绍

1. Servlet 开发

在控制层编写 Java 类，这个类必须继承 HttpServlet。
必须重写 doGet 和 doPost 方法来响应客户端的所有请求。

需要在 web.xml 中配置 servlet，配置 Servlet 需要配置两个部分：

• 配置 Servlet 的名字：对应 web.xml 文件中的元素。
• 配置 Servlet 的 URL：对应 web.xml 文件中的元素。

配置例子如下：

<servlet>
	<servlet-name>lookFile</servlet-name>
	<servlet-class>bl.LookFileServlet</servlet-class>
</servlet>
<servlet-mapping>
	<servlet-name>lookFile</servlet-name>
	<url-pattern>/lookFile</url-pattern>
</servlet-mapping>

2. Servlet 的生命周期

Servlet 是服务器端的应用程序，默认只实例化一次，采用多线程的方式处理所有请求。
生命周期里的三个方法如下：

• init 方法：用于初始化。
• destroy 方法：用于释放资源。
• service 方法：对用户的请求进行处理，根据不同的请求方式调用 doGet 或 doPost。

过程如下：

1. 当客户端向 Web 服务器提出第一次 Servlet 请求时，Web 服务器会实例化一个 Servlet，并且调用 **init()**方法；如果 Web 服务器中已经存在了一个Servlet 实例，将直接使用此实例；
2. 然后调用 **service()**方法，service()方法将根据客户端的请求方式来决定调用对应的 **doGet()**或 doPost 方法；
3. 当Servlet 从 Web 服务器中消亡时，Web 服务器将会调用 Servlet 的 **destroy()**方法。

3. 掌握 Servlet 基本编程

1. 定义一个类继承 HttpServlet，如： public class FirstServlet extends HttpServlet （一般只需重写 doGet，doPost 方法）。
2. Servlet 作为控制器的作用
   2.1 充当中间调度者，接受所有用户请求。
   2.2 获取请求参数，调用 Model 处理用户请求。
   2.3 将处理结果封装到 request 范围的属性中，然后 forward 到JSP 页面即可。
3. 由 JSP 页面则负责取出 Servlet 封装在 request 范围的属性（即处理结果），并将处理结果显示出来。

第8章 Filter和Listener

1. Filter

1.1 Filter介绍

• Filter并不是一个标准的Servlet，它只是Servlet的一个“变种”。
• Filter它可对用户请求进行预处理，可对服务器响应进行后处理。
• Filter不能对客户端生成响应。

1.2 Filter过滤流程

1.3 Filter的作用

• 在HttpServletRequest到达Servlet之前，拦截客户的HttpServletRequest。
• 根据需要检查HttpServletRequest，也可以修改HttpServletRequest头和数据。
• 根据HttpServletResponse到达客户端之前，拦截HttpServletResponse。
• 根据需要检查HttpServletResponse，也可以修改HttpServletResponse头和数据。

1.4 创建Filter

创建一个Filter只需两个步骤：

1. 创建Filter处理类；
   1.1 必须要实现javax.servlet.Filter接口；
   1.2 必须要实现以下三个方法：
     void init(FilterConfig config)：用于完成Filter的初始化。
     void destroy()：用于Filter销毁前，完成某些资源的回收。
     void doFilter(ServletRequest request, ServletResponse response, FilterChain chain)：实现过滤功能，该方法就是对每个请求及响应增加的额外处理。
2. 在web.xml文件中配置Filter。

<!– 定义Filter -->	
<filter>
		 <!– Filter的名字 -->        
		 <filter-name>fiterName</filter-name>
		 <!– Filter的实现类 -->         
		 <filter-class>filters.myFilter</filter-class>
</filter>
<!– 定义Filter拦截地址 --> 
<filter-mapping>
		 <!– Filter的名字 -->        
		 <filter-name> fiterName </filter-name>
		 <!– Filter负责拦截的URL -->        
		 <url-pattern>/*</url-pattern>
</filter-mapping>

1.5 Filter的生命周期

• 创建实例（应用启动，只执行一次）
• 调用init（实例化后，只执行一次）
• doFilter（每次请求/响应执行一次）
• destroy（销毁实例前，只执行一次）

Fitler的生命周期和Servlet的生命周期基本相同，只是每次用户请求到来之时，Filter调用doFilter处理用户请求，而Servlet调用service方法处理用户请求。

2. Listener

  Servlet API提供了大量监听器来监听Web应用的内部事件，从而允许当Web内部事件发生时回调事件监听器内的方法。

使用Listener只需要两个步骤：

1. 定义Listener实现类。
2. 通过Annotation或在web.xml文件中配置Listerner。

第9章 JSP2 新特性

1. EL（表达式语言）

• 所有 EL 都是以 ${ 为起始、以} 为结尾的。. 与 [ ] 运算符两种运算符来
  获取对象的属性。
• EL 常用的内置对象有三个：sessionScope、requestScope、param。
  • 例从 session 的范围中，输出用户的性别。 ${sessionScope.user.sex}，相当于 <%=((User)session.getAttribute(“user”)).getSex() %>
  • 从 request 的范围中，输出用户的性别。 ${requestScope.user.sex}
  • 从请求参数里，输出用户名。${param.username}

补充：MVC设计模式

  MVC 思想将一个应用分成三个基本部分：Model（模型 M）、View（视图 V）和 Controller（控制器 C），这三个部分以最少的耦合协同工作，从而提高应用的可扩展性及可维护性。
  在 Java Web 应用的 MVC 模式中存在如下划分：

• Model 部分(M)：由 JavaBean 充当。
• View 部分(V)：由 JSP 页面充当。
• Controller 部分©：由 Servlet 充当。

  在 Servlet 中只包含控制逻辑；后端 JavaBean 来完成实际的逻辑处理；最后，转发到相应的 JSP 页面处理显示逻辑。

原理图如下：

第三部分 MyBatis

JavaEE复习资料(3)_MyBatis

第四部分 Spring

JavaEE复习资料(4)_Spring

第五部分 Spring MVC

JavaEE复习资料(5)_Spring MVC