Servlet监听器详解及举例

待我称王封你为后i 2022-07-13 06:59 102阅读 0赞

监听器就是一个实现特定接口的普通java程序，这个程序专门用于监听另一个java对象的方法调用或属性改变，当被监听对象发生上述事件后，监听器某个方法将立即被执行。

#### 监听器原理 ####

**监听原理**  
1、存在事件源  
2、提供监听器  
3、为事件源注册监听器  
4、操作事件源，产生事件对象，将事件对象传递给监听器，并且执行监听器相应监听方法

监听器典型案例：监听window窗口的事件监听器  
例如：swing开发首先制造Frame\*\*窗体\*\*，窗体本身也是一个显示空间，对窗体提供监听器，监听窗体方法调用或者属性改变：  
\* 关闭窗体时，调用windowListener 的windowclosing() , 传递windowEvent参数，表示窗体关闭事件对象  
\* 事件对象操作事件源，获得事件源状态

#### 自定义监听器 ####

以上内容可以用下图解释：

![这里写图片描述][SouthEast]

通过person.addPersonListener(new PersonListener()\{\})使事件源与监听器间产生联系。

事件源（在事件源**方法中创建事件对象**）：

/**
     * 事件源对象，被监听
     *  
     */
    public class Person{
        
        private String name;
        private int weight;
        private PersonListener listener;
        //注册监听器
        public void addPersonListener(Personlistener listener){
            this.listener = listener;
        }
        //吃法
        public void eat(){
            //体重增加
            weight+=5;
            //在方法中调用监听器方法
            if(listener != null){
                //监听器存在
                //创建事件对象-----通过事件对象可以获得事件源
                PersonEvent event = new PersonEvent(this);
                listener.personeating(event);
            }
        }
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public int getWeight() {
            return weight;
        }
    
        public void setWeight(int weight) {
            this.weight = weight;
        }
    
    }

监听器(参数是事件对象)

/**
     * 监听器接口，提供对监听相应方法
     * 
     */
    public interface PersonListener{
        
        public void personeating(PersonEvent euent);//监听事件
    }

事件对象(通过事件对象可以获得事件源)

/**
     * 事件对象，当事件源发生动作改变，产生相应事件对象，该对象被传递给监听器指定方法
     * 
     */
    public class PersonEvent{
        
        public Object source;//事件源
        public Object getSource(){
            return source;
        }
        public void setSource(Object source){
            this.source = source;
        }
        //构造事件对象时，接收事件源
        public PersonEvebt(Person person){
            this.source = person;
        }
    }

测试方法

public class PersonTest(){
        public static void main(){
            //步骤一：创建事件源
            Person person = new Person();
            person.setName("Megustas");
            person.setWeight(100);
            //步骤二 创建监听器，注册写到一起
            person.addPersonListener(new PersonListener(){
                        @Override
                public void personeating(PersonEvent event) {
                    System.out.println("监听到了，人正在吃饭！");
                    // 在监听方法中可以用来获得 事件源 状态
                    Person person = (Person) event.getSource();
                    System.out.println(person.getName());
                    System.out.println(person.getWeight());
                }
            });
            // 步骤三 操作事件源
            person.eat();// 结果监听方法被调用
        }
    }

对上的**匿名类**补充：匿名内部类的作用是创建一个实现接口的匿名类对象，含义是创建一个继承自PersonListener的匿名类的对象）,通过new表达式返回的引用被自动向上转型为对PersonListener的引用

#### Servlet监听器 ####

（**不需要配置，但是监听器仍需要进行注册**）  
在Servlet规范中定义了多种类型的监听器，它们用于**监听的事件源**分别为 **ServletContext**, **HttpSession** 和 **ServletRequest** 这三个域对象。

**Servlet监听器分为三大类**  
1、数据域对象创建和销毁监听器  
2、数据域对象和属性变更监听器  
3、绑定到 HttpSession 域中的某个对象的状态的事件监听器

#### （一）数据域对象创建销毁监听器 — 监听三个与对象 （三个监听器） ####

**1、ServletContextListener : 用来监听ServletContext对象的创建和销毁**  
`contextInitialized(ServletContextEvent sce)` 监听创建  
`contextDestroyed(ServletContextEvent sce)` 监听销毁  
\* ServletContext对象代表全局唯一对象，每个web工程会产生一个ServletContext,服务器启动创建，服务器关闭销毁

编写监听器  
步骤一：编写类实现特定监听器接口  
步骤二：注册监听器，不是通过事件源，而是在web.xml 进行配置  
（**监听器和Servlet、Filter不同，不需要url配置，监听器执行不是由用户访问的，监听器 是由事件源自动调用的**）

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

**servletContext域对象何时创建和销毁**：

*  创建：服务器启动针对每一个web应用创建servletcontext
 *  销毁：服务器关闭前先关闭代表每一个web应用的servletContext

**ServletContextListener主流应用：**  
**第一个**：在服务器启动时，对一些对象进行初始化，并且将对象保存ServletContext数据范围内(因为在监听器内可以获得事件源对象) — 全局数据

*  例如：创建数据库连接池

**第二个**：对框架进行初始化 例如：Spring框架初始化通过ServletContextListener (因为监听器代码在服务器启动时执行)

*  Spring框架(配置文件随服务器启动加载) org.springframework.web.context.ContextLoaderListener

**第三个**：实现任务调度，启动定时程序 （Timer、TimerTask） 使一个程序，定时执行

import java.text.DateFormat;
    
    import java.text.ParseException;
    import java.text.SimpleDateFormat;
    import java.util.Date;
    import java.util.Timer;
    import java.util.TimerTask;
    
    import javax.servlet.ServletContext;
    import javax.servlet.ServletContextEvent;
    import javax.servlet.ServletContextListener;
    public class MyServletContextListener implements ServletContextListener {
        
    
        @Override
        public void contextDestroyed(ServletContextEvent sce) {
            System.out.println("监听ServletContext对象销毁了...");
        }
    
        @Override
        public void contextInitialized(ServletContextEvent sce) {
            System.out.println("监听ServletContext对象创建了...");
            // 获得事件源（本质也是getSource（）的调用）
            ServletContext servletContext = sce.getServletContext();//servletContext是全局对象
            // 向ServletContext 中保存数据
    
            // 启动定时器
            final Timer timer = new Timer();
            // 启动定时任务
    
             timer.schedule(new TimerTask() {
             @Override
             // 这就是一个线程
             public void run() {
             System.out.println("定时器执行了...");
             }
             }, 0, 3000); // 马上启动 每隔3秒重复执行
    
            // 指定时间启动定时器
            DateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd hh:mm:ss");
            try {
                Date first = dateFormat.parse("2016-12-28 10:42:00");
                timer.schedule(new TimerTask() {
                    int i;
    
                    @Override
                    public void run() {
                        i++;
                        System.out.println("从10点40分开始启动程序，每隔3秒重复执行");
                        //执行10次
                        if (i == 10) {
                            timer.cancel();// 取消定时器任务
                        }
                    }
                }, first, 3000);
            } catch (ParseException e) {
                e.printStackTrace();
            }
        }
    
    }

**比如说每天晚上十二点给过生日的人进行生日祝福，中国移动对账户进行同步，会在服务器使用较少的时间，例如凌晨之类，启动一段程序，进行同步**

java.util.Timer 一种线程设施，用于安排以后在后台线程中执行的任务。可安排任务执行一次，或者定期重复执行。  
Timer提供了启动定时任务方法 schedule  
\* schedule(TimerTask task, Date firstTime, long period) 用来在指定一个时间启动定时器，定期循环执行  
\* schedule(TimerTask task, long delay, long period) 用来在当前时间delay多少毫秒后启动定时器  
停止定时器，timer.cancel取消任务

**2、HttpSession 数据对象创建和销毁监听器 —– HttpSessionListener**

`sessionCreated(HttpSessionEvent se)` 监听Session对象创建  
`sessionDestroyed(HttpSessionEvent se)` 监听Session对象销毁

**Session何时创建**：request.getSession()  
**Session何时销毁**：关闭服务器，Session过期，session.invalidate  
\*Session过期时间通过web.xml配置（tomcat配置文件中），默认时间30分钟

配置：

<listener>
        <listener-class>
            cn.megustas.listener.MyHttpSessionListener
        </listener-class>
    </listener>

HttpSession监听器

public class MyHttpSessionListener implements HttpSessionListener{
        
        @Override
        public void sessionCreated(HttpSessionEvent se){
            //获得session中的id，通过事件对象
            System.out.println("session对象被创建了");
            HttpSession session = request.getSession();
            System.out.println("id" + session.getId());
        }
    
    }

现有如下JSP页面：

1.jsp

<body>
    <h1>这是一个JSP文件</h1>
    <a href="/megustas/demo1/2.jsp">销毁Session</a>
    </body>

2.jsp

<%
        session.invalidate();
    %>

**访问1.jsp时会执行监听器原因：**因为如果观察jsp的源码，jsp会被预处理成.java代码（在tomcat中work文件夹下，参见[http://blog.csdn.net/megustas\_jjc/article/details/53462025][http_blog.csdn.net_megustas_jjc_article_details_53462025]），我们打开这个.java代码的源码：

![这里写图片描述][SouthEast 1]

其中的getSession的实现实际就是request.getSession()

**3、HttpServletRequest对象的创建和销毁监听器 —- ServletRequestListener**

`requestInitialized(ServletRequestEvent sre)`—-监听request对象创建  
`requestDestroyed(ServletRequestEvent sre)` 监听request对象销毁

**Request何时创建**：请求发起时创建  
**Request何时销毁**：响应结束时销毁

例如：每次刷新界面都会创建销毁一次

**注意（创建销毁次数由请求次数决定）：**  
**使用forward** —- request创建销毁几次 —– 一次  
**使用sendRedirect** —- request创建销毁两次 （两次请求）

#### （二）ServletContext/HttpSession/ServletRequest中保存数据 创建、修改、移除监听器 ####

**ServletContextAttributeListener** 监听ServletContext中属性变化  
**HttpSessionAttributeListener** 监听HttpSession中属性变化  
**ServletRequestAttributeListener** 监听ServletRequest中属性变化

**attributeAdded** 监听属性添加 —- 当数据范围对象没有该属性，第一次添加时`setAttribute(name,value);`调用执行  
**attributeRemoved** 监听属性移除 —- 从一个数据范围对象删除一个已经存在属性`removeAttribute(name);`执行  
**attributeReplaced** 监听属性替换 —– 当一个数据范围已经存在一个属性，向数据范围添加相同名称属性`setAttribute(name,value);`触发替换方法

例如，此处我们用HttpSessionAttributeListener举例（ServletContextListener与ServletRequestListener同理）：

JSP页面

<%
        //属性添加，向session数据范围保存名称为那么，值为张三的属性
        //注意此时是name属性的创建，触发attributeAdded
        session.setAttribute("name","张三");
        //将session中的name属性值替换为李四
        session.setAttribute("name",李四);//触发attributeReplaced
        //移除name属性
        session.removeAttribute("name");//触发attributeReplaced
    
    %>

监听器

public class MyHttpSessionAttributeListener implements
            HttpSessionAttributeListener {
        
    
        @Override
        public void attributeAdded(HttpSessionBindingEvent se) {
            // 属性添加
            System.out.println("向session添加了一个属性...");
            // 知道添加属性名称和值
            HttpSession session = se.getSession();
    
            // se.getValue 但是这个方法不会返回当前值
            System.out.println("属性名称：" + se.getName());
            System.out.println("属性值：" + session.getAttribute(se.getName()));
        }
    
        @Override
        public void attributeRemoved(HttpSessionBindingEvent se) {
            // 属性移除
            System.out.println("从session移除了一个属性....");
    
            System.out.println("属性名称：" + se.getName());
    
        }
    
        @Override
        public void attributeReplaced(HttpSessionBindingEvent se) {
            // 属性替换
            System.out.println("将session中一个属性值替换为其他值...");
    
            HttpSession session = se.getSession();
            System.out.println("属性名称：" + se.getName());
            System.out.println("属性值：" + session.getAttribute(se.getName()));
        }
    
    }

<listener>
        <listener-class>
            cn.megustas.servlet.listener.MyHttpSessionAttributeListener
        <listener-class>
    </listener>

**注意：获得返回值通过session.getAttribute(se.getName())**

#### （三）被绑定Session对象，自我状态感知监听器 ####

保存在 Session 域中的对象可以有多种状态：**绑定**到 Session 中；从 Session 域中**解除绑定**；随 Session 对象持久化到一个存储设备中(**钝化**)；随 Session 对象从一个存储设备中恢复（**活化**）

被存放Session的Java对象，感知自我四种状态变化  
1、被绑定  
2、被解除绑定  
3、被钝化 —– 数据从内存序列化硬盘  
4、被活化 —- 数据从硬盘重新加载回内存

**HttpSessionBindingListener**实现接口的java对象，感知自己被绑定到Session或者从Session中解除绑定  
**HttpSessionActivationListener**实现接口的java对象，感知从内存被钝化硬盘上，从硬盘活化到内存中  
**实现这两个接口的类不需要 web.xml 文件中进行注册，都是由Session自主完成的，例如在存储对象的时候会自动调用绑定**

**HttpSessionBindingListener**  
\* `valueBound(HttpSessionBindingEvent event)` 绑定对象方法 —- `session.setAttribute(name,Object);`  
\* `valueUnbound(HttpSessionBindingEvent event)` 解除绑定方法 —–`session.removeAttribute()`、当Session对象销毁时，当中所有绑定对象解除绑定

JSP页面：

/**
     * 使Bean1对象感知 自我被绑定Session中，感知自我被Session解除绑定
     * 
     */
    public class Bean1 implements HttpSessionBindingListener {
        
        private int id;
        private String name;
    
        public int getId() {
            return id;
        }
    
        public void setId(int id) {
            this.id = id;
        }
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        @Override
        public void valueBound(HttpSessionBindingEvent event) {
            System.out.println("Bean1对象被绑定了...");
            // 当前对象，操作对象
            System.out.println("绑定对象name:" + this.name);
        }
    
        @Override
        public void valueUnbound(HttpSessionBindingEvent event) {
            System.out.println("Bean1对象被解除绑定了...");
            System.out.println("解除绑定对象name:" + this.name);
        }
    
    }

**HttpSessionActivationListener**  
\* `sessionDidActivate(HttpSessionEvent se)`感知对象被活化  
\* `sessionWillPassivate(HttpSessionEvent se)` 感知对象被钝化  
**使用场景**：Session保存数据，很长一段时间没用，但是不能销毁Session对象，不想占用服务器内存资源 —– 钝化（将服务器内存中数据序列化硬盘上）

/**
     * 感知钝化和活化
     * 
     */
    public class Bean2 implements HttpSessionActivationListener, Serializable {
        
        private String name;
        private double price;
    
        public String getName() {
            return name;
        }
    
        public void setName(String name) {
            this.name = name;
        }
    
        public double getPrice() {
            return price;
        }
    
        public void setPrice(double price) {
            this.price = price;
        }
    
        @Override
        public void sessionDidActivate(HttpSessionEvent se) {
            System.out.println("bean2对象被活化...");
        }
    
        @Override
        public void sessionWillPassivate(HttpSessionEvent se) {
            System.out.println("bean2对象被钝化...");
        }
    
    }

JSP界面

读取数据

<body>
    
    读取bean2的数据： ${bean2.name } , ${bean2.price }
    </body>

**注意**

钝化和活化应该由tomcat服务器 自动进行 —- 配置tomcat

<Context>
    //文件在1分钟之后执行钝化
    <Manager className="org.apache.catalina.session.PersistentManager" maxIdleSwap="1">
    //文件钝化到it315文件夹中
    <Store className="org.apache.catalina.session.FileStore" directory="it315"/>
    </Manager>
    </Context>

配置context有几个位置？  
1、tomcat/conf/context.xml 对所有虚拟主机 所有web工程生效  
2、tomcat/conf/Catalina/localhost/context.xml 对当前虚拟主机所有web工程生效  
3、当前工程/META-INF/context.xml 对当前工程有效

**钝化后** it315目录在哪里？在“tomcat/work/Catalina/localhost/项目名”目录中

**java对象如果想实现序列化，需要实现Serializable接口（因此上述Bean2实现Serializable接口，才可以被钝化，并之后进行活化并读取）**

[SouthEast]: /images/20220713/6a74da1b34e94246817b958ae8d7fd46.png
[http_blog.csdn.net_megustas_jjc_article_details_53462025]: http://blog.csdn.net/megustas_jjc/article/details/53462025
[SouthEast 1]: /images/20220713/11e188d1df7a40a4a42e8ac4b0e5e963.png