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

监听器

功能

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

 内部原理

接口回调

什么是接口回调 

下面从没有使用接口开始，完成 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 ：  钝化后的那个文件存放的目录位置。