快速学习JavaWeb中监听器(Listener)的使用方法_java

一、监听器介绍

1.1、监听器的概念

　

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

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

package me.gacl.listener.demo;

import java.awt.Frame;
import java.awt.event.WindowEvent;
import java.awt.event.WindowListener;

public class Demo1 {

  /**
   *java的事件监听机制
   *1、事件监听涉及到三个组件：事件源、事件对象、事件监听器
   *2、当事件源上发生某一个动作时，它会调用事件监听器的一个方法，并在调用该方法时把事件对象传递进去，
   *  开发人员在监听器中通过事件对象，就可以拿到事件源，从而对事件源进行操作。
   */
  public static void main(String[] args) {

    Frame f = new Frame();
    f.setSize(400, 400);
    f.setVisible(true);

    //注册事件监听器
    f.addWindowListener(new WindowListener(){

      public void windowActivated(WindowEvent e) {

      }

      public void windowClosed(WindowEvent e) {

      }

      /**
       * 当window窗体关闭时就会WindowListener这个监听器监听到，
       * 监听器就会调用windowClosing方法处理window窗体关闭时的动作
       */
      public void windowClosing(WindowEvent e) {
        //通过事件对象e来获取事件源对象
        Frame f = (Frame) e.getSource();
        System.out.println(f+"窗体正在关闭");
        f.dispose();
      }

      public void windowDeactivated(WindowEvent e) {

      }

      public void windowDeiconified(WindowEvent e) {

      }

      public void windowIconified(WindowEvent e) {

      }

      public void windowOpened(WindowEvent e) {

      }
    });
  }
}

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

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

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

package me.gacl.observer;

/**
* @ClassName: Person(事件源)
* @Description: 设计一个Person类作为事件源，这个类的对象的行为(比如吃饭、跑步)可以被其他的对象监听
* @author: 孤傲苍狼
* @date: 2014-9-9 下午9:26:06
*
*/
public class Person {
  /**
  * @Field: listener
  *     在Person类中定义一个PersonListener变量来记住传递进来的监听器
  */
  private PersonListener listener;

  /**
  * @Method: eat
  * @Description: 设计Person的行为：吃
  * @Anthor:孤傲苍狼
  *
  */
  public void eat() {
    if (listener != null) {
      /**
       * 调用监听器的doeat方法监听Person类对象eat(吃)这个动作，将事件对象Event传递给doeat方法，
       * 事件对象封装了事件源，new Event(this)中的this代表的就是事件源
       */
      listener.doeat(new Event(this));
    }
  }

  /**
  * @Method: run
  * @Description: 设计Person的行为：跑
  * @Anthor:孤傲苍狼
  *
  */
  public void run() {
    if (listener != null) {
      /**
       * 调用监听器的dorun方法监听Person类对象run(跑)这个动作，将事件对象Event传递给doeat方法，
       * 事件对象封装了事件源，new Event(this)中的this代表的就是事件源
       */
      listener.dorun(new Event(this));
    }
  }

  /**
  * @Method: registerListener
  * @Description: 这个方法是用来注册对Person类对象的行为进行监听的监听器
  * @Anthor:孤傲苍狼
  *
  * @param listener
  */
  public void registerListener(PersonListener listener) {
    this.listener = listener;
  }
}

/**
* @ClassName: PersonListener(事件监听器)
* @Description: 设计Person类(事件源)的监听器接口
* @author: 孤傲苍狼
* @date: 2014-9-9 下午9:28:06
*
*/
interface PersonListener {

  /**
  * @Method: doeat
  * @Description: 这个方法是用来监听Person对象eat(吃)这个行为动作，
  *         当实现类实现doeat方法时就可以监听到Person类对象eat(吃)这个动作
  * @Anthor:孤傲苍狼
  *
  * @param e
  */
  void doeat(Event e);

  /**
  * @Method: dorun
  * @Description: 这个方法是用来监听Person对象run(跑)这个行为动作，
  *         当实现类实现dorun方法时就可以监听到Person类对象run(跑)这个动作
  * @Anthor:孤傲苍狼
  *
  * @param e
  */
  void dorun(Event e);

}

/**
* @ClassName: Event(事件对象)
* @Description:设计事件类，用来封装事件源
* @author: 孤傲苍狼
* @date: 2014-9-9 下午9:37:56
*
*/
class Event {

  /**
  * @Field: source
  *     事件源(Person就是事件源)
  */
  private Person source;

  public Event() {

  }

  public Event(Person source) {
    this.source = source;
  }

  public Person getSource() {
    return source;
  }

  public void setSource(Person source) {
    this.source = source;
  }
}

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

package me.gacl.observer;

public class PersonTest {

  /**
   * @Method: main
   * @Description: 测试Person类
   * @Anthor:孤傲苍狼
   *
   * @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中的监听器

2.1、基本概念

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

2.2、Servlet监听器的分类

　　在Servlet规范中定义了多种类型的监听器，它们用于监听的事件源分别为ServletContext，HttpSession和ServletRequest这三个域对象
　　Servlet规范针对这三个对象上的操作，又把多种类型的监听器划分为三种类型：
 •监听域对象自身的创建和销毁的事件监听器。
 •监听域对象中的属性的增加和删除的事件监听器。
 •监听绑定到HttpSession域中的某个对象的状态的事件监听器。 

2.3、监听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对象的创建和销毁这两个动作进行监听。
* @author: 孤傲苍狼
* @date: 2014-9-9 下午10:26:16
*
*/
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对象销毁");
  }
}

　　2、在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对象进行监听了。

2.4、监听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对象的创建和销毁这两个动作进行监听。
* @author: 孤傲苍狼
* @date: 2014-9-9 下午11:04:33
*
*/
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>

运行结果如下：

2.5、监听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对象的创建和销毁这两个动作进行监听。
* @author: 孤傲苍狼
* @date: 2014-9-9 下午11:50:08
*
*/
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>

测试结果如下：

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

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

以上是小编为您精心准备的的内容，在的博客、问答、公众号、人物、课程等栏目也有的相关内容，欢迎继续使用右上角搜索按钮进行搜索javaweb
， listener
监听器
，以便于您获取更多的相关知识。

时间： 2024-03-07 02:47:48

快速学习JavaWeb中监听器(Listener)的使用方法_java的相关文章

深入学习JavaWeb中监听器(Listener)的使用方法_java

一.监听域对象中属性的变更的监听器 域对象中属性的变更的事件监听器就是用来监听 ServletContext, HttpSession, HttpServletRequest 这三个对象中的属性变更信息事件的监听器. 这三个监听器接口分别是ServletContextAttributeListener, HttpSessionAttributeListener 和ServletRequestAttributeListener,这三个接口中都定义了三个方法来处理被监听对象中的属性的增加,删除和替换

Java中对话框的弹出方法_java

最近在做学校的课程设计,java编程需要用到对话框弹出,第一反应是js中的alert和confirm,java的话瞬间懵,查阅学习总结如下,用以以后的学习 1.显示一个错误对话框,该对话框显示的 message 为 'alert': JOptionPane.showMessageDialog(null, "alert", "alert", JOptionPane.ERROR_MESSAGE); 2.显示一个内部信息对话框,其 message 为 'informati

2种Java删除ArrayList中的重复元素的方法_java

这篇文章将给出两种从ArrayList中删除重复元素的方法,分别是使用HashSet和LinkedHashSet. ArrayList是Java中最常用的集合类型之一.它允许灵活添加多个null元素,重复的元素,并保持元素的插入顺序.在编码时我们经常会遇到那种必须从已建成的ArrayList中删除重复元素的要求. 方法1:使用HashSet删除ArrayList中重复的元素 在该方法中,我们使用HashSet来删除重复的元素.如你所知,HashSet不允许有重复的元素.我们使用HashSet的这

JAVA中的deflate压缩实现方法_java

在文件的传输过程中,为了使大文件能够更加方便快速的传输,一般采用压缩的办法来对文件压缩后再传输,JAVA中的java.util.zip包中的Deflater和Inflater类为使用者提供了DEFLATE算法的压缩功能,以下是自已编写的压缩和解压缩实现,并以压缩文件内容为例说明,其中涉及的具体方法可查看JDK的API了解说明. /** * * @param inputByte * 待解压缩的字节数组 * @return 解压缩后的字节数组 * @throws IOException */ pub

Json在Struts中的转换与传递方法_java

本文主要探讨普通数据如何快速转换为Json数据,一共讨论2种方法: 首相准备页面和实体类: 页面: <body> <div id="topLoginDiv"> 用户名: <input name="user.name" id="loginName" />  密码: <input name="user.password" id="loginPassword" />

使用CORS实现JavaWeb跨域请求问题的方法_java

之前用jsonp 解决跨域问题,现在用CORS实现跨域请求解决java 跨域问题: 主要代码如下 package com.hy.fliter; import java.io.IOException; import javax.servlet.Filter; import javax.servlet.FilterChain; import javax.servlet.FilterConfig; import javax.servlet.ServletException; import javax.

dom4j从jar包中读取xml文件的方法_java

进行封装的时候,我们常常需要用xml来定义一些规范,在单独运行读取的时候当然不会有问题,但这些xml是往往是放在jar包里的,这样一来,这些东西就找不出来了.文中用到的xml定义如下: 复制代码 代码如下: <?xml version="1.0" encoding="utf-8"?><ACCESOS> <item>  <SOCIO name="adsf">   <NUMERO>00045

java中List对象排序通用方法_java

本文实例讲述了java中List对象排序通用方法.分享给大家供大家参考.具体分析如下: 在数据库中查出来的列表list中,往往需要对不同的字段重新排序,一般的做法都是使用排序的字段,重新到数据库中查询.如果不到数据库查询,直接在第一次查出来的list中排序,无疑会提高系统的性能. 只要把第一次查出来的结果存放在session中,就可以对list重新排序了.一般对list排序可以使用Collections.sort(list),但如果list中包含是一个对象的话,这种方法还是行不通的.那要怎么排序

java集合类arraylist循环中删除特定元素的方法_java

在项目开发中,我们可能往往需要动态的删除ArrayList中的一些元素. 一种错误的方式: <pre name="code" class="java">for(int i = 0 , len= list.size();i<len;++i){ if(list.get(i)==XXX){ list.remove(i); } }  上面这种方式会抛出如下异常:   Exception in thread "main" java.lan