监听器(Listener)学习笔记(包括原理、JavaWeb监听器类型)

最新推荐文章于 2025-04-01 19:26:25 发布

余一

最新推荐文章于 2025-04-01 19:26:25 发布

阅读量4.7k

点赞数 6

文章标签：监听器原理接口回调

本文链接：https://blog.csdn.net/CPOHUI/article/details/88867048

版权

JavaWeb 专栏收录该内容

8 篇文章

订阅专栏

监听器

功能

监听某一个事件的发生或者状态的改变。

内部原理

接口回调

什么是接口回调

下面从没有使用接口开始，完成 A类(被监听者) 中的某一个条件被触发了，通知B类(监听者)(其实就是去调用B类的方法)的需求，逐步展示什么是接口回调。
A.java

package test;

public class A {
    public void print() {
        for(int i = 0; i < 10; i++) {
            if(i == 5) {
                System.out.println("A循环到了5了，该通知B了。");
                //下面是添加监听器
                B b = new B();
                b.printFive();
            }
        }
    }
}

B.java

package test;

public class B {
    public void printFive() {
        System.out.println("B被通知：A已经循环到了5， 所以B的这个方法printFive()将被调用");
    }
}

Main.java

package test;

public class Main {
    public static void main(String[] args) {
        A a = new A();
        a.print();
    }
}

运行结果

上面是不考虑接口回调的普通做法，那么什么是接口回调呢？

接口回调：事先先把一个对象传递给 A ，当A执行到某个状态时，通过这个对象，来调用B中的方法。但是注意，不是直接传递B的实例，而是传递一个接口的实例过去。

为什么要定义接口呢？

为了更加通用。A类的方法参数变为该接口的实例对象，不管经过多少年，只要需要通知类(如B类)实现了该接口，就都可以通过传递一个该接口的实例进行通知了。如果没有接口，后面的通知类只能去改写A类中的代码，如上面所示，new B对象，然后调用B类的方法，但是硬编码方式太伤了，而且要是你没有A类的源码呢？

PrintListener.java

public interface PrintListener {
    /**
     * 一旦出现了某一种事件或者达到了某一个状态，就调用这个方法。
     */
    void print();
}

A.java

public class A {
    public void addPrintListener(PrintListener listener) {
        for (int i = 0; i < 10; i++) {
            if (i == 5) {
                System.out.println("A循环到了5了，该通知B 了。");
                listener.print();
                /*              
                 * B b = new B();
                 * b.printFive();
                 * */
            }
        }
    }
}

B.java

public class B implements PrintListener{
    
    @Override
    public void print() {
        System.out.println("B被通知：A已经循环到了5， 所以B的这个方法print()将被调用");
    }
}

Main.java

public class Main {
    public static void main(String[] args) {
        A a = new A();
        //多态的体现
        a.addPrintListener(new B());
    }
}

运行结果

JavaWeb的监听器(接口)总共有8个，划分为三种类型

类型	对应的接口
监听三个作用域创建和销毁 (三个作用域:request、session、application)	作用域request --- ServletRequestListener 作用域session --- HttpSessionListener 作用域application --- ServletContextListener
监听三个作用域属性状态变更	request --- ServletRequestAttributeListener session --- HttpSessionAttributeListener servletContext --- ServletContextAttributeListener
监听httpSession里面存值的状态变更	HttpSessionBindingListener HttpSessionActivationListener

类型一: 监听三个作用域创建和销毁

使用监听器的一般步骤

定义一个类，实现接口
注册 | 配置监听器

监听器	request创建时间	request销毁时间
ServletRequestListener	访问服务器上的任意资源都会有请求出现	服务器已经对这次请求作出了响应。

监听器	servletcontext的创建时间	servletcontext销毁时间	作用
ServletContextListener	启动服务器的时候	关闭服务器或从服务器移除项目	完成自己想要的初始化工作执行自定义任务调度，执行某一个任务。

监听器	session的创建时间	session的销毁时间	作用
HttpSessionListener	只要调用getSession()方法	超时非正常关闭销毁正常关闭服务器(序列化)	统计在线人数

下面是一个使用ContextListener监听器的例子

MyServletContextListener.java

import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

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 销毁了...");
    }
}

注册监听器

<listener>
    <listener-class>listener.MyServletContextListener</listener-class>
</listener>

运行结果：
启动服务器

关闭服务器

类型二: 监听三个作用域属性状态变更

可以监听在作用域中值添加 | 替换 | 移除的动作。

1.request --- ServletRequestAttributeListener

2.session --- HttpSessionAttributeListener

3.servletContext --- ServletContextAttributeListener

可以看出上面三个监听器的方法名称都是一样的，下面以监听session为例：
MySessionListener.java

import javax.servlet.http.HttpSessionAttributeListener;
import javax.servlet.http.HttpSessionBindingEvent;

public class MySessionListener implements HttpSessionAttributeListener {
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {
        System.out.println("属性被添加进来了");
    }
    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {
        System.out.println("属性被移除了");
    }
    @Override
    public void attributeReplaced(HttpSessionBindingEvent se) {
        System.out.println("属性被替换了");
    }
}

同样地在web.xml中注册该监听器

<listener>
    <listener-class>listener02.MySessionListener</listener-class>
</listener>

写一个简单的JSP文件进行测试：Demo.jsp

<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
</head>
<body>
    <%
        session.setAttribute("name", "aobama");
        session.setAttribute("name", "zhangsan");
        session.removeAttribute("name");
    %>
</body>
</html>

运行结果：

类型三: 监听httpSession里面存值的状态变更

这一类监听器不用注册。

HttpSessionBindingListener

作用：监听对象与session 绑定和解除绑定的动作
用法：让javaBean 实现该接口即可

Bean01.java

import javax.servlet.http.HttpSessionBindingEvent;
import javax.servlet.http.HttpSessionBindingListener;

public class Bean01  implements HttpSessionBindingListener{
    private String name ;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void valueBound(HttpSessionBindingEvent event) {
        System.out.println("对象被绑定进来了");
    }
    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        System.out.println("对象被解除绑定");
    }
}

Demo.jsp

<%@page import="bean.Bean01"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
</head>
<body>
<%
    Bean01 bean = new Bean01();
    bean.setName("zhangsansan");    
    session.setAttribute("bean", bean);
    session.removeAttribute("bean");
%>
</body>
</html>

运行结果：

HttpSessionActivationListener

作用：用于监听现在session的值是钝化 (序列化, 把内存中的数据存储到硬盘上) 还是活化 (反序列化, 把硬盘中的数据读取到内存中) 的动作。

session的钝化活化的意义：

session中的值可能会很多，并且我们有很长一段时间不使用这个内存中的值，那么可以考虑把session的值可以存储到硬盘上【钝化】，等下一次在使用的时候，在从硬盘上提取出来。【活化】

Bean02.java

import javax.servlet.http.HttpSessionActivationListener;
import javax.servlet.http.HttpSessionEvent;

public class Bean02  implements HttpSessionActivationListener , Serializable{
     private String name;
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    @Override
    public void sessionWillPassivate(HttpSessionEvent se) {
        System.out.println("session中的值被钝化了...");
    }
    @Override
    public void sessionDidActivate(HttpSessionEvent se) {
        System.out.println("session中的值被活化了...");    
    }
}

Demo.jsp

<%@page import="bean.Bean02"%>
<%@ page language="java" contentType="text/html; charset=UTF-8" pageEncoding="UTF-8"%>
<!DOCTYPE html>
<html>
<head>
<meta charset="UTF-8">
</head>
<body>
    <%
        Bean02 bean = new Bean02();
        bean.setName("lisisi");
        session.setAttribute("bean", bean);
    %>
</body>
</html>

将项目运行后，进入Demo.jsp之后，正常关闭服务器，可看到一下结果：

序列化后的文件可以在服务器的文件中找到，如下：

重启服务器

如何让session的在一定时间内钝化?

做配置即可，有三种方式
    1. 在tomcat里面 conf/context.xml 里面配置
            对所有的运行在这个服务器的项目生效
    2. 在conf/Catalina/localhost/context.xml 配置
            对 localhost生效。  localhost:8080
    3. 在自己的web工程项目中的 META-INF/context.xml
            只对当前的工程生效。

配置内容如下：

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

参数解析：
maxIdleSwap ： 1分钟不用就钝化
directory ：  钝化后的那个文件存放的目录位置。