Servlet过滤器和监听器知识总结

Servlet过滤器是 Servlet 程序的一种特殊用法，主要用来完成一些通用的操作，如编码的过滤、判断用户的登录状态。过滤器使得Servlet开发者能够在客户端请求到达 Servlet资源之前被截获，在处理之后再发送给被请求的Servlet资源，并且还可以截获响应，修改之后再发送给用户。而Servlet监听器可以  监听客户端发出的请求、服务器端的操作，通过监听器，可以自动激发一些操作，如监听在线人数。
  Servlet过滤器简介绍
      Servlet过滤器是在JavaServlet 2.3 规范中定义的，它是一种可以插入的Web组件，它能够对Servlet 容器的接收到的客户端请求和向客户端发出的响应对象进行截获，过滤器支持对Servlet程序和JSP页面的基本请求处理功能，如日志、性能、安全、会话  处理、XSLT转换等。
 
      Servlet过滤器本身不产生请求和响应，它只提供过滤作用，Servlet过滤器能够在Servlet程序(JSP页面)被调用之前检查  request对象，修改请求头和请求内容，在Servlet程序(JSP页面)被调用之后，检查response对象，修改响应头和响应内容。

Servlet过滤器的特点
      1.Servlet过滤器可以检查和修改request和response对象。
 
      2.Servlet过滤器可以被指定与特定的URL关联，只有当客户请求访问该特定的URL时，才会触发过滤器。
 
      3.Servlet过滤器可以被串联成串，形成过滤链，协同修改请求和响应。
   Servlet过滤器的作用如下：
 
      1.查询请求并作出相应的行动。
      2.阻塞请求--响应对，使其不能进一步传递。
      3.修改请求头和内容，用户可以提供自定义的请求。
      4.修改响应头和内容，用户可以通过提供定制的响应版本实现。
      5.与外部资源进行交互。
  2 Servlet过滤器的体系结构
      Servlet过滤器用于拦截传入的请求和传出的响应，并监视、修改或以某种方式处理 正在通过的数据流。Servlet过滤器是自包含、模块化的组件，可以将它们添加到请求/响应过滤链中，或者在不影响应用程序中其它Web组件的情况下删 除它们。Servlet过滤器只在改动请求和响应的运行时处理，因而不应该将它们之间嵌入到Web应用程序框架，除非是通过Servlet API中良好定义的标准接口来实现。
 
      Web资源可以配置成为没有过滤器与之关联(默认情况)、与单个过滤器关联(典型情况)，甚至是与一个过滤器链关联。其功能与Servlet一 样，主要是接收请求和响应对象，然后过滤器会检查请求对象，并决定是将该请求转发给链中的下一个过滤器，还是终止该请求并直接向客户端发会一个响应，如果  请求被转发了，它将被传递给过滤链中的下一个过滤器，或者Servlet程序(JSP页面)，在这个请求通过过滤器链并被服务器处理后，一个响应将以相反 的顺序通过该过滤链发送回去，这样就给每个Servlet过滤器提供了根据需要处理响应对象的机会。
 
      当过滤器在Servlet 2.3规范中首次引入时，只能过滤客户端和客户端所访问的指定Web资源之间的内容(请求/响应)，如果该Web资源将请求转发给其它Web资源时，那就  不能向幕后委托的任何请求应用过滤器。Servlet 2.4 规范消除了这个限制，Servlet过滤器现在可以应用于J2EE Web环境中存在请求和响应的任何地方。可见，Servlet过滤器可以应用在客户端和Servlet程序之间、Servlet程序和Servlet程序 之间、Servlet程序和JSP页面之间、JSP页面和JSP页面之间，具有强大的能力和灵活性。
 
                                                                  
 
  2.1 Servlet过滤器对请求的过滤
      Servlet过滤器对请求的过滤过程如下：
 
      1.Servlet容器创建一个Servlet过滤器实例。
      2.Servlet过滤器实例调用init()方法得到初始化参数。
      3.Servlet过滤器实例调用doFilter()方法，根据初始化参数的值判断该请求是否合法，如果该请求不合法，则阻塞该请求，如果是合法请求，则调用chain.doFilter(request,response)方法将该请求向后转发。
 
  13.2.2 Servlet过滤器对响应的过滤
      Servlet过滤器对响应的过滤过程如下：
      1.过滤器截获客户端的请求。
      2.重新封装ServletResponse，在封装后的ServletResponse中提供客户端自定义的输出流。
      3.将请求向后转发。
      4.Web组件产生响应。
      5.过滤器从被封装的ServletResponse中获取客户自定义的输出流。
      6.将响应内容通过客户自定义的输出流写入缓冲流。
      7.在缓冲流中修改响应内容后清空缓冲流，输出响应内容。
 
  2.3 Servlet过滤器的发布
      Seevlet过滤器设计完毕之后，必须对该过滤器进行发布(配置)， 发布一个Servlet过滤器时，必须在项目的web.xml文件中加入<filter>元素和<filter- mapping>元素，<filter>元素用来定义一个过滤器，该元素的属性有：

属性	描述
filter-name	指定过滤器的名字
filter-class	指定过滤器类
init-param	指定过滤器的初始化参数

    <filter-mapping>元素用于将过滤器与URL关联，其属性有：

属性	描述
filter-name	指定过滤器的名字
url-pattern	指定与过滤器关联的URL

3 实现一个Servlet过滤器
  3.1 Servlet过滤器接口的构成
      所有的Servlet过滤器都必须实现javax.servlet.filter接口，该接口中定义了3个过滤器必须实现的方法：
 
      1.void  init(FilterConfig)：过滤器的初始化方法，Servlet容器在创建过滤器实例时调用这个方法，在这个方法中可以读出在web.xml文件中为该过滤器配置的初始化参数。
 
      2.voiddoFilter(ServletRequest,ServletResponse,FilterChain)：用于完成实际的过滤操作，当客户请求访问与过滤器相关联的URL时，Servlet容器将先调用过滤器的这个方法，FilterChain参数用于访问后续过滤器。
 
      3.voiddestroy()：过滤器在被取消前执行这个方法，释放过滤器申请的资源。
 
  3.2 Servlet过滤器的创建步骤
      创建一个Servlet过滤器需要下面的步骤：
      
      1.创建一个实现了javax.servlet.Filter接口的类。
 
      2.重写init(FilterConfig)方法，读入为过滤器配置的初始化参数，申请过滤器需要的资源。
 
      3.重写方法doFilter(ServletRequest,ServletResponse,FilterChain)，完成过滤操作，可以  从ServletRequest参数中得到全部的请求信息，从ServletResponse参数中得到全部的响应信息。
 
      4.在doFilter()方法的最后，使用FilterChain参数的doFilter()方法将请求和响应后传。
 
      5.对响应的Servlet程序和JSP页面注册过滤器，在部署描述文件(web.xml)中使用<filter-apping>和<filter>元素对过滤器进行配置。
 
  3.3 编写过滤器类
      在过滤器中，需要使用3个简单的接口，它们是：分别是Filter、FilterChain、FilterConfig，全部包含在javax.servlet包中。从编程的角度看，过滤器类要实现Filter接口，然后使用实现了FilterChain和FilterConfig接口的对象来工作，FilterChain对象负责将请求和响应后传，FilterConfig对象负责为过滤器读初始化参数。
 
      为了与过滤器的三步模式(创建、工作、撤消)保持一致，过滤器必须重写Filter接口中的三个方法：
 
      init()：在容器实例化过滤器市时被调用，主要为过滤器做初始化，该方法有一个FilterConfig类型的形参。
 
      doFilter()：这个方法用来完成真正的过滤操作，它有3个形式参数：ServletRequest参数包含请求信息，ServletResponse参数包含响应信息，FilterChain参数用来将请求和响应向后传递。
 
      destroy()：过滤器被撤消时调用这个方法，释放过滤器所 占有的资源。
 
      在下面的例子中实现了一个简单的Servlet过滤器(SessionFilter.Java)，它实现的功能是判断客户是否成功登录，如果成功登录，转向正确页面，否则返回一个错误页面，提示客户应该进行登录。该过滤器代码如下：
 
      //includeList:数组，受保护的资源。
      //logonList：数组，登录页面。
      package ch13;
      import javax.servlet.*;
      import javax.servlet.http.*;
      import java.io.*;
      public class SessionFilter implements Filter{
          String  logonStrings,includeStrings,redirectPath,disabletestfilter;
          String[]  logonList,includeList;
 
          private boolean  isContains(String containers,String[] regx) {
              boolean  result=false;
              for(int  i=0;i<regx.length;i++) {
                  if  (containers.indexOf(regx[i])!=-1)
                      return  true;
              }
              return  result;
          }
 
          public FilterConfig config;
          private void  setFilterConfig(FilterConfig config) {
              this.config=config;
          }
 
          private FilterConfig  getFilterConfig(){
              return  config;
          }
 
          //必须重写
          public void init(FilterConfig filterConfig) throws ServletException{
              this.config=filterConfig;
              logonStrings=config.getInitParameter("logonStrings");
               includeStrings=config.getInitParameter("includeStrings");
               redirectPath=config.getInitParameter("redirectPath");
               disabletestfilter=config.getInitParameter("disabletestfilter");
              logonList=logonStrings.split(";");//分割为数组
               includeList=includeStrings.split(";");//分割为数组
          }
          //必须重写
          public void  doFilter(ServletRequest request,ServletResponse response,FilterChain
                                      chain)  throws ServletException, IOException {
              HttpServletRequest  httpreq=(HttpServletRequest)request;
              HttpServletResponse  httpres=(HttpServletResponse)response;
              HttpServletResponseWrapper  wrapper=new HttpServletResponseWrapper(
  (HttpServletResponse)response);
              if  (disabletestfilter.toUpperCase().equals("Y")){
                  chain.doFilter(request,response);//如果不过滤
                  return;
              }
              Object  user=httpreq.getSession().getAttribute("userinfo");
              if  (user==null){//该用户没有登录
                  if  (!isContains(httpreq.getRequestURI(),includeList)){
                      chain.doFilter(request,response);
                      return;//访问的是不受保护的页面，可以
                  }
                  if  (isContains(httpreq.getRequestURI(),logonList)){
                      chain.doFilter(request,response);
                      return;  //访问的是登录页面，可以
                  }
                  wrapper.sendRedirect(redirectPath);  //转向登页面
              }else  {//该用户已经登录
                  chain.doFilter(request,response);
              }
          }
          //必须重写
          public void destroy() {
              config=null;
          }
      }
 
      在上面的这个Servlet过滤器程序中，根据用户session对象中有无userinfo这个属性来确定该用户是否已经登录。
 
  3.4 配置部署过滤器
      在WEB-INF/web.xml文件中用以下代码配置过滤器：
 
      <filter>
          <filter-name>SessionFilter</filter-name>
              <filter-class>ch13.SessionFilter</filter-class> 
          <init-param>
              <param-name>logonStrings</param-name>
              <param-value>Login.jsp</param-value> 
          </init-param>
          <init-param>
              <param-name>includeStrings</param-name>
              <param-value>.jsp;.html;.htm</param-value>
          </init-param>
          <init-param>
              <param-name>redirectPath</param-name>
              <param-value>./Login.jsp</param-value> 
          </init-param>
          <init-param>
              <param-name>disabletestfilter</param-name>
              <param-value>n</param-value> 
          </init-param>
      </filter>
      <filter-mapping>
          <filter-name>SessionFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
 
      在上面的配置中，参数logonStrings指定可以访问的登录页面，参数includeStrings指定受保护的资源的后缀，参数redirectPath表示没有登录时转向的登录页面，参数disabletestfilter表示过滤器是否有效。而 /* 表示过滤器与所有的URL都关联(对所有的访问请求都进行过滤)。在浏览器中访问任意的资源时，都要通过这个过滤器的过滤。
 
  4 过滤器的应用案例.4.1 版权过滤器的应用案例
      在一个Web应用中的所有页面的下面添加上版权信息，通常的做法是采用<%@ include>指令或<c:import> 标签，使用过滤器也是一个好办法。
 
      1.编写过滤器类CopyrightFilter.java
      package ch13;
      import javax.servlet.*;
      import javax.servlet.http.*;
      import java.io.*;
      public class CopyrightFilter implements Filter{
          private String date;
          public FilterConfig config;
          //必须重写
          public void init(FilterConfig filterConfig) throws ServletException{
              this.config=filterConfig;
              date=config.getInitParameter("date");
          }
          //必须重写
          public void doFilter(ServletRequest request,ServletResponse response,FilterChain
                                              chain)  throws ServletException, IOException {
              chain.doFilter(request,response);
              PrintWriter  out=response.getWriter();
              out.print("<br><center><font  size='3' color='red'>版权所有：北京工业大学
                                                              </center></font>");
              if  (date!=null)
                  out.print("<br><center><font  color='blue'>"+date+"</center></font>");
              out.flush();
          }
          //必须重写
          public void destroy() {
              config=null;
          }
      }
 
      在这个过滤器中，在doFilter()方法的最后，通过response对象得到一个输出流out，然后通过输出流向客户端输出版权信息，这样，每个页面的最后都会出现过滤器添加的版权信息。
 
      2.修改web.xml，配置该过滤器
      <filter>
          <filter-name>CopyrightFilter</filter-name>
              <filter-class>ch13.CopyrightFilter</filter-class> 
          <init-param>
              <param-name>date</param-name>
              <param-value>2010-9</param-value> 
          </init-param>
      </filter>
      <filter-mapping>
          <filter-name>CopyrightFilter</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
 
      3.测试
      在浏览器中任意访问一个页面，都可以在看到在页面的下部出现过滤器添加的版权信息。
 
  4.2 禁止未授权的IP访问站点过滤器的应用案例
      使用过滤器禁止未授权的IP访问站点是过滤器常见的应用，本例演示了如何利用过滤器实现禁止未授权的IP访问站点。
 
      1.编写过滤器类FilterIP.java
      package ch13;
      import javax.servlet.*;
      import javax.servlet.http.*;
      import java.io.*;
      public class FilterIP implements Filter{
          private String  filterIP,error;
          public FilterConfig config;
          //必须重写
          public void init(FilterConfig filterConfig) throws  ServletException{
              this.config=filterConfig;
              filterIP=config.getInitParameter("FilterIP");
              if  (filterIP==null) filterIP="";
              error=config.getInitParameter("ERROR");
              if  (error==null) error="error.jsp";
          }
          //必须重写
          public void doFilter(ServletRequest request,ServletResponse response,FilterChain
                                              chain)  throws ServletException, IOException {
              RequestDispatcher  dispatcher=request.getRequestDispatcher("ErrorInfo.jsp");
              String remoteIP=request.getRemoteAddr();//得到客户的IP地址
              if  (remoteIP.equals(filterIP)) {
                  dispatcher.forward(request,response);
                  return;
              }  else
                  chain.doFilter(request,response);
          }
          //必须重写
          public void destroy() {
              config=null;
          }
      }
 
      在这个过滤器中，在doFilter()方法内，通过request对象得到客户端的IP地址，如果客户端的IP是被禁止的IP，则使用request对象将请求转发给一个出错页面。
 
      2.修改web.xml，配置过滤器
  <filter>
          <filter-name>FilterIP</filter-name>
              <filter-class>ch13.FilterIP</filter-class> 
          <init-param>
              <param-name>FilterIP</param-name>
              <param-value>192.168.1.1</param-value> 
          </init-param>
          <init-param>
              <param-name>ERROR</param-name>
              <param-value>error.jsp</param-value> 
          </init-param>
      </filter>
      <filter-mapping>
          <filter-name>FilterIP</filter-name>
          <url-pattern>/*</url-pattern>
      </filter-mapping>
 
      对来自192.168.1.1的客户的所有请求(/*)都进行过滤，转移到error.jsp页面。
 
      3.编写出错页面error.jsp
      <%@  page contentType="text/html;charset=gb2312" %>
      网站不允许IP地址为192.168.1.1的计算机访问。
 
      在IP地址为  192.168.1.1 的计算机上访问网站的任何一个资源，都会转移到error.jsp页面。
 
  4.3 过滤页面内容(响应内容)
      本过滤器使用HttpServletResponseWrapper类  来实现页面内容的过滤，它的原理是让Web资源先将页面内容(响应内容)写入到HttpServletResponseWrapper对象中，然后再在过  滤器中处理HttpServletResponseWrapper对象中的页面内容(响应内容)，最后再将处理好的页面内容(响应内容)发送给客户。
 
      1.编写HttpServletResponseWrapper类的子类.java
      package ch13;
      import java.io.ByteArrayOutputStream;
      import java.io.OutputStreamWriter;
      import java.io.IOException;
      import java.io.PrintWriter;
      import java.io.UnsupportedEncodingException;
      import javax.servlet.http.HttpServletResponse;
      import javax.servlet.http.HttpServletResponseWrapper;
      import javax.servlet.ServletOutputStream;
      public class WrapperResponse extends  HttpServletResponseWrapper {
          public static final int  OT_NONE = 0, OT_WRITER = 1, OT_STREAM = 2;
          private int outputType =  OT_NONE;
          private ServletOutputStream  output = null;
          private PrintWriter writer =  null;
          private ByteArrayOutputStream  buffer = null;
 
          //构造函数
          public  WrapperResponse(HttpServletResponse resp) throws IOException {
              super(resp); 
              buffer  = new ByteArrayOutputStream();
          }
 
          //得到字符输出流
          public PrintWriter getWriter() throws IOException {
              if  (outputType == OT_STREAM)
                  throw  new IllegalStateException(); //已经用了OutputStream流
              else  if (outputType == OT_WRITER)
                  return  writer;
              else  {
                  outputType  = OT_WRITER;
                  writer  = new PrintWriter(new  OutputStreamWriter(buffer, getCharacterEncoding()));
                  return  writer;
              }
          }
 
          //得到字节输出流
          public ServletOutputStream getOutputStream() throws IOException {
              if  (outputType == OT_WRITER)
                  throw  new IllegalStateException(); //已经用了Writer流
              else  if (outputType == OT_STREAM)
                  return  output;
              else  {
                  outputType  = OT_STREAM;
                  output  = new WrappedOutputStream(buffer);
                  return  output;
              }
          }
 
          //刷新输出内容
          public void flushBuffer() throws IOException {
              if  (outputType == OT_WRITER)
                  writer.flush(); 
              if  (outputType == OT_STREAM)
                  output.flush(); 
          }
 
          //输出缓冲区复位
          public void reset() {
              outputType  = OT_NONE;
              buffer.reset(); 
          }
          public String  getResponseData() throws IOException {
              flushBuffer(); 
              return  new String(buffer.toByteArray());
          }
 
          //内部类，将数据写入自己的定义的缓冲区
          class WrappedOutputStream extends ServletOutputStream {
                  private  ByteArrayOutputStream buffer;
                  public  WrappedOutputStream(ByteArrayOutputStream buffer) {
                      this.buffer  = buffer;
                  } 
                  public  void write(int b) throws IOException {
                      buffer.write(b); 
                  } 
                  public  byte[] toByteArray() {
                      return  buffer.toByteArray();
                  } 
          }
      }
 
      在这个类中，一定要重写response对象的关于输出流（outputStream、writer）操作的方法：getOutputStream()、getWriter()、flushBuffer()、reset()。
 
      2.编写过滤器GavinFilter.java
      package ch13;
      import java.io.IOException;
      import javax.servlet.*;
      import javax.servlet.http.HttpServletRequest;
      import javax.servlet.http.HttpServletResponse;
      public class GavinFilter implements Filter {
          private String  oldword="%" , newword="百分号";
          public void destroy(){}
          public void  doFilter(ServletRequest request, ServletResponse response, FilterChain
                                                  chain)  throws IOException, ServletException {
              HttpServletResponse  oldresponse = (HttpServletResponse)response;
              WrapperResponse  wrapperResponse = new WrapperResponse(oldresponse);
              chain.doFilter(request,  wrapperResponse); //让服务器将响应内容写到Wrapper中
              String  html = wrapperResponse.getResponseData(); //取出响应内容
              oldresponse.getWriter().print(html.replaceAll(oldword,  newword)); //替换页面中的文字，然后发送给客户
          }
          public void init(FilterConfig config) throws ServletException {
              oldword=config.getInitParameter("oldword");
              newword=config.getInitParameter("newword");
          }
      }
 
      该过滤器将页面内容(响应内容)中的字符 % 替换为百分号三个汉字，由此可见，实现了对响应内容的过滤。
 
      3.对该过滤器的配置
      <filter>
          <filter-name>gavinFilter</filter-name> 
          <filter-class>ch13.GavinFilter</filter-class> 
          <init-param>
              <param-name>oldword</param-name> 
              <param-value>%</param-value>
          </init-param>
          <init-param>
              <param-name>newword</param-name> 
              <param-value>百分号</param-value>
          </init-param>
      </filter>
      <filter-mapping>
          <filter-name>gavinFilter</filter-name> 
          <url-pattern>/*</url-pattern> 
      </filter-mapping>
 
  5 Servlet监听器
      Servlet监听器也叫做 listener，通过它可以监听Web应用的上下文(环境)信息、Servlet请求信息、Servlet会话信息，并自动根据不同情况，在后台调用相  应的处理程序。通过监听器，可以自动激发一些操作，比如监听在线人数，当增加一个HttpSession时就激发 sessionCreated(HttpSessionEvent)方法，这样就可以给在线人数加1。
 
  13.5.1 监听器的原理
      Servlet监听器是Web应用开发的一个重要组成部  分，Servlet监听器是在Servlet2.3规范中和Servlet过滤器一起引入的。在 Servlet2.4 规范中对其进行了比较大的改进。主要就是用来对Web应用进行监督和控制，极大地增强了Web应用的事件处理能力。
 
      Servlet监听器的功能比较类似于Java中的GUI程序的监听器，可以监听由于Web应用中的状态改变而引起的Servlet容器产生的相应事件，然后接收并处理这些事件。
 
  5.2 监听器的类型
      在 Servlet 2.4 规范中，根据监听对象的类型和范围，将监听器分为3类：ServletRequest监听器(请求监听器)、HttpSession监听器(会话监听器)、ServletContext监听器(上下文监听器)，其中请求监听器(ServletRequest监听器)是  Servlet 2.4 规范中新增加的监听器，可以用来监听客户的端请求，在Servlet 2.4 规范中包含了8个监听器接口和6个监听器事件类，具体的监听器接口和事件如下表：

监听对象	监听接口	监听事件
ServletRequest	ServletRequestListener    (2个方法)	ServletRequestEvent
	ServletRequestAttributeListener    (3个方法)	ServletRequestAttributeEvent
HttpSession	HttpSessionListener    (2个方法)	HttpSessionEvent
	HttpSessionActivationListener    (2个方法)
	HttpSessionAttributeListener    (3个方法)	HttpSessionBindingEvent
	HttpSessionBindingListener    (2个方法)
ServletContext	ServletContextListener    (2个方法)	ServletContextEvent
	ServletContextAttributeListener    (3个方法)	ServletContextAttributeEvent

    1.被监听对象ServletContext
      对ServletContext对象(JSP页面中称为application对象)实现监听涉及2个接口：
 
      (1)ServletContextListener接口：用于监听ServletContext对象的创建和删除：接口中定义的回调方法有：
 
          当创建一个ServletContext对象时，激发  contextInitialzed(ServletContextEvent)方法。
          当撤消一个ServletContext对象时，激发  contextDestroyed(ServletContextEvent)方法。
 
      (2)ServletContextAttributeListener接口：用于监听ServletContext对象的属性操作。接口中定义的回调方法有：
 
          增加属性时，激发 attributeAdded(ServletContextAttributeEvent)
          删除属性时，激发 attributeRemoved(ServletContextAttributeEvent)
          修改属性时，激发 attributeReplaced(ServletContextAttributeEvent)
 
      2.被监听对象HttpSession
      对HttpSession对象(session)实现监听涉及4个接口：
 
      (1)HttpSessionListener接口：这个接口监听Http会话的创建和撤消，并在某个session对象建立和销毁之前调用某个方法。接口中定义的回调方法有：
 
          创建一个session对象时，激发  sessionCreated(HttpSessionEvent)
          删除一个session对象时，激发 sessionDestroyed(HttpSessionEvent)
 
      (2)HttpSessionActivationListener接口：监听Http会话的active和passivate状态。接口中定义的回调方法有：
 
          session对象被保存到磁盘时，激发 sessionWillPassivate(HttpSessionEvent)
          session对象被调入内存时，激发 sessionDidActivate(HttpSessionEvent)
 
      Activate与Passivate是用于置换session对象的动作，当Web服务器因为资源利用或负载平衡等原因要将内存中的 session对象暂时储存至硬盘或其它储存器时(通过对象序列化)，所作的动作称之为Passivate，而硬盘或储存器上的session对象重新加 载到JVM中时所采的动作称之为Activate。sessionDidActivate()方法与 sessionWillPassivate()方法分别于Activeate后与Passivate前被调用。
 
      (3)HttpSessionAttributeListener接口：监听Http会话中属性的设置信息。接口中定义的回调方法有：
 
          向某个session对象中增加新属性时，激发  attributeAdded(HttpSessionBindingEvent)
          删除某个session对象中的属性时，激发 attributeRemoved(HttpSessionBindingEvent)
          修改某个session对象中的属性时，激发 attributeReplaced(HttpSessionBindingEvent)
 
      使用HttpSessionBindingEvent事件类对象的getSession()方法可以得到这个session对象，使用 HttpSessionBindingEvent对象的getName()方法得到属性的名字，使用getValue()方法得到属性的值。
 
      若有属性加入到某个会话（HttpSession）对象，则会调用attributeAdded()，同理在替换属性与移除属性时，会分别调用attributeReplaced()、attributeRemoved()。

    (4)HttpSessionBindingListener接口：这是唯一一个不需要在web.xml中进行配置的监听器接口，监听Http会话中属性的变化情况。接口中定义的回调方法有：
 
          属性被加入到session中时，激发属性的 valueBound(HttpSessionBindingEvent)
          属性被从session中删除时，激发属性的 valueUnbound(HttpSessionBindingEvent)
 
      使用HttpSessionBindingEvent事件类对象的getSession()方法可以得到这个session对象，使用 HttpSessionBindingEvent对象的getName()方法得到属性的名字，使用getValue()方法得到属性的值。
 
      如果一个对象object实现了HttpSessionBindingListener接口时，当把object对象保存到session中时， 就会自动调用object对象的valueBound()方法，如果对象object被从session（HttpSession）移除时，则会调用 object对象的valueUnbound()方法。使用这个接口，可以让一个对象自己知道它自己是被保存到了session中，还是从session 中被删除了。     
      
      3.被监听对象ServletRequest
      对ServletRequest对象(request)实现监听涉及2个接口：
 
      (1)ServletRequestListener接口：监听请求的创建和撤消，该接口用来监听请求到达和结束，因此可以在请求达到前和请求结束前执行一些用户行为。  接口中定义的回调方法有：
 
      请求对象初始化时，激发 requestInitialized(ServletRequestEvent)
      请求对象被撤消时，激发  requestDestroyed(ServletRequestEvent)
 
      在request（HttpServletRequest）对象建立或被消灭时，会分别调用requestInitialized()和requestDestroyed()方法。
 
      (2)ServletRequestAttributeListener接口：监听请求中(request对象中)的属性变化。接口中定义的回调方法有：
 
      向某个request对象中增加属性时被调用attributeAdded(ServletRequestAttributeEvent)方法。
      从某个request对象中删除属性时被调用attributeRemoved(ServletRequestAttributeEvent)方法。
      修改某个request中的属性时被调用attributeReplaced(ServletRequestAttributeEvent)方法。
 
      使用ServletRequestEvent类的getServletRequest()方法可以得到这个被监听的请求对象，使用  ServletRequestAttributeEvent类的getName()方法可以得到属性名，getValue()方法可以得到属性的值。
 
      若有属性加入到某个request对象中时则会调用attributeAdded()，同理在替换属性与删除属性时，会分别调用attributeReplaced()、 attributeRemoved()。
 
      当Web应用程序启动后，在处理任何请求之前，调用contextInitialzed()方法和getInitParamter()方法，返回  在配置文件中为定义的环境初始化信息。不同的组件，如Servlet、JSP、监听器和过滤器等，通过ServletRequest、 HttpSession 和 ServletContext达到数据共享，这些类都提供了下面的一组方法，可以使用这组方法来设置、获取、删除属性：
 
          public void  setAttribute("属性名",属性值);
          public Object  getAttribute("属性名");
          public void  removeAttribute("属性名");
      
  5.3 监听器管理共享数据库连接
      在web.xml中，使用<listener>来配置监听器，语法是：
 
          <listener>
              <listener-class>包名.类名</listener-class>
          </listener>
 
      比如：创建一个ServletContext对象监听器，在一个Web项目一启动就创建一个与数据库的连接，保存在application对象中，这个连接一直保存到Web项目关闭时为止。程序代码如下：
 
      package ch13;
      import javax.servlet.ServletContextEvent;
      import javax.servlet.ServletContextListener;
      import java.sql.*;
      //import ch7.db.*;
      public final class MyConnectionManager implements ServletContextListener {
          Connection con=null;
          public void  contextInitialized(ServletContextEvent e) {//重写接口定义的方法，项目启动是调用该方法
              ConnectDB db=new ConnectDB();
              con=db.getConnection();  //使用对象db创建数据库连接
              e.getServletContext().setAttribute("con",con);//与数据库的连接保存入application对象中
          }
          public void contextDestroyed(ServletContextEvent  e) {//重写接口定义的方法，项目关闭时调用该方法
              try {
                  con.close();
              }
              catch(Exception  e1){}
          }
      }
 
      在web.xml文件对这个ServletContext类型的监听器进行配置：
 
          <listener>
              <listener-class>ch13.MyConnectionManager</listener-class>
          </listener>
 
      这个监听器能保证每新创建一个ServletContext对象时(一个Web项目只有一个 ServletContext对象)，该Web项目都会有一个可以使用的数据库连接，并且这个数据库连接会在该ServletContext对象关闭(结 束)的时候随之关闭。
 
      测试页面testcon.jsp：
      <%@ page contentType="text/html" pageEncoding="GB18030"%>
      <br><%= "得到的数据库连接："+application.getAttribute("con") %>
      <br><h1>请注意安装数据库的驱动程序</h1>
 
 
  5.4 监听器的应用案例
      下面是一个在线用户数量监听器，这个监听器可以实时统计在线人数，在 ServletContext初始化和撤消时，在服务器控制台打印出对应信息，当ServletContext对象里的属性增加、修改、删除时，在服务器  控制台打印相应的信息。要完成上面的监听功能，需要使用3个接口：
 
      HttpSessionListener：监督HttpSession对象的创建和撤消，统计人数。
      ServletContextListener：监督ServletContext对象的创建和撤消。
      ServletContextAttributeListener：监督ServletContext的属性变化。
 
      1.监听器程序代码OnLineCountListener.java
      package ch13;
      import javax.servlet.*;
      import javax.servlet.http.*;
      public final class OnLineCountListener implements  HttpSessionListener,
                                  ServletContextAttributeListener,  ServletContextListener {
          private int count;
          private ServletContext  context=null;
 
          //构造函数
          public OnLineCountListener()  {
              count=0;//人数
          }
 
          //重写HttpSessionListener接口中的2个方法,完成对session对象创建和撤消的监视
          public void  sessionCreated(HttpSessionEvent se) {//创建了一个session对象
              count++;//人数加1
              setContext(se);
          }
          public void  sessionDestroyed(HttpSessionEvent se){//撤消了一个session对象
              count--;//人数减1
              setContext(se);
          }
 
          private void  setContext(HttpSessionEvent se){
              se.getSession().getServletContext().setAttribute("onLine",new  Integer(count));
          }
 
          //重写ServletContextAttributeListener接口中的3个方法
          public void  attributeAdded(ServletContextAttributeEvent event) {//添加了属性
              log("attributeAdded("+event.getName()+","+event.getValue()+")");
          }
          public void  attributeRemoved(ServletContextAttributeEvent event) {//删除了属性
              log("attributeRemove("+event.getName()+","+event.getValue()+")");
          }
          public void attributeReplaced(ServletContextAttributeEvent  event) {//替换了原有的属性
              log("attributeReplaced("+event.getName()+","+event.getValue()+")");
          }
 
          //重写ServletContextListener接口中的2个方法
          public void  contextDestroyed(ServletContextEvent event) {//Web项目关闭
              log("contextDestroyed()");
              context=null;
          }
          public void  contextInitialized(ServletContextEvent event) {//Web项目启动
              this.context=event.getServletContext();
              log("contextInitialized()");
          }
 
          //显示信息
          private void log(String  message){
              System.out.println("ContextListener:"+message);
          }
      }
 
      在OnLineCountListener类中，用count保存目前在线人数，每增加一个session对象，人数加1，每撤消一个session对象，人数减1。人数保存在ServletContext对象中，使得任何页面都可以使用。
 
      2.在web.xml文件中配置监听器
 
          <listener>
              <listener-class>ch13.OnLineCountListener</listener-class>
          </listener>
 
      3.编写测试页面(2个)
                              listener.jsp------>exit.jsp
 
                              listener.jsp页面内容
      <%@ page  contentType="text/html;charset=gb2312" %>
      目前在线人数：<font  color="red"><%=application.getAttribute("onLine")%></font><br>
      退出会话:
      <form action="exit.jsp"  method="post">
      <input type="submit"  value="exit">
      </form>
 
                              exit.jsp页面内容
      <%@ page  contentType="text/html;charset=gb2312" %>
      你已经退出会话<%  session.invalidate(); %>
 
      可以单独启动5个浏览器窗口，每个窗口代表一个客户，因此在线人数是5。
 
  5.5 HttpSessionBindingListener 接口的使用
      设计一个学生对象Student，当将该学生对象存入 session中时，他的年龄增加10岁，当将这个学生对象从session中删除时，他的年龄减少5岁。
 
      学生类Student.java
      package ch13;
      import javax.servlet.*;
      import javax.servlet.http.*;
      public class Student implements  HttpSessionBindingListener {
          private int age=30;
          public void valueBound(HttpSessionBindingEvent  arg0) {//存入session时自动调用
              age+=10;
          }
          public void  valueUnbound(HttpSessionBindingEvent arg0) {//从session中删除时自动调用
              age-=5;
          }
          public int getAge() {return  age;}
      }
 
      测试页面bind.jsp
      <%@ page  contentType="text/html;charset=gb2312"  import="ch13.Student"%>
      <%
          Student student=new  Student();
          out.println("学生年龄："+student.getAge()+"<br>");
          session.setAttribute("st",student);
          out.println("存入session后，该学生年龄："+student.getAge()+"<br>");
          session.removeAttribute("st"); 
          out.println("从session删除，该学生年龄："+student.getAge()+"<br>"); 
      %>