spring的各种 Listener

 引言：listener顾名思义就是监听的意思，作用就是监听程序中的一些变化，并根据其做出一些相应的响应。通俗的语言就是在session，request，application三个对象创建消亡或者往其中进行修改增加删除属性时自动执行代码的功能组件。 

     定义：listener监听器主要是实现了javax.servlet.ServletContextListener接口的服务器端程序，它跟过滤器一样随web应用启动而启动，只需要初始化一次，以后都可以进行监听。一般主要用于ServletContext、HttpSession、HttpServletSession这三个对象中的属性变更信息事件监听。

使用listener步骤：

1. 通过实现具体接口创建实现类（可实现多个监听器接口）
2. 配置实现类成为监听器，有两种配置方式：
   1. 直接用@WebListener注解修饰实现类
   2. 通过web.xml方式配置，代码如下：

<listener>
    <listener-class>com.zrgk.listener.MyListener</lisener-class>
</listener>

一、对request进行监听

    应用实例：实现对javax.servlet.ServletRequestListener接口的监听，也就是HttpRequestServlet进行监听。

    1、Web.xml中的配置：   

   <listener>

1. <description>HttpRequestListner监听器</description>

2. <listener-class>com.check.listener.MyRequestContextListener</listener-class>

3. </listener>

    2、在MyRequestContextListener类中对ServletRequestListener接口的实现    

1. package com.check.listener;

2. import javax.servlet.ServletRequestEvent;

3. import javax.servlet.ServletRequestListener;

4. import javax.servlet.http.HttpSessionEvent;

5. import javax.servlet.http.HttpSessionListener;

6. public class MyRequestContextListener implements ServletRequestListener{

7.  

8. @Override

9. public void requestDestroyed(ServletRequestEvent sre) {

10. System.out.println("Request销毁成功"+sre.getServletRequest());

11.  

12. }

13. @Override

14. public void requestInitialized(ServletRequestEvent sre) {

15. System.out.println("Request创建成功"+sre.getServletRequest());

16.  

17. }

18.  

19. }

    总结这：样就可以对request请求进行监听，其中对象的创建和销毁时间为：request请求发生的时候对象创建，当响应产生的时候request对象销毁。  

 

二、对session进行监听

   1、web.xml中的配置    

1. <!--注册针对HttpSession对象监听器 -->

2. <listener>

3. <description>HttpSessionListener监听器</description>

4. <listener-class>com.check.listener.MySessionContextListener</listener-class>

5. </listener>

   2、MySessionContextListener对HttpSessionListener实现

1. package com.check.listener;

2.  

3. import java.text.SimpleDateFormat;

4. import java.util.Date;

5.  

6. import javax.servlet.ServletContextEvent;

7. import javax.servlet.ServletContextListener;

8. import javax.servlet.http.HttpSessionEvent;

9. import javax.servlet.http.HttpSessionListener;

10.  

11. public class MySessionContextListener implements HttpSessionListener {

12. SimpleDateFormat sdf=new SimpleDateFormat("yyyy-MM-dd HH:mm:ss");

13. @Override

14. public void sessionCreated(HttpSessionEvent se) {

15. Date date=new Date();

16. System.out.println("session创建成功"+se.getSession()+" "+sdf.format(date));

17.  

18. }

19.  

20. @Override

21. public void sessionDestroyed(HttpSessionEvent se) {

22. Date date=new Date();

23. System.out.println("session销毁成功"+se.getSession() + " "+sdf.format(date));

24.  

25. }

26. }

 

总结：我在运行的时候，报这个session创建的时间是在一次Httprequest请求成功后创建的，也就是相当于一个request请求会创建一个session，而session的创建包括如下几种情况。

1.session对象创建:

    reqeust.getSession();它是用于获取session.

    是否创建，分以下几种情况:

    1.请求中如果没有jsessionid,那么就是创建session对象。

    2.如果请求头中有jsessionid值：

    1.如果在服务器端，有一个session的id值与其一样，不创建，直接使用。

    2.如果在服务器端，没有这个session的id值，那么会创建。

 2. session销毁:

    1.默认超时  30分钟

    2.设置session超时时间

    setMaxInactiveInterval(int interval)

    3.invalidate()手动销毁.

   4.关闭服务器

 

而我在创建的时候，在web.xm中配置session的销毁时间：1分钟

1. <session-config>

2. <session-timeout>1</session-timeout>

3. </session-config>

三、实现对ServletContext事件的监听

   1、web.xml配置

1. <listener>

2. <description>ServletContextListener监听器</description>

3. <!-- 实现了ServletContextListener接口的监听器类 -->

4. <listener-class>com.check.listener.MyServletContextListener</listener-class>

5. </listener>

   2、实现类MyServletContextListener；

1. package com.check.listener;

2. import javax.servlet.ServletContextEvent;

3. import javax.servlet.ServletContextListener;

4. public class MyServletContextListener implements ServletContextListener {

5. @Override

6. public void contextInitialized(ServletContextEvent sce) {

7. System.out.println("ServletContext 对象创建"+sce.getServletContext());

8.  

9. }

10. @Override

11. public void contextDestroyed(ServletContextEvent sce) {

12. System.out.println("ServletContext 对象销毁"+sce.getServletContext());

13. }

14. }

 

四、对其中属性进行一个监听：例如ServletContextAttributeListener

  1、web.xml配置

1. <listener>

2. <description>MyServletContextAttributeListener监听器</description>

3. <listener-class>com.check.listener.MyServletContextAttributeListener</listener-class>

4. </listener>

   2、实现类

1. package com.check.listener;

2.  

3. import java.text.MessageFormat;

4.  

5. import javax.servlet.ServletContextAttributeEvent;

6. import javax.servlet.ServletContextAttributeListener;

7. import javax.servlet.ServletContextListener;

8.  

9. public class MyServletContextAttributeListener implements ServletContextAttributeListener{

10.  

11. @Override

12. public void attributeAdded(ServletContextAttributeEvent scab) {

13. String str =MessageFormat.format(

14. "ServletContext域对象中添加了属性:{0}，属性值是:{1}"

15. ,scab.getName()

16. ,scab.getValue());

17. System.out.println(str);

18. }

19.  

20. @Override

21. public void attributeRemoved(ServletContextAttributeEvent scab) {

22. String str =MessageFormat.format(

23. "ServletContext域对象中删除属性:{0}，属性值是:{1}"

24. ,scab.getName()

25. ,scab.getValue());

26. System.out.println(str);

27. }

28.  

29. @Override

30. public void attributeReplaced(ServletContextAttributeEvent scab) {

31. String str =MessageFormat.format(

32. "ServletContext域对象中替换了属性:{0}的值"

33. ,scab.getName());

34. System.out.println(str);

35. }

36.  

37. }

 

五、ServletContextListener原理

Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener 接口的服务器端程序，它也是随web应用的启动
而启动，只初始化一次，随web应用的停止而销毁。主要作用是：做一些初始化的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等。首先来看一下ServletContextListener接口的源代码：

[java] view plain copy

1. public abstract interface ServletContextListener extends EventListener{  
2.     public abstract void contextInitialized(ServletContextEvent paramServletContextEvent);  
3.     public abstract void contextDestroyed(ServletContextEvent paramServletContextEvent);  
4. }  

下面利用监听器对数据库连接池DataSource的初始化演示它的使用：ListenerTest.java 
[java] view plain copy

1. import javax.servlet.ServletContext;     
2. import javax.servlet.ServletContextEvent;     
3. import javax.servlet.ServletContextListener;     
4. import org.apache.commons.dbcp.BasicDataSource;         
5. /** 
6.  * 现在来说说Servlet的监听器Listener，它是实现了javax.servlet.ServletContextListener 接口的 
7.  * 服务器端程序，它也是随web应用的启动而启动，只初始化一次，随web应用的停止而销毁。主要作用是：做一些初始化 
8.  * 的内容添加工作、设置一些基本的内容、比如一些参数或者是一些固定的对象等等。 
9.  *  
10.  * 示例代码：使用监听器对数据库连接池DataSource进行初始化 
11.  */   
12. public class ListenerTest implements ServletContextListener{       
13.    // 应用监听器的销毁方法     
14.    public void contextDestroyed(ServletContextEvent servletContextEvent) {     
15.         ServletContext servletContext = servletContextEvent.getServletContext();  
16.         // 在整个web应用销毁之前调用，将所有应用空间所设置的内容清空  
17.         servletContext.removeAttribute("dataSource");  
18.         System.out.println("销毁工作完成...");    
19.    }     
20.     // 应用监听器的初始化方法     
21.     public void contextInitialized(ServletContextEvent servletContextEvent) {     
22.         // 通过这个事件可以获取整个应用的空间     
23.         // 在整个web应用下面启动的时候做一些初始化的内容添加工作     
24.         ServletContext servletContext = servletContextEvent.getServletContext();    
25.         // 设置一些基本的内容；比如一些参数或者是一些固定的对象     
26.         // 创建DataSource对象，连接池技术 dbcp     
27.         BasicDataSource basicDataSource = new BasicDataSource();   
28.         basicDataSource.setDriverClassName("com.jdbc.Driver");   
29.         basicDataSource.setUrl("jdbc:mysqlocalhost:3306/");   
30.         basicDataSource.setUsername("root");     
31.         basicDataSource.setPassword("root");     
32.         basicDataSource.setMaxActive(10);//最大连接数     
33.         basicDataSource.setMaxIdle(5);//最大管理数     
34.         //bds.setMaxWait(maxWait); 最大等待时间     
35.         // 把 DataSource 放入ServletContext空间中，     
36.         // 供整个web应用的使用(获取数据库连接)  
37.         servletContext.setAttribute("dataSource", basicDataSource);     
38.         System.out.println("应用监听器初始化工作完成...");     
39.         System.out.println("已经创建DataSource...");    
40.     }     
41. }  

web.xml中配置如下，很简单：

 

 

[html] view plain copy

1. <!-- 配置应用监听器  -->     
2. <listener>     
3.     <listener-class>com.ycq.ListenerTest</listener-class>     
4. </listener>    

这样配置好了之后，以后在web应用中就可以通过ServletContext取得BasicDataSource对象，从而获取与数据库的连接，提高性能，方便使用。

 

示例代码二：

 

[java] view plain copy

1. import java.io.File;  
2. import javax.servlet.ServletContextEvent;  
3. import javax.servlet.ServletContextListener;  
4. import com.i2f.fsp.deploy.TransactionDeployer;  
5. /** 
6.  * 监听器随着项目的启动而启动 
7.  * 
8.  */  
9. public class ListenerTest2 implements ServletContextListener{  
10.     // 销毁监听器   
11.     public void contextDestroyed(ServletContextEvent servletContextEvent) {  
12.         System.out.println("date20161020095500 :" + servletContextEvent.getServletContext());  
13.     }  
14.     public void contextInitialized(ServletContextEvent servletContextEvent) {  
15.         try{  
16.             // 获取项目跟路径  
17.             String basePath = servletContextEvent.getServletContext().getRealPath("/");  
18.             // D:\apache-tomcat-6.0.41\webapps\i2money\ 绝对路径  
19.             System.out.println("basePath20161020094700 :" + basePath);  
20.             if (!(basePath.endsWith(File.separator))){  
21.                 basePath = basePath + File.separator;  
22.             }  
23.             basePath = basePath + "WEB-INF" + File.separator + "classes" + File.separator;  
24.             new TransactionDeployer(basePath).deploy();  
25.             // D:\apache-tomcat-6.0.41\webapps\i2money\WEB-INF\classes\  
26.             System.out.println("basePath20161020094701 :" + basePath);  
27.         }  
28.         catch (Exception e){  
29.             e.printStackTrace();  
30.             System.exit(-1);  
31.         }  
32.     }  
33. }  
34.  

六、HttpSessionListener示例代码

示例代码三：

[java] view plain copy

1. import javax.servlet.http.HttpSession;  
2. import javax.servlet.http.HttpSessionEvent;  
3. import javax.servlet.http.HttpSessionListener;  
4. import org.apache.commons.logging.Log;  
5. import org.apache.commons.logging.LogFactory;  
6. import org.springframework.context.ApplicationContext;  
7. import org.springframework.web.context.support.WebApplicationContextUtils;  
8. public class UserLogoutListener implements HttpSessionListener{  
9.     protected final Log log = LogFactory.getLog(super.getClass());  
10.     public void sessionCreated(HttpSessionEvent event){  
11.         this.log.error("session created. id = " + event.getSession().getId());  
12.     }  
13.     public void sessionDestroyed(HttpSessionEvent event){  
14.         this.log.error("session destroyed.id = " + event.getSession().getId());  
15.         HttpSession session = event.getSession();  
16.         ApplicationContext context = WebApplicationContextUtils.getWebApplicationContext(session.getServletContext());  
17.         OnlineUserMonitorClient client = (OnlineUserMonitorClient)context.getBean("onlineUserMonitorClient");  
18.         client.afterSessionDestroyed(session);  
19.     }  
20. }  

 

监听器在实际项目中的应用，监听器在java web中应用的较多，比如：统计当前在线人数、自定义session扫描器。
--------------------- 应用一：统计当前在线人数 ---------------------

 

 

[java] view plain copy

1. import javax.servlet.ServletContext;  
2. import javax.servlet.http.HttpSessionEvent;  
3. import javax.servlet.http.HttpSessionListener;  
4. /** 
5.  * @description HttpSessionListener监听器实现统计网站在线人数的功能 
6.  */  
7. public class SessionListener implements HttpSessionListener{  
8.   
9.     public static int TOTAL_ONLINE_USERS = 0;  
10.     public void sessionCreated(HttpSessionEvent httpSessionEvent) {  
11.         ServletContext servletContext = httpSessionEvent.getSession().getServletContext();  
12.         TOTAL_ONLINE_USERS = (Integer) servletContext.getAttribute("TOTAL_ONLINE_USERS");  
13.         // 如果用户退出，TOTAL_ONLINE_USERS自减1  
14.         if(TOTAL_ONLINE_USERS == 0){  
15.             servletContext.setAttribute("TOTAL_ONLINE_USERS", 1);  
16.         }  
17.         else{  
18.             TOTAL_ONLINE_USERS--;  
19.             servletContext.setAttribute("TOTAL_ONLINE_USERS", TOTAL_ONLINE_USERS);  
20.         }  
21.     }  
22.   
23.     public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {  
24.         ServletContext servletContext = httpSessionEvent.getSession().getServletContext();  
25.         TOTAL_ONLINE_USERS = (Integer) servletContext.getAttribute("TOTAL_ONLINE_USERS");  
26.         // 如果用户登录，TOTAL_ONLINE_USERS自增1  
27.         if(TOTAL_ONLINE_USERS == 0){  
28.             servletContext.setAttribute("TOTAL_ONLINE_USERS", 1);  
29.         }  
30.         else{  
31.             TOTAL_ONLINE_USERS++;  
32.             servletContext.setAttribute("TOTAL_ONLINE_USERS", TOTAL_ONLINE_USERS);  
33.         }  
34.     }  
35. }  

--------------------- 应用二：自定义session扫描器 ---------------------

 

 

[java] view plain copy

1. import java.util.LinkedList;  
2. import java.util.List;  
3. import java.util.Timer;  
4. import javax.servlet.ServletContextEvent;  
5. import javax.servlet.ServletContextListener;  
6. import javax.servlet.http.HttpSession;  
7. import javax.servlet.http.HttpSessionEvent;  
8. import javax.servlet.http.HttpSessionListener;  
9. import jeus.util.concurrent50.Collections;  
10. /** 
11.  * @description 当网站用户量增加时，session占用的内存会越来越大，这时session的管理，将会是一项很大的 
12.  * 系统开销，为了高效的管理session，我们可以写一个监听器，定期清理掉过期的session 
13.  */  
14. public class SessionScanerListener implements HttpSessionListener,ServletContextListener{  
15.     // 创建一个线程安全的集合，用来存储session  
16.     @SuppressWarnings("unchecked")  
17.     List<HttpSession> sessionList = Collections.synchronizedList(new LinkedList<HttpSession>());  
18.     private Object lock = new Object();  
19.       
20.     public void sessionCreated(HttpSessionEvent httpSessionEvent) {  
21.         System.out.println("session 创建成功...");  
22.         HttpSession httpSession = httpSessionEvent.getSession();  
23.         synchronized (lock){  
24.             sessionList.add(httpSession);  
25.         }  
26.     }  
27.   
28.     public void sessionDestroyed(HttpSessionEvent httpSessionEvent) {  
29.         System.out.println("session 销毁成功...");  
30.     }  
31.     // web应用关闭时触发contextDestroyed事件  
32.     public void contextDestroyed(ServletContextEvent servletContextEvent) {  
33.         System.out.println("web应用关闭...");  
34.     }  
35.   
36.     // web应用启动时触发contextInitialized事件  
37.     public void contextInitialized(ServletContextEvent servletContextEvent) {  
38.         System.out.println("web应用初始化...");  
39.         // 创建定时器  
40.         Timer timer = new Timer();  
41.         // 每隔30秒就定时执行任务  
42.         timer.schedule(new MyTask(sessionList,lock), 0, 1000*30);  
43.     }  
44. }  

[java] view plain copy

1. import java.util.List;  
2. import java.util.ListIterator;  
3. import java.util.TimerTask;  
4. import javax.servlet.http.HttpSession;  
5. /** 
6.  * 定时器，定义定时任务的具体内容 
7.  */  
8. public class MyTask extends TimerTask{  
9.     private List<HttpSession> list;  
10.     // 存储传递过来的锁  
11.     private Object lock;  
12.     // 构造方法  
13.     MyTask(List<HttpSession> list, Object lock){  
14.         this.list = list;  
15.         this.lock = lock;  
16.     }  
17.     @Override  
18.     public void run() {  
19.         // 考虑到多线程的情况，这里必须要同步  
20.         synchronized (lock){  
21.             System.out.println("定时器开始执行...");  
22.             ListIterator<HttpSession> listIterator = list.listIterator();  
23.             while(listIterator.hasNext()){  
24.                 HttpSession httpSession = listIterator.next();  
25.                 // httpSession.getLastAccessedTime() = session的最后访问时间  
26.                 if(System.currentTimeMillis() - httpSession.getLastAccessedTime() > 1000*30){  
27.                     // 手动销毁session  
28.                     httpSession.invalidate();  
29.                     // 从集合中移除已经被销毁的session  
30.                     listIterator.remove();  
31.                 }  
32.             }  
33.         }  
34.     }  
35. }  

 

七、spring常用listener

1、IntrospectorCleanupListener

        IntrospectorCleanupListener应该注册为web.xml中的第一个Listener，在任何其他Listener之前注册。           该监听器在web.xml中的配置如下：

Xml代码

 

1. <listener>  
2.     <listener-class>org.springframework.web.util.IntrospectorCleanupListener</listener-class>  
3. </listener>  

        在Web应用程序关闭时IntrospectorCleanupListener将会刷新JDK的JavaBeans的Introspector缓存。在你的web.xml中注册这个listener来确保Web应用程序的类加载器以及其加载的类正确的释放资源。

        如果JavaBeans的Introspector已被用来分析应用程序类，系统级的Introspector缓存将持有这些类的一个硬引用。因此，这些类和Web应用程序的类加载器在Web应用程序关闭时将不会被垃圾收集器回收！而IntrospectorCleanupListener则会对其进行适当的清理，已使其能够被垃圾收集器回收。

 

 2、Log4jConfigListener

        Spring提供了一个Log4jConfigListener，本身就能通过web.xml中配置来指定位置加载log4j配置文件和log输出路径，但是该 listener需要放在spring的Listener之前。 

 

        使用spring中的Log4jConfigListener有如如下好处：

                1、动态的改变日志级别和策略，不需要重启Web应用。

                2、把log文件定在 /WEB-INF/logs/ 而不需要写绝对路径。

                        系统把web目录的路径压入一个叫webapp.root的系统变量，日志保存路径就可以用相对路径了

                        log4j.appender.logfile.File=${webapp.root}/WEB-INF/logs/monia.log

                3、可以把log4j.properties和其他properties一起放在/WEB-INF/ ，而不是Class-Path。

                4、log4jRefreshInterval为6000表示开一条watchdog线程每6秒扫描一下配置文件的变化。

 

         在web.xml文件中添加如下配置：

Xml代码

 

1. <!-- 当同一个应用服务器中部署两个以上用到Log4jConfigListener的应用时，需要通过该参数加以区别 -->  
2. <context-param>  
3.     <param-name>webAppRootKey</param-name>  
4.     <param-value>some.web.root</param-value>  
5. </context-param>  
6.   
7. <context-param>  
8.     <param-name>log4jConfigLocation</param-name>  
9.     <param-value>WEB-INF/log4j.properties</param-value>  
10. </context-param>  
11.   
12. <context-param>  
13.     <param-name>log4jRefreshInterval</param-name>  
14.     <param-value>60000</param-value>  
15. </context-param>  
16.   
17. <listener>  
18.     <listener-class>org.springframework.web.util.Log4jConfigListener</listener-class>  
19. </listener>  

 

3、WebAppRootListener

       这个监听器就会在web上下文初始化的时候，调用webUtil的对应方法，首先获取到param-name对应的param-value，然后根据传递进去的ServletContext对象得到web的物理路径:String root = servletContext.getRealPath("/");接着把这个param-value作为key，root作为value放到system中System.setProperty(key, root);然后在web中可以用 System.get.....就可以得到web的跟目录的物理路径了。

        监听web.xml中的配置para-name为webAppRootKey的值，

Xml代码

 

1. <context-param>  
2.     <param-name>webAppRootKey</param-name>  
3.     <param-value>some.web.root</param-value>  
4. </context-param>  

         再配置该监听器

Xml代码

 

1. <listener>  
2.     <listener-class>org.springframework.web.util.WebAppRootListener</listener-class>  
3. </listener>  

         如果在web.xml中已经配置了Log4jConfigListener监听器，则不需要配置WebAppRootListener了。因为Log4jConfigListener已经包含了WebAppRootListener的功能。

 

 4、ContextLoaderListener

        启动Web容器时，自动装配ApplicationContext的配置信息。该监听器在web.xml中的配置如下：

Xml代码

 

1. <listener>  
2.     <listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>  
3. </listener>  

         如果在web.xml中不写任何参数配置信息，默认的路径是/WEB-INF/applicationContext.xml，在WEB-INF目录下创建的xml文件的名称必须是applicationContext.xml；如果是要自定义文件名可以在web.xml里加入contextConfigLocation这个context参数：

Xml代码

 

1. <context-param>    
2.     <param-name>contextConfigLocation</param-name>    
3.     <param-value>    
4.         /WEB-INF/classes/applicationContext-*.xml,  
5.         claaspath:/applicationContext-*.xml  
6.     </param-value>    
7. </context-param>   

 

5、RequestContextListener

        在Spring2.0中除了以前的Singleton和Prototype外又加入了三个新的web作用域，分别为request、session和global session。

       Request作用域：

                针对每次HTTP请求，Spring容器都会创建一个全新的bean实例，且该bean实例仅在当前HTTP request内有效。当处理请求结束，request作用域的bean实例将被销毁。

       Session作用域：

                针对某个HTTP Session，Spring容器会创建一个全新的bean实例，且该bean仅在当前HTTP Session内有效。当HTTP Session最终被废弃的时候，在该HTTP Session作用域内的bean也会被废弃掉。

       global session作用域：

                global session作用域类似于标准的HTTP Session作用域，不过它仅仅在基于portlet的web应用中才有意义。Portlet规范定义了全局Session的概念，它被所有构成某个portlet web应用的各种不同的portlet所共享。在global session作用域中定义的bean被限定于全局portlet Session的生命周期范围内。

 

       作用域依赖问题：如果将Web相关作用域的Bean注入到singleton或prototype的Bean中，这种情况下，需要Spring AOP

Xml代码

 

1. <bean name="car" class="com.demo.Car" scope="request">    
2.     <aop:scoped-proxy/>    
3. </bean>    
4. <bean id="boss" class="com.demo.Boss" >    
5.     <properrty name="car" ref="car" />    
6. </bean>   

       如果想让容器里的某个bean拥有其中某种新的web作用域，除了在bean级上配置相应的scope属性，还必须在容器级做一个额外的初始化配置。该监听器在web.xml中的配置如下：

Xml代码

 

1. <listener>  
2.     <listener-class>org.springframework.web.context.request.RequestContextListener</listener-class>  
3. </listener>