0
点赞
收藏
分享

微信扫一扫

JavaWeb开发与代码的编写(十九)


JavaWeb开发与代码的编写(十九)

监听器(Listener)

监听器的概念

 

JavaWeb开发与代码的编写(十九)_事件源

  监听器是一个专门用于对其他对象身上发生的事件或状态改变进行监听和相应处理的对象,当被监视的对象发生情况时,立即采取相应的行动。监听器其实就是一个实现特定接口的普通java程序,这个程序专门用于监听另一个java对象的方法调用或属性改变,当被监听对象发生上述事件后,监听器某个方法立即被执行。

监听器案例——监听window窗口的事件监听器

1 package me.gacl.listener.demo;
 2 
 3 import java.awt.Frame;
 4 import java.awt.event.WindowEvent;
 5 import java.awt.event.WindowListener;
 6 
 7 public class Demo1 {
 8 
 9     /**
10      *java的事件监听机制
11      *1、事件监听涉及到三个组件:事件源、事件对象、事件监听器
12      *2、当事件源上发生某一个动作时,它会调用事件监听器的一个方法,并在调用该方法时把事件对象传递进去,
13      *    开发人员在监听器中通过事件对象,就可以拿到事件源,从而对事件源进行操作。
14      */
15     public static void main(String[] args) {
16         
17         Frame f = new Frame();
18         f.setSize(400, 400);
19         f.setVisible(true);
20         
21         //注册事件监听器
22         f.addWindowListener(new WindowListener(){
23 
24             public void windowActivated(WindowEvent e) {
25                 
26             }
27 
28             public void windowClosed(WindowEvent e) {
29                 
30             }
31 
32             /**
33              * 当window窗体关闭时就会WindowListener这个监听器监听到,
34              * 监听器就会调用windowClosing方法处理window窗体关闭时的动作
35              */
36             public void windowClosing(WindowEvent e) {
37                 //通过事件对象e来获取事件源对象
38                 Frame f = (Frame) e.getSource();
39                 System.out.println(f+"窗体正在关闭");
40                 f.dispose();
41             }
42 
43             public void windowDeactivated(WindowEvent e) {
44                 
45             }
46 
47             public void windowDeiconified(WindowEvent e) {
48                 
49             }
50 
51             public void windowIconified(WindowEvent e) {
52                 
53             }
54 
55             public void windowOpened(WindowEvent e) {
56                 
57             }
58         });
59     }
60 }

设计一个可以被别的对象监听的对象

  我们平时做开发的时候,我们是写监听器去监听其他对象,那么我们如果想设计一个对象,让这个对象可以被别的对象监听又该怎么做呢,可以按照严格的事件处理模型来设计一个对象,这个对象就可以被别的对象监听,事件处理模型涉及到三个组件:事件源、事件对象、事件监听器。

  下面我们来按照事件处理模型来设计一个Person对象具体代码如下:

1 package me.gacl.observer;
  2 
  3 /**
  4 * @ClassName: Person(事件源)
  5 * @Description: 设计一个Person类作为事件源,这个类的对象的行为(比如吃饭、跑步)可以被其他的对象监听
  8 *
  9 */  
 10 public class Person {
 11     /**
 12     * @Field: listener
 13     *          在Person类中定义一个PersonListener变量来记住传递进来的监听器
 14     */ 
 15     private PersonListener listener;
 16 
 17     /**
 18     * @Method: eat
 19     * @Description: 设计Person的行为:吃
 21     *
 22     */ 
 23     public void eat() {
 24         if (listener != null) {
 25             /**
 26              * 调用监听器的doeat方法监听Person类对象eat(吃)这个动作,将事件对象Event传递给doeat方法,
 27              * 事件对象封装了事件源,new Event(this)中的this代表的就是事件源
 28              */
 29             listener.doeat(new Event(this));
 30         }
 31     }
 32 
 33     /**
 34     * @Method: run
 35     * @Description: 设计Person的行为:跑
 37     *
 38     */ 
 39     public void run() {
 40         if (listener != null) {
 41             /**
 42              * 调用监听器的dorun方法监听Person类对象run(跑)这个动作,将事件对象Event传递给doeat方法,
 43              * 事件对象封装了事件源,new Event(this)中的this代表的就是事件源
 44              */
 45             listener.dorun(new Event(this));
 46         }
 47     }
 48 
 49     /**
 50     * @Method: registerListener
 51     * @Description: 这个方法是用来注册对Person类对象的行为进行监听的监听器
 54     * @param listener
 55     */ 
 56     public void registerListener(PersonListener listener) {
 57         this.listener = listener;
 58     }
 59 }
 60 
 61 /**
 62 * @ClassName: PersonListener(事件监听器)
 63 * @Description: 设计Person类(事件源)的监听器接口
 66 *
 67 */ 
 68 interface PersonListener {
 69 
 70     /**
 71     * @Method: doeat
 72     * @Description: 这个方法是用来监听Person对象eat(吃)这个行为动作,
 73     *                 当实现类实现doeat方法时就可以监听到Person类对象eat(吃)这个动作
 76     * @param e
 77     */ 
 78     void doeat(Event e);
 79 
 80     /**
 81     * @Method: dorun
 82     * @Description: 这个方法是用来监听Person对象run(跑)这个行为动作,
 83     *                 当实现类实现dorun方法时就可以监听到Person类对象run(跑)这个动作
 84     * @Anthor:孤傲苍狼
 85     *
 86     * @param e
 87     */ 
 88     void dorun(Event e);
 89 
 90 }
 91 
 92 /**
 93 * @ClassName: Event(事件对象)
 94 * @Description:设计事件类,用来封装事件源
 97 *
 98 */ 
 99 class Event {
100 
101     /**
102     * @Field: source
103     *          事件源(Person就是事件源)
104     */ 
105     private Person source;
106 
107     public Event() {
108         
109     }
110 
111     public Event(Person source) {
112         this.source = source;
113     }
114 
115     public Person getSource() {
116         return source;
117     }
118 
119     public void setSource(Person source) {
120         this.source = source;
121     }
122 }

  经过这样的设计之后,Peron类的对象就是可以被其他对象监听了。测试代码如下:

package me.gacl.observer;
 
 public class PersonTest {
 
     /**
      * @Method: main
      * @Description: 测试Person类
      *
      * @param args
      */
    public static void main(String[] args) {
         //
         Person p = new Person();
         //注册监听p对象行为的监听器
         p.registerListener(new PersonListener() {
             //监听p吃东西这个行为
             public void doeat(Event e) {
                 Person p = e.getSource();
                 System.out.println(p + "在吃东西");
             }
             //监听p跑步这个行为
            public void dorun(Event e) {
                 Person p = e.getSource();
                 System.out.println(p + "在跑步");
             }
         });
        //p在吃东西
         p.eat();
         //p在跑步
         p.run();
     }
 }

运行结果:

  me.gacl.observer.Person@4a5ab2在吃东西
  me.gacl.observer.Person@4a5ab2在跑步

 

JavaWeb中的监听器

基本概念

  JavaWeb中的监听器是Servlet规范中定义的一种特殊类,它用于监听web应用程序中的ServletContext, HttpSession和 ServletRequest等域对象的创建与销毁事件,以及监听这些域对象中的属性发生修改的事件。

Servlet监听器的分类

  在Servlet规范中定义了多种类型的监听器,它们用于监听的事件源分别为ServletContextHttpSessionServletRequest这三个域对象
  Servlet规范针对这三个对象上的操作,又把多种类型的监听器划分为三种类型:

  1. 监听域对象自身的创建和销毁的事件监听器。
  2. 监听域对象中的属性的增加和删除的事件监听器。
  3. 监听绑定到HttpSession域中的某个对象的状态的事件监听器。

监听ServletContext域对象的创建和销毁

  ServletContextListener接口用于监听ServletContext对象的创建和销毁事件。实现了ServletContextListener接口的类都可以对ServletContext对象的创建和销毁进行监听。

  当ServletContext对象被创建时,激发contextInitialized (ServletContextEvent sce)方法。

  当ServletContext对象被销毁时,激发contextDestroyed(ServletContextEvent sce)方法。

  ServletContext域对象创建和销毁时机:
    创建:服务器启动针对每一个Web应用创建ServletContext
    销毁:服务器关闭前先关闭代表每一个web应用的ServletContext

范例:编写一个MyServletContextListener类,实现ServletContextListener接口,监听ServletContext对象的创建和销毁

  1、编写监听器,代码如下:

package me.gacl.web.listener;
 
 import javax.servlet.ServletContextEvent;
 import javax.servlet.ServletContextListener;
 
 /**
 * @ClassName: MyServletContextListener
 * @Description: MyServletContextListener类实现了ServletContextListener接口,
 *                 因此可以对ServletContext对象的创建和销毁这两个动作进行监听。
 *
 */ 
 public class MyServletContextListener implements ServletContextListener {
 
     @Override
     public void contextInitialized(ServletContextEvent sce) {
         System.out.println("ServletContext对象创建");
     }
 
     @Override
     public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("ServletContext对象销毁");
    }
}

在web.xml文件中注册监听器

  我们在上面的中讲到,要想监听事件源,那么必须将监听器注册到事件源上才能够实现对事件源的行为动作进行监听,在JavaWeb中,监听的注册是在web.xml文件中进行配置的,如下:

<?xml version="1.0" encoding="UTF-8"?>
 <web-app version="3.0" 
     xmlns="http://java.sun.com/xml/ns/javaee" 
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" 
     xsi:schemaLocation="http://java.sun.com/xml/ns/javaee 
    http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd">
   <display-name></display-name>    
   <welcome-file-list>
     <welcome-file>index.jsp</welcome-file>
   </welcome-file-list>
   
   <!-- 注册针对ServletContext对象进行监听的监听器 -->
   <listener>
       <description>ServletContextListener监听器</description>
       <!--实现了ServletContextListener接口的监听器类 -->
       <listener-class>me.gacl.web.listener.MyServletContextListener</listener-class>
   </listener>
   
 </web-app>

  经过这两个步骤,我们就完成了监听器的编写和注册,Web服务器在启动时,就会自动把在web.xml中配置的监听器注册到ServletContext对象上,这样开发好的MyServletContextListener监听器就可以对ServletContext对象进行监听了。

监听HttpSession域对象的创建和销毁

  HttpSessionListener 接口用于监听HttpSession对象的创建和销毁
  创建一个Session时,激发sessionCreated (HttpSessionEvent se) 方法
  销毁一个Session时,激发sessionDestroyed (HttpSessionEvent se) 方法。

范例:编写一个MyHttpSessionListener类,实现HttpSessionListener接口,监听HttpSession对象的创建和销毁

  1、编写监听器,代码如下:

package me.gacl.web.listener;
 
 import javax.servlet.http.HttpSessionEvent;
 import javax.servlet.http.HttpSessionListener;
 
 /**
 * @ClassName: MyHttpSessionListener
 * @Description: MyHttpSessionListener类实现了HttpSessionListener接口,
 *                 因此可以对HttpSession对象的创建和销毁这两个动作进行监听。
 */ 
 public class MyHttpSessionListener implements HttpSessionListener {
 
     @Override
     public void sessionCreated(HttpSessionEvent se) {
         System.out.println( se.getSession() + "创建了!!");
     }
 
     /* HttpSession的销毁时机需要在web.xml中进行配置,如下:
      * <session-config>
               <session-timeout>1</session-timeout>
           </session-config>
           这样配置就表示session在1分钟之后就被销毁
      */
     @Override
     public void sessionDestroyed(HttpSessionEvent se) {
         System.out.println("session销毁了!!");
     }
 }

 2、在web.xml文件中注册监听器

<!--注册针对HttpSession对象进行监听的监听器-->
    <listener>
        <description>HttpSessionListener监听器</description>
        <listener-class>me.gacl.web.listener.MyHttpSessionListener</listener-class>
   </listener>
   <!-- 配置HttpSession对象的销毁时机 -->
   <session-config>
       <!--配置HttpSession对象的1分钟之后销毁 -->
       <session-timeout>1</session-timeout>
   </session-config>

  当我们访问jsp页面时,HttpSession对象就会创建,此时就可以在HttpSessionListener观察到HttpSession对象的创建过程了,我们可以写一个jsp页面观察HttpSession对象创建的过程。

如下:index.jsp

<%@ page language="java" import="java.util.*" pageEncoding="UTF-8" %>
 
 <!DOCTYPE HTML>
 <html>
   <head>
     <title>HttpSessionListener监听器监听HttpSession对象的创建</title>
   </head>
   
   <body>
        一访问JSP页面,HttpSession就创建了,创建好的Session的Id是:${pageContext.session.id}
   </body>
 </html>

运行结果如下:

JavaWeb开发与代码的编写(十九)_java_02

监听ServletRequest域对象的创建和销毁

  ServletRequestListener接口用于监听ServletRequest 对象的创建和销毁
  Request对象被创建时,监听器的requestInitialized(ServletRequestEvent sre)方法将会被调用
  Request对象被销毁时,监听器的requestDestroyed(ServletRequestEvent sre)方法将会被调用

  ServletRequest域对象创建和销毁时机:
    创建:用户每一次访问都会创建request对象
    销毁:当前访问结束,request对象就会销毁

范例:编写一个MyServletRequestListener类,实现ServletRequestListener接口,监听ServletRequest对象的创建和销毁

  1、编写监听器,代码如下:

package me.gacl.web.listener;
 
 import javax.servlet.ServletRequestEvent;
 import javax.servlet.ServletRequestListener;
 
 /**
 * @ClassName: MyServletRequestListener
 * @Description: MyServletRequestListener类实现了ServletRequestListener接口,
 *                 因此可以对ServletRequest对象的创建和销毁这两个动作进行监听。
 *
 */ 
 public class MyServletRequestListener implements ServletRequestListener {
 
     @Override
     public void requestDestroyed(ServletRequestEvent sre) {
         System.out.println(sre.getServletRequest() + "销毁了!!");
         
     }
 
     @Override
     public void requestInitialized(ServletRequestEvent sre) {
         System.out.println(sre.getServletRequest() + "创建了!!");
     }
 }

 2、在web.xml文件中注册监听器

<!--注册针对ServletRequest对象进行监听的监听器-->
   <listener> 
     <description>ServletRequestListener监听器</description>
      <listener-class>me.gacl.web.listener.MyServletRequestListener</listener-class>
  </listener

测试结果如下:

JavaWeb开发与代码的编写(十九)_事件源_03

从运行结果中可以看到,用户每一次访问都会创建request对象,当访问结束后,request对象就会销毁。

以上就是对监听器的一些简单讲解。

 

监听域对象中属性的变更的监听器

域对象中属性的变更的事件监听器就是用来监听 ServletContext, HttpSession, HttpServletRequest 这三个对象中的属性变更信息事件的监听器。
  这三个监听器接口分别是ServletContextAttributeListener, HttpSessionAttributeListener 和ServletRequestAttributeListener,这三个接口中都定义了三个方法来处理被监听对象中的属性的增加,删除和替换的事件,同一个事件在这三个接口中对应的方法名称完全相同,只是接受的参数类型不同。

attributeAdded 方法

  当向被监听对象中增加一个属性时,web容器就调用事件监听器的attributeAdded方法进行响应,这个方法接收一个事件类型的参数,监听器可以通过这个参数来获得正在增加属性的域对象和被保存到域中的属性对象
  各个域属性监听器中的完整语法定义为:

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

attributeRemoved 方法

  当删除被监听对象中的一个属性时,web容器调用事件监听器的attributeRemoved方法进行响应
  各个域属性监听器中的完整语法定义为:

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

attributeReplaced 方法

  当监听器的域对象中的某个属性被替换时,web容器调用事件监听器的attributeReplaced方法进行响应
  各个域属性监听器中的完整语法定义为:

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

ServletContextAttributeListener监听器范例:

  编写ServletContextAttributeListener监听器监听ServletContext域对象的属性值变化情况,代码如下:

package me.gacl.web.listener;
 
 import java.text.MessageFormat;
 
 import javax.servlet.ServletContextAttributeEvent;
 import javax.servlet.ServletContextAttributeListener;
 
 /**
 * @ClassName: MyServletContextAttributeListener
 * @Description: ServletContext域对象中属性的变更的事件监听器
 *
*/ 
 public class MyServletContextAttributeListener implements
         ServletContextAttributeListener {
 
     @Override
     public void attributeAdded(ServletContextAttributeEvent scab) {
         String str =MessageFormat.format(
                 "ServletContext域对象中添加了属性:{0},属性值是:{1}"
                 ,scab.getName()
                 ,scab.getValue());
         System.out.println(str);
     }
 
     @Override
    public void attributeRemoved(ServletContextAttributeEvent scab) {
         String str =MessageFormat.format(
                 "ServletContext域对象中删除属性:{0},属性值是:{1}"
                 ,scab.getName()
                 ,scab.getValue());
         System.out.println(str);
     }
 
     @Override
     public void attributeReplaced(ServletContextAttributeEvent scab) {
         String str =MessageFormat.format(
                 "ServletContext域对象中替换了属性:{0}的值"
                 ,scab.getName());
         System.out.println(str);
    }
 }

  在web.xml文件中注册监听器

<listener>
       <description>MyServletContextAttributeListener监听器</description>
       <listener-class>me.gacl.web.listener.MyServletContextAttributeListener</listener-class>
   </listener>

  编写ServletContextAttributeListenerTest.jsp测试页面

<%@ page language="java" pageEncoding="UTF-8"%>
  <!DOCTYPE HTML>
  <html>
    <head>
      <title>ServletContextAttributeListener监听器测试</title>
    </head>
    
    <body>
         <%
            //往application域对象中添加属性
            application.setAttribute("name", "孤傲苍狼");
           //替换application域对象中name属性的值
            application.setAttribute("name", "gacl");
            //移除application域对象中name属性
            application.removeAttribute("name");
            %>
   </body>
 </html>

运行结果如下:

JavaWeb开发与代码的编写(十九)_JavaWeb开发与代码的编写(十九)_04

  从运行结果中可以看到,ServletContextListener监听器成功监听到了ServletContext域对象(application)中的属性值的变化情况。

ServletRequestAttributeListener和HttpSessionAttributeListener监听器范例:

  编写监听器监听HttpSession和HttpServletRequest域对象的属性值变化情况,代码如下:

1 package me.gacl.web.listener;
 2 
 3 import java.text.MessageFormat;
 4 
 5 import javax.servlet.ServletRequestAttributeEvent;
 6 import javax.servlet.ServletRequestAttributeListener;
 7 import javax.servlet.http.HttpSessionAttributeListener;
 8 import javax.servlet.http.HttpSessionBindingEvent;
 9 
10 public class MyRequestAndSessionAttributeListener implements
11         HttpSessionAttributeListener, ServletRequestAttributeListener {
12 
13     @Override
14     public void attributeAdded(ServletRequestAttributeEvent srae) {
15         String str =MessageFormat.format(
16                 "ServletRequest域对象中添加了属性:{0},属性值是:{1}"
17                 ,srae.getName()
18                 ,srae.getValue());
19         System.out.println(str);
20     }
21 
22     @Override
23     public void attributeRemoved(ServletRequestAttributeEvent srae) {
24         String str =MessageFormat.format(
25                 "ServletRequest域对象中删除属性:{0},属性值是:{1}"
26                 ,srae.getName()
27                 ,srae.getValue());
28         System.out.println(str);
29     }
30 
31     @Override
32     public void attributeReplaced(ServletRequestAttributeEvent srae) {
33         String str =MessageFormat.format(
34                 "ServletRequest域对象中替换了属性:{0}的值"
35                 ,srae.getName());
36         System.out.println(str);
37     }
38 
39     @Override
40     public void attributeAdded(HttpSessionBindingEvent se) {
41         String str =MessageFormat.format(
42                 "HttpSession域对象中添加了属性:{0},属性值是:{1}"
43                 ,se.getName()
44                 ,se.getValue());
45         System.out.println(str);
46     }
47 
48     @Override
49     public void attributeRemoved(HttpSessionBindingEvent se) {
50         String str =MessageFormat.format(
51                 "HttpSession域对象中删除属性:{0},属性值是:{1}"
52                 ,se.getName()
53                 ,se.getValue());
54         System.out.println(str);
55     }
56 
57     @Override
58     public void attributeReplaced(HttpSessionBindingEvent se) {
59         String str =MessageFormat.format(
60                 "HttpSession域对象中替换了属性:{0}的值"
61                 ,se.getName());
62         System.out.println(str);
63     }
64 }

 在web.xml文件中注册监听器

<listener>
       <description>MyRequestAndSessionAttributeListener监听器</description>
       <listener-class>me.gacl.web.listener.MyRequestAndSessionAttributeListener</listener-class>
   </listener>

  编写RequestAndSessionAttributeListenerTest.jsp测试页面

<%@ page language="java" pageEncoding="UTF-8"%>
 <!DOCTYPE HTML>
 <html>
   <head>
     <title>RequestAndSessionAttributeListener监听器测试</title>
   </head>
   
   <body>
     <%
            //往session域对象中添加属性
            session.setAttribute("aa", "bb");
           //替换session域对象中aa属性的值
            session.setAttribute("aa", "xx");
            //移除session域对象中aa属性
            session.removeAttribute("aa");
           
           //往request域对象中添加属性
            request.setAttribute("aa", "bb");
           //替换request域对象中aa属性的值
           request.setAttribute("aa", "xx");
            //移除request域对象中aa属性
            request.removeAttribute("aa");
     %>
   </body>
 </html>

 运行结果如下:

  

JavaWeb开发与代码的编写(十九)_java_05

  从运行结果中可以看到,HttpSessionAttributeListener监听器和ServletRequestAttributeListener成功监听到了HttpSession域对象和HttpServletRequest域对象的属性值变化情况。

感知Session绑定的事件监听器

  保存在Session域中的对象可以有多种状态:绑定(session.setAttribute("bean",Object))到Session中;从 Session域中解除(session.removeAttribute("bean"))绑定;随Session对象持久化到一个存储设备中;随Session对象从一个存储设备中恢复
  Servlet 规范中定义了两个特殊的监听器接口"HttpSessionBindingListener和HttpSessionActivationListener"来帮助JavaBean 对象了解自己在Session域中的这些状态: ,实现这两个接口的类不需要 web.xml 文件中进行注册。

HttpSessionBindingListener接口

  实现了HttpSessionBindingListener接口的JavaBean对象可以感知自己被绑定到Session中和 Session中删除的事件
  当对象被绑定到HttpSession对象中时,web服务器调用该对象的void valueBound(HttpSessionBindingEvent event)方法
  当对象从HttpSession对象中解除绑定时,web服务器调用该对象的void valueUnbound(HttpSessionBindingEvent event)方法

范例:

package me.gacl.domain;
 
 import javax.servlet.http.HttpSessionBindingEvent;
 import javax.servlet.http.HttpSessionBindingListener;
 
 /**
 * @ClassName: JavaBeanDemo1
 * @Description: 
 *   实现了HttpSessionBindingListener接口的 JavaBean对象可以感知自己被绑定到 Session中和从Session中删除的事件
    当对象被绑定到 HttpSession 对象中时,web 服务器调用该对象的  void valueBound(HttpSessionBindingEvent event) 方法
     当对象从 HttpSession 对象中解除绑定时,web 服务器调用该对象的 void valueUnbound(HttpSessionBindingEvent event)方法
 
*
*/ 
 public class JavaBeanDemo1 implements HttpSessionBindingListener {
 
     private String name;
     @Override
     public void valueBound(HttpSessionBindingEvent event) {
         System.out.println(name+"被加到session中了");
     }
 
     @Override     public void valueUnbound(HttpSessionBindingEvent event) {
         System.out.println(name+"被session踢出来了");
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }
 
     public JavaBeanDemo1(String name) {
         this.name = name;
     }
 }

  上述的JavaBeanDemo1这个javabean实现了HttpSessionBindingListener接口,那么这个JavaBean对象可以感知自己被绑定到Session中和从Session中删除的这两个操作,测试代码如下:

<%@ page language="java" pageEncoding="UTF-8"%>
 <%@page import=" me.gacl.domain.JavaBeanDemo1"%>
 <!DOCTYPE HTML>
 <html>
   <head>
     <title></title>
   </head>
   
   <body>
     <% 
         //将javabean对象绑定到Session中
         session.setAttribute("bean",new JavaBeanDemo1("孤傲苍狼"));
         //从Session中删除javabean对象
         session.removeAttribute("bean");
     %>
   </body>
 </html>

HttpSessionActivationListener接口

  实现了HttpSessionActivationListener接口的JavaBean对象可以感知自己被活化(反序列化)和钝化(序列化)的事件
  当绑定到HttpSession对象中的javabean对象将要随HttpSession对象被钝化(序列化)之前,web服务器调用该javabean对象的void sessionWillPassivate(HttpSessionEvent event) 方法。这样javabean对象就可以知道自己将要和HttpSession对象一起被序列化(钝化)到硬盘中.
  当绑定到HttpSession对象中的javabean对象将要随HttpSession对象被活化(反序列化)之后,web服务器调用该javabean对象的void sessionDidActive(HttpSessionEvent event)方法。这样javabean对象就可以知道自己将要和 HttpSession对象一起被反序列化(活化)回到内存中

范例:

  

package me.gacl.domain;
 
 import java.io.Serializable;
 
 import javax.servlet.http.HttpSessionActivationListener;
 import javax.servlet.http.HttpSessionEvent;
 
 /**
 * @ClassName: JavaBeanDemo2
 * @Description: 
     实现了HttpSessionActivationListener接口的 JavaBean 对象可以感知自己被活化和钝化的事件
     活化:javabean对象和Session一起被反序列化(活化)到内存中。
     钝化:javabean对象存在Session中,当服务器把session序列化到硬盘上时,如果Session中的javabean对象实现了Serializable接口
     那么服务器会把session中的javabean对象一起序列化到硬盘上,javabean对象和Session一起被序列化到硬盘中的这个操作称之为钝化
     如果Session中的javabean对象没有实现Serializable接口,那么服务器会先把Session中没有实现Serializable接口的javabean对象移除
     然后再把Session序列化(钝化)到硬盘中
     当绑定到 HttpSession对象中的javabean对象将要随 HttpSession对象被钝化之前,
     web服务器调用该javabean对象对象的 void sessionWillPassivate(HttpSessionEvent event)方法
     这样javabean对象就可以知道自己将要和 HttpSession对象一起被序列化(钝化)到硬盘中
     当绑定到HttpSession对象中的javabean对象将要随 HttpSession对象被活化之后,
     web服务器调用该javabean对象的 void sessionDidActive(HttpSessionEvent event)方法
     这样javabean对象就可以知道自己将要和 HttpSession对象一起被反序列化(活化)回到内存中
 *
 */ 
 public class JavaBeanDemo2 implements HttpSessionActivationListener,
         Serializable {
 
      
     private static final long serialVersionUID = 7589841135210272124L;
     private String name;
     
     @Override
     public void sessionWillPassivate(HttpSessionEvent se) {
         
         System.out.println(name+"和session一起被序列化(钝化)到硬盘了,session的id是:"+se.getSession().getId());
     }
 
     @Override
     public void sessionDidActivate(HttpSessionEvent se) {
         System.out.println(name+"和session一起从硬盘反序列化(活化)回到内存了,session的id是:"+se.getSession().getId());
     }
 
     public String getName() {
         return name;
     }
 
     public void setName(String name) {
         this.name = name;
     }

     public JavaBeanDemo2(String name) {
         this.name = name;
     }
 }

  为了观察绑定到HttpSession对象中的javabean对象随HttpSession对象一起被钝化到硬盘上和从硬盘上重新活化回到内存中的的过程,我们需要借助tomcat服务器帮助我们完成HttpSession对象的钝化和活化过程,具体做法如下:

  在WebRoot\META-INF文件夹下创建一个context.xml文件,如下所示:

  

JavaWeb开发与代码的编写(十九)_事件源_06

  context.xml文件的内容如下:

<Context>
    <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">     
    <Store className="org.apache.catalina.session.FileStore" directory="gacl"/>
    </Manager>
</Context>

在context.xml文件文件中配置了1分钟之后就将HttpSession对象钝化到本地硬盘的一个gacl文件夹中

  jsp测试代码如下:

<%@ page language="java" pageEncoding="UTF-8"%>
 <%@page import="me.gacl.domain.JavaBeanDemo2"%>
 <!DOCTYPE HTML>
 <html>
   <head>
     <title></title>
   </head>
    
    <body>
       一访问JSP页面,HttpSession就创建了,创建好的Session的Id是:${pageContext.session.id}
        <hr/>
    <% 
         session.setAttribute("bean",new JavaBeanDemo2("孤傲苍狼"));
     %>
   </body>
</html>

  访问这个jsp页面,服务器就会马上创建一个HttpSession对象,然后将实现了HttpSessionActivationListener接口的JavaBean对象绑定到session对象中,这个jsp页面在等待1分钟之后没有人再次访问,那么服务器就会自动将这个HttpSession对象钝化(序列化)到硬盘上,

  

JavaWeb开发与代码的编写(十九)_事件源_07

  我们可以在tomcat服务器的work\Catalina\localhost\JavaWeb_Listener_20140908\gacl文件夹下找到序列化到本地存储的session,如下图所示:

  

JavaWeb开发与代码的编写(十九)_java_08

  当再次访问这个Jsp页面时,服务器又会自动将已经钝化(序列化)到硬盘上HttpSession对象重新活化(反序列化)回到内存中。运行结果如下:

JavaWeb开发与代码的编写(十九)_java_09

  JavaWeb开发技术中的监听器技术的内容就这么多了,在平时的工作中,监听器技术在JavaWeb项目开发中用得是比较多,因此必须掌握这门技术。

 

监听器(Listener)的应用

监听器在JavaWeb开发中用得比较多,下面说一下监听器(Listener)在开发中的常见应用

统计当前在线人数

  在JavaWeb应用开发中,有时候我们需要统计当前在线的用户数,此时就可以使用监听器技术来实现这个功能了。

package me.gacl.web.listener;
 
 import javax.servlet.ServletContext;
 import javax.servlet.http.HttpSessionEvent;
 import javax.servlet.http.HttpSessionListener;
 
 /**
 * @ClassName: OnLineCountListener
 * @Description: 统计当前在线用户个数
 *
 */ 
 public class OnLineCountListener implements HttpSessionListener {
 
     @Override
    public void sessionCreated(HttpSessionEvent se) {
         ServletContext context = se.getSession().getServletContext();
         Integer onLineCount = (Integer) context.getAttribute("onLineCount");
         if(onLineCount==null){
             context.setAttribute("onLineCount", 1);
         }else{
             onLineCount++;
             context.setAttribute("onLineCount", onLineCount);
         }
     }
 
     @Override
     public void sessionDestroyed(HttpSessionEvent se) {
         ServletContext context = se.getSession().getServletContext();
         Integer onLineCount = (Integer) context.getAttribute("onLineCount");
         if(onLineCount==null){
             context.setAttribute("onLineCount", 1);
         }else{
             onLineCount--;
             context.setAttribute("onLineCount", onLineCount);
         }
    }
 }

 

自定义Session扫描器

  当一个Web应用创建的Session很多时,为了避免Session占用太多的内存,我们可以选择手动将这些内存中的session销毁,那么此时也可以借助监听器技术来实现。

1 package me.gacl.web.listener;
  2 
  3 import java.util.Collections;
  4 import java.util.LinkedList;
  5 import java.util.List;
  6 import java.util.ListIterator;
  7 import java.util.Timer;
  8 import java.util.TimerTask;
  9 import javax.servlet.ServletContextEvent;
 10 import javax.servlet.ServletContextListener;
 11 import javax.servlet.http.HttpSession;
 12 import javax.servlet.http.HttpSessionEvent;
 13 import javax.servlet.http.HttpSessionListener;
 14 
 15 /**
 16 * @ClassName: SessionScanerListener
 17 * @Description: 自定义session扫描器
 21 */ 
 22 public class SessionScanerListener implements HttpSessionListener,ServletContextListener {
 23 
 24     /**
 25     * @Field: list
 26     *          定义一个集合存储服务器创建的HttpSession
 27     *        LinkedList不是一个线程安全的集合
 28     */ 
 29     /**
 30      * private List<HttpSession> list = new LinkedList<HttpSession>();
 31      * 这样写涉及到线程安全问题,SessionScanerListener对象在内存中只有一个
 32      * sessionCreated可能会被多个人同时调用,
 33      * 当有多个人并发访问站点时,服务器同时为这些并发访问的人创建session
 34      * 那么sessionCreated方法在某一时刻内会被几个线程同时调用,几个线程并发调用sessionCreated方法
 35      * sessionCreated方法的内部处理是往一个集合中添加创建好的session,那么在加session的时候就会
 36      * 涉及到几个Session同时抢夺集合中一个位置的情况,所以往集合中添加session时,一定要保证集合是线程安全的才行
 37      * 如何把一个集合做成线程安全的集合呢?
 38      * 可以使用使用 Collections.synchronizedList(List<T> list)方法将不是线程安全的list集合包装线程安全的list集合
 39      */
 40     //使用 Collections.synchronizedList(List<T> list)方法将LinkedList包装成一个线程安全的集合
 41     private List<HttpSession> list = Collections.synchronizedList(new LinkedList<HttpSession>());
 42     //定义一个对象,让这个对象充当一把锁,用这把锁来保证往list集合添加的新的session和遍历list集合中的session这两个操作达到同步
 43     private Object lock = new Object();
 44             
 45     @Override
 46     public void sessionCreated(HttpSessionEvent se) {
 47         System.out.println("session被创建了!!");
 48         HttpSession session = se.getSession();
 49         
 50         synchronized (lock){
 51             /**
 52              *将该操作加锁进行锁定,当有一个thread-1(线程1)在调用这段代码时,会先拿到lock这把锁,然后往集合中添加session,
 53              *在添加session的这个过程中假设有另外一个thread-2(线程2)来访问了,thread-2可能是执行定时器任务的,
 54              *当thread-2要调用run方法遍历list集合中的session时,结果发现遍历list集合中的session的那段代码被锁住了,
 55              *而这把锁正在被往集合中添加session的那个thread-1占用着,因此thread-2只能等待thread-1操作完成之后才能够进行操作
 56              *当thread-1添加完session之后,就把lock放开了,此时thread-2拿到lock,就可以执行遍历list集合中的session的那段代码了
 57              *通过这把锁就保证了往集合中添加session和变量集合中的session这两步操作不能同时进行,必须按照先来后到的顺序来进行。
 58              */
 59             list.add(session);
 60         }
 61     }
 62 
 63     @Override
 64     public void sessionDestroyed(HttpSessionEvent se) {
 65         System.out.println("session被销毁了了!!");
 66     }
 67 
 68     /* Web应用启动时触发这个事件
 69      * @see javax.servlet.ServletContextListener#contextInitialized(javax.servlet.ServletContextEvent)
 70      */
 71     @Override
 72     public void contextInitialized(ServletContextEvent sce) {
 73         System.out.println("web应用初始化");
 74         //创建定时器
 75         Timer timer = new Timer();
 76         //每隔30秒就定时执行任务
 77         timer.schedule(new MyTask(list,lock), 0, 1000*30);
 78     }
 79 
 80     @Override
 81     public void contextDestroyed(ServletContextEvent sce) {
 82         System.out.println("web应用关闭");
 83     }
 84 }
 85 
 86 /**
 87 * @ClassName: MyTask
 88 * @Description:定时器要定时执行的任务
 91 *
 92 */ 
 93 class MyTask extends TimerTask {
 94         
 95     //存储HttpSession的list集合
 96     private List<HttpSession> list;
 97     //存储传递过来的锁
 98     private Object lock;
 99     public MyTask(List<HttpSession> list,Object lock){
100         this.list = list;
101         this.lock = lock;
102     }
103     /* run方法指明了任务要做的事情
104      * @see java.util.TimerTask#run()
105      */
106     @Override
107     public void run() {
108             //将该操作加锁进行锁定
109         synchronized (lock) {
110             System.out.println("定时器执行!!");
111             ListIterator<HttpSession> it = list.listIterator();
112             /**
113              * 迭代list集合中的session,在迭代list集合中的session的过程中可能有别的用户来访问,
114              * 用户一访问,服务器就会为该用户创建一个session,此时就会调用sessionCreated往list集合中添加新的session,
115              * 然而定时器在定时执行扫描遍历list集合中的session时是无法知道正在遍历的list集合又添加的新的session进来了,
116              * 这样就导致了往list集合添加的新的session和遍历list集合中的session这两个操作无法达到同步
117              * 那么解决的办法就是把"list.add(session)和while(it.hasNext()){//迭代list集合}"这两段代码做成同步,
118              * 保证当有一个线程在访问"list.add(session)"这段代码时,另一个线程就不能访问"while(it.hasNext()){//迭代list集合}"这段代码
119              * 为了能够将这两段不相干的代码做成同步,只能定义一把锁(Object lock),然后给这两步操作加上同一把锁,
120              * 用这把锁来保证往list集合添加的新的session和遍历list集合中的session这两个操作达到同步
121              * 当在执行往list集合添加的新的session操作时,就必须等添加完成之后才能够对list集合进行迭代操作,
122              * 当在执行对list集合进行迭代操作时,那么必须等到迭代操作结束之后才能够往往list集合添加的新的session
123              */
124             while(it.hasNext()){
125                 HttpSession session = (HttpSession) it.next();
126                 /**
127                  * 如果当前时间-session的最后访问时间>1000*15(15秒)
128                  * session.getLastAccessedTime()获取session的最后访问时间
129                  */
130                 if(System.currentTimeMillis()-session.getLastAccessedTime()>1000*30){
131                     //手动销毁session
132                     session.invalidate();
133                     //移除集合中已经被销毁的session
134                     it.remove();
135                 }
136             }
137         }
138     }
139 }

以上就是监听器的两个简单应用场景。

 

 

 

 

举报

相关推荐

0 条评论