Java Web 之 Listener

本文包括：

1、Listener简介

2、Servlet监听器

3、监听三个域对象创建和销毁的事件监听器

4、监听三个域对象的属性(Attribute)的变化的事件监听器

5、监听绑定到 HttpSession 域中的某个对象的状态的事件监听器

1、Listener简介

  • Listener（监听器）就是一个实现特定接口的普通java程序，这个程序专门用于监听另一个java对象的方法调用或属性改变，当被监听对象发生上述事件后，监听器某个方法将立即被执行。

  • 为了加深理解，自定义监听器来练练手，假设现在有个体重100的人要吃饭了，要监听他吃饭的动作，捕捉到了之后再打印它的体重，具体思路如下；

    1. 事件源类：

       public class Person {
     private String name;
     private int weight;// 体重
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getWeight() {
         return weight;
     }
 
     public void setWeight(int weight) {
         this.weight = weight;
     }
 
 }

    2. 监听器接口：

       public interface PersonListener {
     public void personeating(PersonEvent event);// 监听方法，需要一个事件对象作为参数
 }

    3. 事件类：

       public class PersonEvent {
     private Object source;// 事件源
 
     public Object getSource() {
         return source;
     }
 
     public void setSource(Object source) {
         this.source = source;
     }
 
     // 提供一个这样的构造方法：构造事件对象时，接收事件源（Person）
     public PersonEvent(Person person) {
         this.source = person;
     }
 
 }

    4. 在事件源中注册监听器：

       public class Person {
     private String name;
     private int weight;// 体重
     private PersonListener listener;
 
     // 注册监听器
     public void addPersonListener(PersonListener listener) {
         this.listener = listener;
     }
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getWeight() {
         return weight;
     }
 
     public void setWeight(int weight) {
         this.weight = weight;
     }
 
 }

    5. 操作事件源 ----- 在事件源方法中，构造事件对象，参数为当前事件源（this），传递事件对象给监听器的监听方法：

       public class Person {
     private String name;
     private int weight;// 体重
     private PersonListener listener;
 
     // 注册监听器
     public void addPersonListener(PersonListener listener) {
         this.listener = listener;
     }
 
     // 吃饭
     public void eat() {
         // 体重增加
         weight += 5;
         // 调用监听器监听方法
         if (listener != null) {
             // 监听器存在
             // 创建事件对象 --- 通过事件对象可以获得事件源
             PersonEvent event = new PersonEvent(this);
 
             listener.personeating(event);
         }
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public int getWeight() {
         return weight;
     }
 
     public void setWeight(int weight) {
         this.weight = weight;
     }
 
 }

    6. 测试：

       public class PersonTest {
     public static void main(String[] args) {
         // 步骤一 创建事件源
         Person person = new Person();
         person.setName("小明");
         person.setWeight(100);
 
         // 步骤二 给事件源注册监听器（该监听器由匿名内部类创建）
         person.addPersonListener(new PersonListener() {
             @Override
             public void personeating(PersonEvent event) {
                 System.out.println("监听到了，人正在吃饭！");
                 
                 // 在监听方法中可以获得事件源对象，进而可以操作事件源对象
                 Person person = (Person) event.getSource();
                 System.out.println(person.getName());
                 System.out.println(person.getWeight());
             }
         });
 
         // 步骤三 操作事件源
         person.eat();// 结果监听方法被调用
     }
 }

2、Servlet监听器

  • 在Servlet规范中定义了多种类型的监听器，它们用于监听的事件源是三个域对象，分别为：

    • ServletContext

    • HttpSession

    • ServletRequest

  • Servlet规范针对这三个域对象上的操作，又把这多种类型的监听器划分为三种类型：

    • 监听三个域对象的创建和销毁的事件监听器

    • 监听三个域对象的属性(Attribute)的增加和删除的事件监听器

    • 监听绑定到 HttpSession 域中的某个对象的状态的事件监听器。（查看API文档）

  • 编写 Servlet 监听器：

    • 和编写其它事件监听器一样，编写Servlet监听器也需要实现一个特定的接口，并针对相应动作覆盖接口中的相应方法。

    • 和其它事件监听器略有不同的是，Servlet监听器的注册不是直接注册在事件源上，而是由WEB容器负责注册，开发人员只需在web.xml文件中使用<listener>标签配置好监听器，web容器就会自动把监听器注册到事件源中。

    • 一个 web.xml 文件中可以配置多个 Servlet 事件监听器，web 服务器按照它们在 web.xml 文件中的注册顺序来加载和注册这些 Serlvet 事件监听器。配置代码如下所示：

        <!-- 对监听器进行注册 -->
  <!-- 监听器和Servlet、Filter不同，不需要url配置，监听器执行不是由用户访问的，监听器 是由事件源自动调用的 -->
  <listener>
      <listener-class>cn.itcast.servlet.listener.MyServletContextListener</listener-class>
  </listener>

3、监听三个域对象创建和销毁的事件监听器

3.1、ServletContextListener

  • ServletContextListener 接口用于监听 ServletContext 对象的创建和销毁事件。

    • 当 ServletContext 对象被创建时，调用接口中的方法：

        ServletContextListener.contextInitialized (ServletContextEvent sce)

    • 当 ServletContext 对象被销毁时，调用接口中的方法：

        ServletContextListener.contextDestroyed(ServletContextEvent sce)

  • ServletContext域对象何时创建和销毁：

    • 创建：服务器启动时，针对每一个web应用创建Servletcontext

    • 销毁：服务器关闭前，先关闭代表每一个web应用的ServletContext

  • ServletContext主要用来干什么？

    1. 保存全局应用数据对象

      • 在服务器启动时，对一些对象进行初始化，并且将对象保存ServletContext数据范围内 —— 实现全局数据

      • 例如：创建数据库连接池

    2. 加载框架配置文件

      • Spring框架(配置文件随服务器启动加载) org.springframework.web.context.ContextLoaderListener

    3. 实现任务调度（定时器），启动定时程序

      • java.util.Timer：一种线程设施，用于安排以后在后台线程中执行的任务，可安排任务执行一次，或者定期重复执行。

      • Timer提供了启动定时任务方法 Timer.schedule()，其中有两种方法需要记住：

        1. 在指定的一个时间时启动定时器，定期执行一次

            Timer.schedule(TimerTask task, Date firstTime, long period)

        2. 在当前时间延迟多少毫秒后启动定时器，定期执行一次

            Timer.schedule(TimerTask task, long delay, long period)

      • 停止定时器，取消任务

          Timer.cancel()

  • demo：

      package cn.itcast.servlet.listener;
  
  import java.text.DateFormat;
  import java.text.ParseException;
  import java.text.SimpleDateFormat;
  import java.util.Date;
  import java.util.Timer;
  import java.util.TimerTask;
  
  import javax.servlet.ServletContext;
  import javax.servlet.ServletContextEvent;
  import javax.servlet.ServletContextListener;
  
  /**
   * 自定义 Context监听器
   * 
   * @author seawind
   * 
   */
  public class MyServletContextListener implements ServletContextListener {
  
      @Override
      public void contextDestroyed(ServletContextEvent sce) {
          System.out.println("监听ServletContext对象销毁了...");
      }
  
      @Override
      public void contextInitialized(ServletContextEvent sce) {
          System.out.println("监听ServletContext对象创建了...");
          // 获得事件源
          ServletContext servletContext = sce.getServletContext();
          // 向ServletContext 中保存数据
  
          // 启动定时器
          final Timer timer = new Timer();
          // 启动定时任务
  
          // timer.schedule(new TimerTask() {
          // @Override
          // // 这就是一个线程
          // public void run() {
          // System.out.println("定时器执行了...");
          // }
          // }, 0, 3000); // 马上启动 每隔3秒重复执行
  
          // 指定时间启动定时器
          DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
          try {
              Date first = dateFormat.parse("2012-08-07 10:42:00");
              timer.schedule(new TimerTask() {
                  int i;
  
                  @Override
                  public void run() {
                      i++;
                      System.out.println("从10点40分开始启动程序，每隔3秒重复执行");
                      if (i == 10) {
                          timer.cancel();// 取消定时器任务
                      }
                  }
              }, first, 3000);
          } catch (ParseException e) {
              e.printStackTrace();
          }
      }
  
  }

3.2、HttpSessionListener

  • HttpSessionListener接口用于监听HttpSession的创建和销毁

    • 创建一个Session时，接口中的该方法将会被调用：

        HttpSessionListener.sessionCreated(HttpSessionEvent se)

    • 销毁一个Session时，接口中的该方法将会被调用：

        HttpSessionListener.sessionDestroyed (HttpSessionEvent se)

  • Session域对象创建和销毁：

    • 创建：浏览器访问服务器时，服务器为每个浏览器创建不同的 session 对象，服务器创建session

    • 销毁：如果用户的session的30分钟没有使用，session就会过期，我们在Tomcat的web.xml里面也可以配置session过期时间。

  • demo：

      package cn.itcast.servlet.listener;
  
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpSessionEvent;
  import javax.servlet.http.HttpSessionListener;
  
  public class MyHttpSessionListener implements HttpSessionListener {
  
      @Override
      public void sessionCreated(HttpSessionEvent se) {
          // 通过事件对象获得session 的id 
          System.out.println("session被创建了");
          HttpSession session = se.getSession();
          System.out.println("id:" + session.getId());
      }
  
      @Override
      public void sessionDestroyed(HttpSessionEvent se) {
          System.out.println("session被销毁了");
          HttpSession session = se.getSession();
          System.out.println("id:" + session.getId());
      }
  
  }

关于HttpSession的生命周期、具体描述详见：JSP 会话管理

3.3、ServletRequestListener（很少用）

  • ServletRequestListener 接口用于监听ServletRequest 对象的创建和销毁：

    • ServletRequest对象被创建时，监听器的requestInitialized方法将会被调用。

    • ServletRequest对象被销毁时，监听器的requestDestroyed方法将会被调用。

  • ServletRequest域对象创建和销毁的时机：

    • 创建：用户每一次访问，都会创建一个reqeust

    • 销毁：当前访问结束，request对象就会销毁

  • 这个监听器最需要注意的：

    • 使用forward ---- request创建销毁一次 （因为转发本质是一次请求）

    • 使用sendRedirect ---- request创建销毁两次 （因为重定向本质是两次请求）

关于ServletRequest详见：//www.greatytc.com/p/7e2e3fd58e91

3.4、案例：统计在线人数

  • 图解：

  • 首先，初始化在线人数，根据前文，ServletContextListener可以监听ServletContext对象的创建，所以新建一个实现监听器接口的类：

      package cn.itcast.servlet.listener.demo2;
  
  import javax.servlet.ServletContext;
  import javax.servlet.ServletContextEvent;
  import javax.servlet.ServletContextListener;
  
  public class OnlineCountServletContextListener implements
          ServletContextListener {
  
      @Override
      public void contextDestroyed(ServletContextEvent sce) {
      }
  
      @Override
      public void contextInitialized(ServletContextEvent sce) {
          // 初始化在线人数为0
          ServletContext context = sce.getServletContext();
          context.setAttribute("onlinenum", 0);
      }
  
  }

  • 利用HttpSessionListener监听HttpSession对象的创建和销毁，可以统计在线人数：

      package cn.itcast.servlet.listener.demo2;
  
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpSessionEvent;
  import javax.servlet.http.HttpSessionListener;
  
  public class OnlineCountHttpSessionListener implements HttpSessionListener {
  
      @Override
      public void sessionCreated(HttpSessionEvent se) {
          // 当Session对象被创建时，在线人数 +1
          HttpSession session = se.getSession();
          ServletContext context = session.getServletContext();
  
          int onlinenum = (Integer) context.getAttribute("onlinenum");
          context.setAttribute("onlinenum", onlinenum + 1);
  
          System.out.println(session.getId() + "被创建了...");
      }
  
      @Override
      public void sessionDestroyed(HttpSessionEvent se) {
          // 当Session对象被销毁时，在线人数 - 1
          HttpSession session = se.getSession();
          ServletContext context = session.getServletContext();
  
          int onlinenum = (Integer) context.getAttribute("onlinenum");
          context.setAttribute("onlinenum", onlinenum - 1);
  
          System.out.println(session.getId() + "被销毁了 ...");
      }
  
  }

  • 别忘了在web.xml中配置：

      <listener>
      <listener-class>cn.itcast.servlet.listener.demo2.OnlineCountServletContextListener</listener-class>
  </listener>
  <listener>
      <listener-class>cn.itcast.servlet.listener.demo2.OnlineCountHttpSessionListener</listener-class>
  </listener>

  • 简单创建一个JSP页面（注意，JSP作用域中applicationScope的范围是整个服务器，所以可以得到ServletContext对象中存储的值）：

      <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Insert title here</title>
  </head>
  <body>
  <h1>显示在线人数</h1>
  ${applicationScope.onlinenum }
  </body>
  </html>

3.5、案例：利用定时器定时销毁Session

  • 图解：

  • ScannerServletContextListener干了两件事：初始化List<HttpSession>；启动定时器，每隔20秒执行一次。

    注意：

    因为要从List中删除元素，所以循环用Iterator而不用foreach。

    在使用扫描删除Session对象时，要保证Session的List集合长度不能改变（即此时此刻不能添加新的Session） ---- 利用同步解决 synchronized

      package cn.itcast.servlet.listener.demo3;
  
  import java.util.ArrayList;
  import java.util.Iterator;
  import java.util.List;
  import java.util.Timer;
  import java.util.TimerTask;
  
  import javax.servlet.ServletContext;
  import javax.servlet.ServletContextEvent;
  import javax.servlet.ServletContextListener;
  import javax.servlet.http.HttpSession;
  
  public class ScannerServletContextListener implements ServletContextListener {
  
      @Override
      public void contextDestroyed(ServletContextEvent sce) {
      }
  
      @Override
      public void contextInitialized(ServletContextEvent sce) {
          // 第一件事，创建Session的List集合
          final List<HttpSession> sessionList = new ArrayList<HttpSession>();
          // 将集合保存ServletContext对象
          ServletContext servletContext = sce.getServletContext();
          servletContext.setAttribute("sessionList", sessionList);
  
          // 第二件事，启动定时器，每隔20秒执行一次
          Timer timer = new Timer();
          timer.schedule(new TimerTask() {
              @Override
              public void run() {
                  System.out.println("定时session扫描器执行了....");
                  // 扫描Session的List集合，看哪个Session已经1分钟没用了
                  // 发现Session1分钟没有使用，销毁Session 从集合移除
                  synchronized (sessionList) {
                      Iterator<HttpSession> iterator = sessionList.iterator();
                      while (iterator.hasNext()) {
                          HttpSession session = iterator.next();
                          if (System.currentTimeMillis()
                                  - session.getLastAccessedTime() > 1000 * 60) {
                              System.out.println(session.getId()
                                      + "对象已经1分钟没有使用，被销毁了...");
                              // 销毁Session
                              session.invalidate();
                              // 从集合移除Session
                              iterator.remove();
  
                          }
                      }
                  }
              }
          }, 0, 20000);
      }
  
  }

  • ScannerHttpSessionListener：

      package cn.itcast.servlet.listener.demo3;
  
  import java.util.List;
  
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpSessionEvent;
  import javax.servlet.http.HttpSessionListener;
  
  public class ScannerHttpSessionListener implements HttpSessionListener {
  
      @Override
      public void sessionCreated(HttpSessionEvent se) {
          // 在创建Session对象时，将Session对象加入集合
          HttpSession httpSession = se.getSession();
          ServletContext context = httpSession.getServletContext();
  
          List<HttpSession> sessionList = (List<HttpSession>) context
                  .getAttribute("sessionList");
          synchronized (sessionList) {
              sessionList.add(httpSession);
          }
  
          // 还是否需要context.setAttribute？ ---- 不需要：因为之前得到的是List的地址
          context.setAttribute("sessionList", sessionList); // 这行代码写不写无所谓
  
          System.out.println(httpSession.getId() + "被创建了...");
      }
  
      @Override
      public void sessionDestroyed(HttpSessionEvent se) {
      }
  
  }

  • 配置：

      <listener>
      <listener-class>cn.itcast.servlet.listener.demo3.ScannerServletContextListener</listener-class>
  </listener>
  <listener>
      <listener-class>cn.itcast.servlet.listener.demo3.ScannerHttpSessionListener</listener-class>
  </listener>

4、监听三个域对象的属性(Attribute)的变化的事件监听器

  • Servlet规范定义了监听 ServletContext, HttpSession, HttpServletRequest 这三个对象中的属性(Attribute)变更信息事件的监听器。

  • 这三个监听器接口分别是

    • ServletContextAttributeListener

    • HttpSessionAttributeListener

    • ServletRequestAttributeListener

  • 这三个接口中都定义了三个方法来处理被监听对象中的属性的增加，删除和替换的事件，同一个事件在这三个接口中对应的方法名称完全相同，只是接受的参数类型不同

  • XXListener.attributeAdded(XXEvent)

    • 当向被监听器对象中增加一个属性时，web容器就调用事件监听器的 attributeAdded 方法进行相应，这个方法接受一个事件类型的参数，监听器可以通过这个参数来获得正在增加属性的域对象和被保存到域中的属性对象

    • 各个域属性监听器中的完整语法定义为：

        public void attributeAdded(ServletContextAttributeEvent scae)
  public void attributeAdded (HttpSessionBindingEvent  hsbe) 
  public void attributeAdded(ServletRequestAttributeEvent srae)

  • XXListener.attributeRemoved(XXEvent)

    • 当删除被监听对象中的一个属性时，web 容器调用事件监听器的这个方法进行相应

    • 各个域属性监听器中的完整语法定义为：

        public void attributeRemoved(ServletContextAttributeEvent scae) 
  public void attributeRemoved (HttpSessionBindingEvent  hsbe) 
  public void attributeRemoved (ServletRequestAttributeEvent srae)

  • XXListener.attributeReplaced(XXEvent)

    • 当监听器的域对象中的某个属性被替换时，web容器调用事件监听器的这个方法进行相应

    • 各个域属性监听器中的完整语法定义为：

        public void attributeReplaced(ServletContextAttributeEvent scae) 
  public void attributeReplaced (HttpSessionBindingEvent  hsbe) 
  public void attributeReplaced (ServletRequestAttributeEvent srae)

  • 由于这三个监听器用法极其相似，所以只用一个例子来演示具体用法：

  • 新建有一个JSP页面：

      <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Insert title here</title>
  </head>
  <body>
  <%
      // 向Session数据范围 保存名称为"name"，值为"张三"的属性(Attribute)
      session.setAttribute("name","张三"); // 触发attributeAdd

      // 将session中属性(Attribute)名为"name"的值替换为"李四"
      session.setAttribute("name","李四"); // 触发attributeReplaced

      // 移除名为"name"的属性
      session.removeAttribute("name");// 触发attributeRemoved
  %>
  </body>
  </html>

  • MyHttpSessionAttributeListener：

      package cn.itcast.servlet.listener;
  
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpSessionAttributeListener;
  import javax.servlet.http.HttpSessionBindingEvent;
  
  public class MyHttpSessionAttributeListener implements
          HttpSessionAttributeListener {
  
      @Override
      public void attributeAdded(HttpSessionBindingEvent se) {
          // 属性添加
          System.out.println("向session添加了一个属性...");
          HttpSession session = se.getSession();
  
          System.out.println("属性名称：" + se.getName());
          System.out.println("属性值：" + session.getAttribute(se.getName())); // se.getValue ：这个方法不会返回当前属性(Attribute)的值
      }
  
      @Override
      public void attributeRemoved(HttpSessionBindingEvent se) {
          // 属性移除
          System.out.println("从session移除了一个属性....");
  
          System.out.println("属性名称：" + se.getName());
  
      }
  
      @Override
      public void attributeReplaced(HttpSessionBindingEvent se) {
          // 属性替换
          System.out.println("将session中一个属性值替换为其他值...");
  
          HttpSession session = se.getSession();
          System.out.println("属性名称：" + se.getName());
          System.out.println("属性值：" + session.getAttribute(se.getName()));
      }
  
  }

5、监听绑定到 HttpSession 域中的某个对象的状态的事件监听器

  • 保存在 Session 域中的对象可以有多种状态：

    • 绑定到 Session 中；

    • 从 Session 域中解除绑定；

    • 随 Session 对象持久化到一个存储设备中(钝化)；

    • 随 Session 对象从一个存储设备中恢复（活化）

  • Servlet 规范中定义了两个特殊的监听器接口来帮助 JavaBean 对象了解自己在 Session 域中的这些状态：HttpSessionBindingListener 接口和 HttpSessionActivationListener 接口，实现这两个接口的类不需要 web.xml 文件中注册，因为监听方法调用，都是由Session自主完成的

    • HttpSessionBindingListener

      实现该接口的 Java 对象，可以感知自己被绑定到 Session 或者从 Session 中解除绑定

    • HttpSessionActivationListener

      实现该接口的 Java 对象，可以感知自己从内存被钝化硬盘上，或者从硬盘被活化到内存中

5.1、HttpSessionBindingListener接口

  • 实现了 HttpSessionBindingListener 接口的 JavaBean 对象可以感知自己被绑定到 Session 中和从 Session 中删除的事件

    • 绑定：当对象被绑定到 HttpSession 对象中时，web 服务器调用该 JavaBean 对象的 valueBound 方法

        public void valueBound(HttpSessionBindingEvent event)

    • 解绑：当对象从 HttpSession 对象中解除绑定时，web 服务器调用该 JavaBean 对象的 valueUnbound 方法

        public void valueUnbound(HttpSessionBindingEvent event)

  • demo：

    • 实现 HttpSessionBindingListener 接口的 JavaBean ：

        package cn.itcast.domain;
  
  import javax.servlet.http.HttpSessionBindingEvent;
  import javax.servlet.http.HttpSessionBindingListener;
  
  /**
   * 使Bean1对象感知 自我被绑定Session中，感知自我被Session解除绑定
   * 
   * @author seawind
   * 
   */
  public class Bean1 implements HttpSessionBindingListener {
      private int id;
      private String name;
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      @Override
      public void valueBound(HttpSessionBindingEvent event) {
          System.out.println("Bean1对象被绑定了...");
          // 当前对象，操作对象
          System.out.println("绑定对象name:" + this.name);
      }
  
      @Override
      public void valueUnbound(HttpSessionBindingEvent event) {
          System.out.println("Bean1对象被解除绑定了...");
          System.out.println("解除绑定对象name:" + this.name);
      }
  
  }

    • 新建一个JSP页面，里面有如下代码：

        <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <%@page import="cn.itcast.domain.Bean1"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Insert title here</title>
  </head>
  <body>
  <%
      Bean1 bean_Susan = new Bean1();
      bean_Susan.setId(100);
      bean_Susan.setName("Susan");
      
      // 将bean_Susan对象以“bean1”为名，绑定到Session中
      session.setAttribute("bean1",bean_Susan);
      
      Bean1 bean_Mary = new Bean1();
      bean_Mary.setId(200);
      bean_Mary.setName("Mary");

      // 将bean_Susan对象以“bean1”为名，绑定到Session中
      session.setAttribute("bean1",bean_Mary);
  %>
  ${bean1.name }
  </body>
  </html>

    • 此时若开启服务器，打开这个JSP页面，控制台会输出什么呢？

        Bean1对象被绑定了...
  绑定对象name:bean_Susan
  Bean1对象被绑定了...
  绑定对象name:bean_Mary
  Bean1对象被解除绑定了...
  解除绑定对象name:bean_Susan

    • 注意陷阱：当 Session 绑定的 JavaBean 对象替换时，会让新对象绑定，旧对象解绑

5.2、HttpSessionActivationListener接口

  • 实现了HttpSessionActivationListener接口的 JavaBean 对象可以感知自己被活化和钝化的事件

    • 当绑定到 HttpSession 对象中的 JavaBean 对象将要随 HttpSession 对象被钝化之前，web 服务器调用该 JavaBean 对象的 void sessionWillPassivate(HttpSessionBindingEvent event) 方法

    • 当绑定到 HttpSession 对象中的 JavaBean 对象将要随 HttpSession 对象被活化之后，web 服务器调用该 JavaBean 对象的 void sessionDidActive(HttpSessionBindingEvent event) 方法

  • 使用场景：Session保存数据，很长一段时间没用，但是不能销毁Session对象，又不想占用服务器内存资源 ----- 钝化（将服务器内存中数据序列化硬盘上）

  • 钝化和活化应该由 Tomcat 服务器 自动进行，所以应该配置 Tomcat ：

      <Context>
      <!-- 1分钟不用 进行钝化  表示1分钟 -->
      <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
          <!-- 钝化后文件存储位置  directory="it315" 存放到it315目录-->
          <Store className="org.apache.catalina.session.FileStore" directory="it315"/>
      </Manager>
  </Context>

    配置context有几个位置？

    1、tomcat/conf/context.xml 对所有虚拟主机 所有web工程生效

    2、tomcat/conf/Catalina/localhost/context.xml 对当前虚拟主机所有web工程生效

    3、当前工程/META-INF/context.xml 对当前工程有效

  • demo：

    • write.jsp：

        <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <%@page import="cn.itcast.domain.Bean2"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Insert title here</title>
  </head>
  <body>
  <!-- 将javabean 对象保存Session中 -->
  <%
      Bean2 bean2 = new Bean2();
      bean2.setName("联想笔记本");
      bean2.setPrice(5000);
      
      session.setAttribute("bean2",bean2);
  %>
  </body>
  </html>

    • read.jsp：

        <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Insert title here</title>
  </head>
  <body>
  <!-- 读取javabean对象的数据 -->
  读取bean2的数据： ${bean2.name } , ${bean2.price }
  </body>
  </html>

    • Bean2.java：

        package cn.itcast.domain;
  
  import javax.servlet.http.HttpSessionActivationListener;
  import javax.servlet.http.HttpSessionEvent;
  
  /**
   * 感知钝化和活化
   * 
   * @author seawind
   * 
   */
  public class Bean2 implements HttpSessionActivationListener {
      private String name;
      private double price;
  
      public String getName() {
          return name;
      }
  
      public void setName(String name) {
          this.name = name;
      }
  
      public double getPrice() {
          return price;
      }
  
      public void setPrice(double price) {
          this.price = price;
      }
  
      @Override
      public void sessionDidActivate(HttpSessionEvent se) {
          System.out.println("bean2对象被活化...");
      }
  
      @Override
      public void sessionWillPassivate(HttpSessionEvent se) {
          System.out.println("bean2对象被钝化...");
      }
  
  }

    • 配置Tomcat后，开启服务器，打开write.jsp，等待一分钟，在这一分钟内，打开read.jsp是可以读取到bean2对象的。一分钟过后，read.jsp读取不到bean2对象了，同时控制台输出：

        bean2对象被钝化...

    • 这时候就实现了钝化的效果。好，接下来按照步骤走，钝化后it315目录在哪里？ 在项目文件夹是找不到这个目录的，得去Tomcat服务器的目录去找：

        tomcat/work/Catalina/localhost/项目工程名/

    • 在it315目录中的确可以看到一个XXXXXX.session的文件，其中XXXXXX就是SessionId，打开这个文件，却没有发现 JavaBean 的任何信息，这是为什么呢？

    • 回顾JavaSE的知识，可以发现 JavaBean 没有序列化。Java对象如果想被序列化，必须实现Serializable接口 ---- Bean2 实现该接口：

        import java.io.Serializable;
  ...
  public class Bean2 implements HttpSessionActivationListener, Serializable {
  ...
  ｝

    • 接下来，重启服务器，打开write.jsp，一分钟后，控制台照旧输出bean2对象被钝化的消息，再进去XXXXXX.session文件中，发现可以找到 JavaBean 对象的相关信息（虽然是乱码）。接下来再打开read.jsp，发现可以读取到 JavaBean 对象了，并且此时控制台输出：

        bean2对象被活化...

    • 这就是一种对于Session的优化策略

5.3、案例：在线用户列表和踢人功能

  • 图解：

  • demo：

    • MyServletContextListener：

        package cn.itcast.listener;
  
  import java.util.HashMap;
  import java.util.Map;
  
  import javax.servlet.ServletContext;
  import javax.servlet.ServletContextEvent;
  import javax.servlet.ServletContextListener;
  import javax.servlet.http.HttpSession;
  
  import cn.itcast.domain.User;
  
  /**
   * 完成全局数据对象初始化
   * 
   * @author seawind
   * 
   */
  public class MyServletContextListener implements ServletContextListener {
  
      @Override
      public void contextDestroyed(ServletContextEvent sce) {
      }
  
      @Override
      public void contextInitialized(ServletContextEvent sce) {
          // 所有在线用户数据集合
          Map<User, HttpSession> map = new HashMap<User, HttpSession>();
          // 将集合保存ServletContext 数据范围
          ServletContext servletContext = sce.getServletContext();
  
          servletContext.setAttribute("map", map);
      }
  
  }

    • JavaBean：

        package cn.itcast.domain;
  
  import java.util.Map;
  
  import javax.servlet.ServletContext;
  import javax.servlet.http.HttpSession;
  import javax.servlet.http.HttpSessionBindingEvent;
  import javax.servlet.http.HttpSessionBindingListener;
  
  /**
   * User对象自我感知，绑定Session和解除绑定
   */
  public class User implements HttpSessionBindingListener {
      private int id;
      private String username;
      private String password;
      private String role;
  
      public int getId() {
          return id;
      }
  
      public void setId(int id) {
          this.id = id;
      }
  
      public String getUsername() {
          return username;
      }
  
      public void setUsername(String username) {
          this.username = username;
      }
  
      public String getPassword() {
          return password;
      }
  
      public void setPassword(String password) {
          this.password = password;
      }
  
      public String getRole() {
          return role;
      }
  
      public void setRole(String role) {
          this.role = role;
      }
  
      @Override
      public void valueBound(HttpSessionBindingEvent event) {
          // 将新建立Session 和 用户 保存ServletContext 的Map中
          HttpSession session = event.getSession();
          ServletContext servletContext = session.getServletContext();
  
          Map<User, HttpSession> map = (Map<User, HttpSession>) servletContext
                  .getAttribute("map");
  
          // 将新用户加入map
          map.put(this, session);
      }
  
      @Override
      public void valueUnbound(HttpSessionBindingEvent event) {
          // 根据user对象，从Map中移除Session
          HttpSession session = event.getSession();
          ServletContext servletContext = session.getServletContext();
  
          Map<User, HttpSession> map = (Map<User, HttpSession>) servletContext
                  .getAttribute("map");
  
          // 从map移除
          map.remove(this);
      }
  
  }

    • LoginServlet：

        package cn.itcast.servlet;
  
  import java.io.IOException;
  import java.sql.SQLException;
  import java.util.Map;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  
  import org.apache.commons.dbutils.QueryRunner;
  import org.apache.commons.dbutils.handlers.BeanHandler;
  
  import cn.itcast.domain.User;
  import cn.itcast.utils.JDBCUtils;
  
  /**
   * 登陆
   * 
   * @author seawind
   * 
   */
  public class LoginServlet extends HttpServlet {
  
      public void doGet(HttpServletRequest request, HttpServletResponse response)
              throws ServletException, IOException {
          request.setCharacterEncoding("utf-8");
  
          String username = request.getParameter("username");
          String password = request.getParameter("password");
  
          String sql = "select * from user where username = ? and password = ?";
          Object[] args = { username, password };
  
          QueryRunner queryRunner = new QueryRunner(JDBCUtils.getDataSource());
          try {
              User user = queryRunner.query(sql,
                      new BeanHandler<User>(User.class), args);
              // 判断登陆是否成功
              if (user == null) {
                  // 失败
                  request.setAttribute("msg", "用户名或者密码错误！");
                  request.getRequestDispatcher("/login.jsp").forward(request,
                          response);
              } else {
                  // 成功
                  request.getSession().invalidate();// 销毁之前状态
  
                  // 先判断该用户是否已经登陆，如果已经登陆，将Session销毁
                  Map<User, HttpSession> map = (Map<User, HttpSession>) getServletContext()
                          .getAttribute("map");
                  for (User hasLoginUser : map.keySet()) {
                      if (hasLoginUser.getUsername().equals(user.getUsername())) {
                          // 此用户之前登陆过 --- 消灭Session
                          HttpSession hasLoginSession = map.get(hasLoginUser);
                          hasLoginSession.invalidate();// session 被摧毁，移除所有对象
                          // 若不使用break，则会调用map的remove方法（invalidate -> valueUnbound），发生并发异常
                          break; 
                      }
                  }
  
                  request.getSession().setAttribute("user", user); // 将user对象绑定到Session，触发valueBound
                  response.sendRedirect("/day18kick/list.jsp");
              }
          } catch (SQLException e) {
              e.printStackTrace();
          }
      }
  
      public void doPost(HttpServletRequest request, HttpServletResponse response)
              throws ServletException, IOException {
          doGet(request, response);
      }
  
  }

    • KickServlet：

        package cn.itcast.servlet;
  
  import java.io.IOException;
  import java.util.Map;
  
  import javax.servlet.ServletException;
  import javax.servlet.http.HttpServlet;
  import javax.servlet.http.HttpServletRequest;
  import javax.servlet.http.HttpServletResponse;
  import javax.servlet.http.HttpSession;
  
  import cn.itcast.domain.User;
  
  /**
   * 接收被踢id
   * 
   * @author seawind
   * 
   */
  public class KickServlet extends HttpServlet {
  
      public void doGet(HttpServletRequest request, HttpServletResponse response)
              throws ServletException, IOException {
          String id = request.getParameter("id");// 被踢人 id
  
          Map<User, HttpSession> map = (Map<User, HttpSession>) getServletContext()
                  .getAttribute("map");
          // 查找目标id
          for (User hasLoginUser : map.keySet()) {
              if (hasLoginUser.getId() == Integer.parseInt(id)) {
                  // 找到被踢用户记录
                  HttpSession hasLoginSession = map.get(hasLoginUser);
                  hasLoginSession.invalidate();
                  break;
              }
          }
          // 跳转回 列表页面
          response.sendRedirect("/day18kick/list.jsp");
      }
  
      public void doPost(HttpServletRequest request, HttpServletResponse response)
              throws ServletException, IOException {
          doGet(request, response);
      }
  
  }

    • list.jsp：

        <%@ page language="java" contentType="text/html; charset=UTF-8"
      pageEncoding="UTF-8"%>
  <%@taglib uri="http://java.sun.com/jsp/jstl/core" prefix="c"%>
  <!DOCTYPE html PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">
  <html>
  <head>
  <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
  <title>Insert title here</title>
  </head>
  <body>
  <h1>在线用户列表</h1>
  <h2>当前用户 ${user.username }</h2>
  <!-- 将ServletContext中 map 数据显示出来 -->
  <c:forEach items="${map}" var="entry">
      <!-- 只有管理员可以踢人 -->
      <!-- 管理员不能被踢 -->
      ${entry.key.username } 
      <c:if test="${user.role == 'admin' && entry.key.role != 'admin' }">
          <a href="/day18kick/kick?id=${entry.key.id}">踢下线</a> 
      </c:if>
      <br/>
  </c:forEach>
  </body>
  </html>
最后编辑于 ：
©著作权归作者所有,转载或内容合作请联系作者
  • 人面猴
    序言：七十年代末，一起剥皮案震惊了整个滨河市，随后出现的几起案子，更是在滨河造成了极大的恐慌，老刑警刘岩，带你破解...
    沈念sama阅读 193,968评论 5赞 459
  • 死咒
    序言：滨河连续发生了三起死亡事件，死亡现场离奇诡异，居然都是意外死亡，警方通过查阅死者的电脑和手机，发现死者居然都...
    沈念sama阅读 81,682评论 2赞 371
  • 救了他两次的神仙让他今天三更去死
    文/潘晓璐 我一进店门，熙熙楼的掌柜王于贵愁眉苦脸地迎上来，“玉大人，你说我怎么就摊上这事。” “怎么了？”我有些...
    开封第一讲书人阅读 141,254评论 0赞 319
  • 道士缉凶录：失踪的卖姜人
    文/不坏的土叔 我叫张陵，是天一观的道长。 经常有香客问我，道长，这世上最难降的妖魔是什么？ 我笑而不...
    开封第一讲书人阅读 52,074评论 1赞 263
  • 港岛之恋（遗憾婚礼）
    正文 为了忘掉前任，我火速办了婚礼，结果婚礼上，老公的妹妹穿的比我还像新娘。我一直安慰自己，他们只是感情好，可当我...
    茶点故事阅读 60,964评论 4赞 355
  • 恶毒庶女顶嫁案：这布局不是一般人想出来的
    文/花漫 我一把揭开白布。 她就那样静静地躺着，像睡着了一般。 火红的嫁衣衬着肌肤如雪。 梳的纹丝不乱的头发上，一...
    开封第一讲书人阅读 46,055评论 1赞 272
  • 城市分裂传说
    那天，我揣着相机与录音，去河边找鬼。 笑死，一个胖子当着我的面吹牛，可吹牛的内容都是我干的。 我是一名探鬼主播，决...
    沈念sama阅读 36,484评论 3赞 381
  • 双鸳鸯连环套：你想象不到人心有多黑
    文/苍兰香墨 我猛地睁开眼，长吁一口气：“原来是场噩梦啊……” “哼！你这毒妇竟也来了？” 一声冷哼从身侧响起，我...
    开封第一讲书人阅读 35,170评论 0赞 253
  • 万荣杀人案实录
    序言：老挝万荣一对情侣失踪，失踪者是张志新（化名）和其女友刘颖，没想到半个月后，有当地人在树林里发现了一具尸体，经...
    沈念sama阅读 39,433评论 1赞 290
  • 护林员之死
    正文 独居荒郊野岭守林人离奇死亡，尸身上长有42处带血的脓包…… 初始之章·张勋 以下内容为张勋视角 年9月15日...
    茶点故事阅读 34,512评论 2赞 308
  • 白月光启示录
    正文 我和宋清朗相恋三年，在试婚纱的时候发现自己被绿了。 大学时的朋友给我发了我未婚夫和他白月光在一起吃饭的照片。...
    茶点故事阅读 36,296评论 1赞 325
  • 活死人
    序言：一个原本活蹦乱跳的男人离奇死亡，死状恐怖，灵堂内的尸体忽然破棺而出，到底是诈尸还是另有隐情，我是刑警宁泽，带...
    沈念sama阅读 32,184评论 3赞 312
  • 日本核电站爆炸内幕
    正文 年R本政府宣布，位于F岛的核电站，受9级特大地震影响，放射性物质发生泄漏。R本人自食恶果不足惜，却给世界环境...
    茶点故事阅读 37,545评论 3赞 298
  • 男人毒药：我在死后第九天来索命
    文/蒙蒙 一、第九天 我趴在偏房一处隐蔽的房顶上张望。 院中可真热闹，春花似锦、人声如沸。这庄子的主人今日做“春日...
    开封第一讲书人阅读 28,880评论 0赞 17
  • 一桩弑父案，背后竟有这般阴谋
    文/苍兰香墨 我抬头看了看天上的太阳。三九已至，却和暖如春，着一层夹袄步出监牢的瞬间，已是汗流浃背。 一阵脚步声响...
    开封第一讲书人阅读 30,150评论 1赞 250
  • 情欲美人皮
    我被黑心中介骗来泰国打工， 没想到刚下飞机就差点儿被人妖公主榨干…… 1. 我叫王不留，地道东北人。 一个月前我还...
    沈念sama阅读 41,437评论 2赞 341
  • 代替公主和亲
    正文 我出身青楼，却偏偏与公主长得像，于是被迫代替她去往敌国和亲。 传闻我的和亲对象是个残疾皇子，可洞房花烛夜当晚...
    茶点故事阅读 40,630评论 2赞 335

推荐阅读更多精彩内容

  • 监听器/过滤器(Servlet Listener / Filter)
    监听器(listener) 监听器简介 :监听器就是一个实现特定接口的普通java程序，这个程序专门用于监听另一个...
    奋斗的老王阅读 2,461评论 0赞 53
  • Java初级面试题
    1. Java基础部分 基础部分的顺序：基本语法，类相关的语法，内部类的语法，继承相关的语法，异常的语法，线程的语...
    子非鱼_t_阅读 31,493评论 18赞 399
  • Java面试
    一. Java基础部分.................................................
    wy_sure阅读 3,774评论 0赞 11
  • Java Web之Filter
    本文包括：1、Filter简介2、Filter是如何实现拦截的？3、Filter开发入门4、Filter的生命周期...
    廖少少阅读 7,222评论 3赞 56
  • Java后台面试 常见问题
    从三月份找实习到现在，面了一些公司，挂了不少，但最终还是拿到小米、百度、阿里、京东、新浪、CVTE、乐视家的研发岗...
    时芥蓝阅读 42,136评论 11赞 349