Listener监听器，实现一个显示在线用户人数-Toy模板网

这篇具有很好参考价值的文章主要介绍了Listener监听器，实现一个显示在线用户人数。希望对大家有所帮助。如果存在错误或未考虑完全的地方，请大家不吝赐教，您也可以点击"举报违法"按钮提交疑问。

Listener监听器，实现一个显示在线用户人数

每博一文案

关于后半身，脾气越温，福报越深。
师傅说：惜命最好的方式不是养生，而是管好自己的情绪。
坏毛病都是惯出来的，但好脾气都是磨出来的，与人生气，伤的是和气，与自己生气，伤的是身体。
佛说：人有五毒心，贪嗔痴慢疑，其中一时的嗔念起，百万叶障深，火烧功德林，脾气来了，福气就走了。
破得了偏执，才修得了善行。世上最亏本的事，就是用一时的冲动消耗了积累的福报。
既然你是对的，那你没必要发脾气。但如果你是错的，那你就没资格发脾气。
在感情的世界里，愤怒时的态度也是丈量幸福的尺度。
一个人生气是怎么对你，他平时就怎么爱你，在一起久了，性格会互补，爱得多的脾气，
会越来越好，被爱的会越来越霸道，总得有一个人原意低头迁就，所有的包容都来自深爱，
所有的好脾气都是不想失去，因为彼此心灵都明白，争执不是唯一的目的，磨合得更紧密，才是
最重要的主题。
爱，就是什么都介意，最后又什么都原谅脾气，人人都有，拿出来是本能，但压下去才是本事。
一个人成熟的标志就是变得不爱生气了，因为能让你在意的事情变少了，以前能冒犯到你的，
现在都变得无所谓了，以前无法容忍的，现在想想就作罢了。就像灰尘落在身上，轻轻拂去就好了。
不用蹲下懊恼，阻碍了前行的脚步。
你只有这一生，不能慷慨赠与没有意义的人，也不必为不值得的事，就轻易放弃开心的权利。
愿你此生尽兴，时辰善良，愿你所有的快乐都无需假装。
                                    ——————《一禅心灵庙语》

Listener监听器，实现一个显示在线用户人数
- 每博一文案
- 1. Listener 监听器的概述
- 2. Listener 监听器在 Servlet 的体系结构
- 3. 编写一个 Listener 监听器的过程
  - 3.1 ServletContextListener
- 4. 其他Listener 监听器的使用：
  - 4.1 ServletRequestListener
  - 4.2 HttpSessionListener
  - 4.3 HttpSessionAttributeListener
  - 4.4 HttpSessionBindingListener
- 5. Listener监听器的案例：实现一个显示登录的在线人数
- 6. 总结：
- 7. 最后：

1. Listener 监听器的概述

Listener监听器，实现一个显示在线用户人数

Listener 监听器是Servlet规范中的一员。就像Filter一样。Filter也是Servlet规范中的一员。

在Servlet中，所有的监听器接口都是以Listener结尾。

Listener 监听器的作用：

监听器实际上是Servlet规范留给我们javaweb程序员的特殊时机。特殊的时刻如果想执行这段代码，你需要想到使用对应的监听器。

简单的说就是，当你的程序执行过程中满足的了/触发了某个事件，则该Listener 监听器中的方法就会被调用，并执行。比如：我们的Java中的 静态代码块 （当我们对于的类加载到内存当中时，该类当中的静态代码块，就会被执行，并且只会仅仅只会执行一次。）如下：
package com.RainbowSea.listener;

public class Test {

    // 只要这个 Test 类(被加加载到了内存，这个事件)当中，该静态代码块就会被执行，并且只会仅仅只会执行一次。
    static {
        System.out.println("静态代码块被执行了");
    }

    public static void main(String[] args) {
        Test test = new Test();  // 实例化，该对象的时候，就会将该 Test 类加载到内存当中,(该Test 加载
        // 到内存当中，该事件触发，执行其中 Test 类当中定义的 静态代码块。 )
    }


}
类似的，如果你对 javaScript 有一个了解的话，那么你就可以，更好的理解这里所受的 事件 这个元素了。因为JavaScript就是一个基于 触发事件的执行的语言。

2. Listener 监听器在 Servlet 的体系结构

概念：Listener表示监听器，是JavaWeb三大组件(Servlet、Filter、Listener)之一。
监听器可以监听就是在application，session，request三个对象创建、销毁或者往其中添加修改删除属性时自动执行代码的功能组件
Listener分类：JavaWeb中提供了8个监听器

监听器分类	监听器名称	作用
ServletContext监听	ServletContextListener	用于对ServletContext对象进行监听( 创建、销毁)
	ServletContextAttributeListener	对ServletContext对象中属性的监听( 增删改属性)
Session监听	HttpSessionListener	对Session对象的整体状态的监听（创建、销毁）
	HttpSessionBindingListener	监听对象与Session的绑定和解除
	HttpSessionActivationListener	对Session数据的钝化和活化的监听
Request监听	ServletRequestListener	对Request对象进行监听（创建、销毁）
	ServletContextAttributeListener	对Request对象中属性的监听（增删改属性）

下面的是基于 Tomcat 10 的环境下的：Servlet规范中提供的监听器？

jakarta.servlet包下：
- ServletContextListener
- ServletContextAttributeListener
- ServletRequestListener
- ServletRequestAttributeListener
jakarta.servlet.http包下：
- HttpSessionListener
- HttpSessionAttributeListener
  - 该监听器需要使用 @WebListener注解进行标注。
  - 该监听器监听的是什么？是session域中数据的变化。只要数据变化，则执行相应的方法。主要监测点在session域对象上。
- HttpSessionBindingListener
  - 该监听器不需要使用@WebListener进行标注。
  - 假设User类实现了该监听器，那么User对象在被放入session的时候触发bind事件，User对象从session中删除的时候，触发unbind事件。
  - 假设Customer类没有实现该监听器，那么Customer对象放入session或者从session删除的时候，不会触发bind和unbind事件。
  - 文章后面，会对其详细说明。
- HttpSessionIdListener
  - session的id发生改变的时候，监听器中的唯一一个方法就会被调用。
- HttpSessionActivationListener
  - 监听session对象的钝化和活化的。
  - 钝化：session对象从内存存储到硬盘文件。
  - 活化：从硬盘文件把session恢复到内存。

3. 编写一个 Listener 监听器的过程

3.1 ServletContextListener

除了Servlet和Filter外，JavaEE的Servlet规范还提供了第三种组件：Listener。

Listener顾名思义就是监听器，有好几种Listener，其中最常用的是ServletContextListener，我们编写一个实现了ServletContextListener接口。在编写之前我们先回顾一下： ServletContext 的作用：一个Web服务器可以运行一个或多个WebApp，对于每个WebApp，Web服务器都会为其创建一个全局唯一的ServletContext实例（因为一个 webApp 就只有一个名为 web.xml 的配置文件），我们在AppListener里面编写的两个回调方法实际上对应的就是ServletContext实例的创建和销毁：ServletContext是一个WebApp运行期的全局唯一实例，可用于设置和共享配置信息。

ServletContextListener 监听器作用是：要监听的是 ServletContext的对象的状态其中的两个方法 contextInitialized() 监听 ServletContext 的创建，contextDestroyed()监听 ServletContext 的销毁的，这个创建和销毁的状态事情。

Listener监听器，实现一个显示在线用户人数

其中两个方法是作用：

注意一点：就是：监听器中的方法不需要程序员手动调用，是发生某个特殊事件(触发)之后，被服务器调用。

/**
     ** Notification that the web application initialization process is starting.
     * All ServletContextListeners are notified of context initialization before
     * any filter or servlet in the web application is initialized.
     * The default implementation is a NO-OP.
     * @param sce Information about the ServletContext that was initialized
     */
    public default void contextInitialized(ServletContextEvent sce) {
        // 该方法的作用是：这个方法是在ServletContext 对象被创建的时候调用
        
    }

/**
     ** Notification that the servlet context is about to be shut down. All
     * servlets and filters have been destroyed before any
     * ServletContextListeners are notified of context destruction.
     * The default implementation is a NO-OP.
     * @param sce Information about the ServletContext that was destroyed
     */
    public default void contextDestroyed(ServletContextEvent sce) {
        // 这个方法是ServletContext 对象被销毁的时候执行
    }

上述两个方法是举例说明：

编写一个 Servlet 创建 ServletContext 应用域对象，触发创建 ServletContext 事件

package com.RainbowSea.listener;

import jakarta.servlet.ServletContext;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;


@WebServlet("/test")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // 创建 ServetContext 应用域对象
        ServletContext servletContext = request.getServletContext();

    }
}

创建 TestServletContextListener 类实现 ServletContextListener 接口，用于事件的触发，服务器调用其中的方法（）

package com.RainbowSea.listener;

import jakarta.servlet.ServletContextEvent;
import jakarta.servlet.ServletContextListener;



/**
 * ServletContextListener 是用来监视 ServletContext 应用域的状态的监听器
 */

public class TestServletContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 现在这个特殊的时刻写代码，你写就是了，他会被服务器自动调用了
        // 这个方法是在ServletContext 对象被创建的时候调用
        System.out.println("ServletContext  应用域对象创建了");

    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        //这个方法是 在 ServletContext 对象被销毁的时候调用的
        System.out.println("ServletContext 应用域对被销毁了");
    }
}

编写该 ServletContextListener 的配置信息，在 web.xml 当中，如下：

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns="https://jakarta.ee/xml/ns/jakartaee"
         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
         xsi:schemaLocation="https://jakarta.ee/xml/ns/jakartaee https://jakarta.ee/xml/ns/jakartaee/web-app_5_0.xsd"
         version="5.0">
    
    <listener>
        <listener-class>com.RainbowSea.listener.TestServletContextListener</listener-class>
    </listener>
    
</web-app>

也可以使用该注解@WebListener() 注解的方式，需要注意的是：该注解不需要赋值属性，使用默认的就可以了。

Listener监听器，实现一个显示在线用户人数

运行结果：

Listener监听器，实现一个显示在线用户人数

4. 其他Listener 监听器的使用：

介绍一些其他常用的：Listener 监听器的使用：

4.1 ServletRequestListener

ServletRequestListener 监听器的作用：监听的是 Request 请求域的状态，主要为：监听 ServletRequestListener() 销毁，requestInitialized() 创建。
Listener监听器，实现一个显示在线用户人数

Listener监听器，实现一个显示在线用户人数

ServletRequestListener 中的两个 default 默认方法的说明：

/**
     * The request is about to go out of scope of the web application.
     * The default implementation is a NO-OP.
     * @param sre Information about the request
     */
    public default void requestDestroyed (ServletRequestEvent sre) {
        // 该方法表示：当 request 请求对象销毁的时候执行。
    }

/**
     * The request is about to come into scope of the web application.
     * The default implementation is a NO-OP.
     * @param sre Information about the request
     */
    public default void requestInitialized (ServletRequestEvent sre) {
        // 表方法表示：当 request 请求对象创建的时候，执行
    }

举例：

package com.RainbowSea.listener;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;

import java.io.IOException;


@WebServlet("/test")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {


    }
}

package com.RainbowSea.listener;

import jakarta.servlet.ServletRequestEvent;
import jakarta.servlet.ServletRequestListener;
import jakarta.servlet.annotation.WebListener;


/**
 * ServletRequestLister 是用来监听 Request 请求域对象的销毁和创建两种状态的。
 */

@WebListener // 使用注解的方式,不要赋值，使用 默认值
public class TestServletRequestListener implements ServletRequestListener {

    // 该方法当 request 请求域对象要被销毁的时候，tomcat 服务器调用该方法
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("request 请求对象被销毁了");
    }

    // 该方法当 request 请求域对象创建的时候，Tomcat 服务器调用该方法
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("request 请求对象创建了");
    }
}

运行测试结果：

Listener监听器，实现一个显示在线用户人数
ng)

4.2 HttpSessionListener

**HttpSessionListener 监听的作用：是监听 session 会话域对象的创建和销毁的状态：sessionCreated()监视 Session 的创建，sessionDestroyed() 监视销毁。 **

Listener监听器，实现一个显示在线用户人数

其中两个方法的详细说明：

/**
     * Notification that a session was created.
     * The default implementation is a NO-OP.
     *
     * @param se
     *            the notification event
     */
    public default void sessionCreated(HttpSessionEvent se) {
        // 该方法当 session 会话域对象创建的时候，被 Tomcat 服务器调用并执行
    }

/**
     * Notification that a session is about to be invalidated.
     * The default implementation is a NO-OP.
     *
     * @param se
     *            the notification event
     */
    public default void sessionDestroyed(HttpSessionEvent se) {
        // 该方法当 session 会话域对象销毁的时候，被 Tomcat 服务器调用并执行
    }

举例1验证：

创建一个 MyServlet 类，该类当中创建 Session 会话域对象，触发 HttpSessionListener 中 session 销毁事件，让服务器调用其中的方法，同时编写调用 session 中的销毁的方法，触发销毁是事件。

package com.RainbowSea.listener;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;


@WebServlet("/test")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // session 会话域对象是来自服务器的，所有是通过 request 请求获取到的
        // 该方法如果服务器中没有 session 会话域对象，则自动创建
        HttpSession session = request.getSession();

        if (session != null) {
            // session 销毁
            session.invalidate();
        }

    }
}

package com.RainbowSea.listener;

import jakarta.servlet.annotation.WebListener;
import jakarta.servlet.http.HttpSessionEvent;
import jakarta.servlet.http.HttpSessionListener;


/**
 * HttpSessionListener 是用来监视 session 会话域对象的创建和销毁的状态的。
 */

@WebListener // 使用注解配置，不需要赋值使用默认的值
public class TestHttpSessionListener implements HttpSessionListener {
    @Override
    public void sessionCreated(HttpSessionEvent se) {
       // 该方法 session 创建的时候，被Tomcat 服务器调用并执行
        System.out.println("session 会话域对象创建了");
    }

    @Override
    public void sessionDestroyed(HttpSessionEvent se) {
        System.out.println("session 会话域对象被销毁了");
    }
}

测试效果：

Listener监听器，实现一个显示在线用户人数

举例2 我们启用 JSP中九大内置对象中的之一的 session 对象
Listener监听器，实现一个显示在线用户人数


<%@ page contentType="text/html;charset=UTF-8" language="java" %>
<html>
<head>
    <title>Title</title>
</head>
<body>

<a href="<%=request.getContextPath()%>/test"> session 会话销毁</a>

</body>
</html>

package com.RainbowSea.listener;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;


@WebServlet("/test")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // session 会话域对象是来自服务器的，所有是通过 request 请求获取到的
        // 该方法如果服务器中没有 session 会话域对象，不会自动创建
        HttpSession session = request.getSession(false);

        if (session != null) {  // 防止 null 引用
            // session 销毁
            session.invalidate();
        }

    }
}

package com.RainbowSea.listener;

import jakarta.servlet.ServletRequestEvent;
import jakarta.servlet.ServletRequestListener;
import jakarta.servlet.annotation.WebListener;


/**
 * ServletRequestLister 是用来监听 Request 请求域对象的销毁和创建两种状态的。
 */

//@WebListener // 使用注解的方式,不要赋值，使用 默认值
public class TestServletRequestListener implements ServletRequestListener {

    // 该方法当 request 请求域对象要被销毁的时候，tomcat 服务器调用该方法
    @Override
    public void requestDestroyed(ServletRequestEvent sre) {
        System.out.println("request 请求对象被销毁了");
    }

    // 该方法当 request 请求域对象创建的时候，Tomcat 服务器调用该方法
    @Override
    public void requestInitialized(ServletRequestEvent sre) {
        System.out.println("request 请求对象创建了");
    }
}

测试效果：

Listener监听器，实现一个显示在线用户人数

4.3 HttpSessionAttributeListener

HttpSessionAttributeListener 的监听器的作用是：监视向Session 会话域当中添加，修改，移除数据的状态的事件的监听。

Listener监听器，实现一个显示在线用户人数

同理的其中对应的这些

jakarta.servlet.ServletContextAttributeListener 也是一样的其作用是：向 ServletContext 应用域当中添加，修改，移除数据的状态的事件的监听。

Listener监听器，实现一个显示在线用户人数

jakarta.servlet.ServletRequestAttributeListener也是一样的其作用是：向 Request 请求域当中添加，修改，移除数据的状态的事件的监听。

Listener监听器，实现一个显示在线用户人数

这三者的接口的结构是一样的，其方法的作用也是一样的，使用的方法也是一样的，这里就不多赘述了，这里就仅仅对其中的 jakarta.servlet.http.HttpSessionAttributeListener 作演示，另外两个的使用大致都是和它是一样的。

这里下面是对jakarta.servlet.http.HttpSessionAttributeListener接口中的方法的说明：

/**
     * Notification that an attribute has been added to a session. Called after
     * the attribute is added.
     * The default implementation is a NO-OP.
     *
     * @param se Information about the added attribute
     */
    public default void attributeAdded(HttpSessionBindingEvent se) {
      // 向Session 会话域当中添加存储数据的时候，以下方法被服务器调用执行
    }

/**
     * Notification that an attribute has been removed from a session. Called
     * after the attribute is removed.
     * The default implementation is a NO-OP.
     *
     * @param se Information about the removed attribute
     */
    public default void attributeRemoved(HttpSessionBindingEvent se) {
        // 将Session 会话域当中的数据删除的时候，以下方法被服务器调用执行了
    }

/**
     * Notification that an attribute has been replaced in a session. Called
     * after the attribute is replaced.
     * The default implementation is a NO-OP.
     *
     * @param se Information about the replaced attribute
     */
    public default void attributeReplaced(HttpSessionBindingEvent se) {
         // 将Session 会话当中某个数据被替换修改了，以下方法被服务器调用执行
    }

举例验证：

package com.RainbowSea.listener;

import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;


@WebServlet("/test")
public class MyServlet extends HttpServlet {
    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response) throws ServletException,
            IOException {

        // session 会话域对象是来自服务器的，所有是通过 request 请求获取到的
        // 该方法如果服务器中没有 session 会话域对象，则会自动创建
        HttpSession session = request.getSession();

        // 向 session 会话域当中添加数据
        session.setAttribute("test",001);

        // 向 session 会话域当中替换数据
        session.setAttribute("test",100);

        // session 会话域当中移除数据
        session.removeAttribute("test");
    }
}

package com.RainbowSea.listener;

import jakarta.servlet.annotation.WebListener;
import jakarta.servlet.http.HttpSessionAttributeListener;
import jakarta.servlet.http.HttpSessionBindingEvent;


/**
 * HttpSessionAttributeListener 监视 session 会话域当中的数据的添加，移除，修改(替换) 事件的监听
 */
@WebListener // 使用注解：使用注解当中的默认值，不需要赋值
public class TestHttpSessionAttributeListener implements HttpSessionAttributeListener {
    @Override
    public void attributeAdded(HttpSessionBindingEvent se) {
        // 向 session 会话域当中添加数据时，该方法被服务器调用，并执行了
        System.out.println("session add 添加数据了");
    }

    @Override
    public void attributeRemoved(HttpSessionBindingEvent se) {
        // 向 session 会话域当中移除数据时，该方法被服务器调用，并执行了
        System.out.println("session removed 移除数据了");
    }

    @Override
    public void attributeReplaced(HttpSessionBindingEvent se) {
        // 向 session 会话域当中的数据 被 替换时，该方法被服务器调用，并执行了
        System.out.println("session replaced 替换数据了");
    }
}

Debugger 断点测试验证：

Listener监听器，实现一个显示在线用户人数

4.4 HttpSessionBindingListener

HttpSessionBindingListener 监视器的作用：是对应一个 Javabeen 对象的实现了implements HttpSessioniBingingListener 接口的添加到 Session 会话域当中的。

该监听器不需要使用@WebListener进行标注。
假设User类实现了该监听器，那么User对象在被放入session的时候触发绑定 bind事件，User对象从session中删除的时候，触发解绑 unbind事件。
假设Customer类没有实现该监听器，那么Customer对象放入session或者从session删除的时候，不会触发bind和unbind事件

Listener监听器，实现一个显示在线用户人数

如下是关于：HttpSessionBingingListener 两个方法的详细说明：

 /**
     * Notifies the object that it is being bound to a session and identifies
     * the session.
     * The default implementation is a NO-OP.
     *
     * @param event
     *            the event that identifies the session
     * @see #valueUnbound
     */
    public default void valueBound(HttpSessionBindingEvent event) {
        // 向 session 会话域当中添加 : 对象(该对象实现了 HttpSessionBingingListener) 的 javabeen 绑定数据 。
    }

/**
     * Notifies the object that it is being unbound from a session and
     * identifies the session.
     * The default implementation is a NO-OP.
     *
     * @param event
     *            the event that identifies the session
     * @see #valueBound
     */
    public default void valueUnbound(HttpSessionBindingEvent event) {
        // 将 session 会话域当中的移除: (该对象实现了 HttpSessionBingingListener) 的 javabeen ) 解绑数据
    }

**JavaBeen 类实现 HttpSessionBindingListener **

package com.RainbowSea.been;

import jakarta.servlet.http.HttpSessionBindingEvent;
import jakarta.servlet.http.HttpSessionBindingListener;

import java.util.Objects;

public class User implements HttpSessionBindingListener {
    private String name ;
    private String password;


    @Override
    public void valueBound(HttpSessionBindingEvent event) {
        // 将该 User 实现了 HttpSessionBindingListener 接口的 javabeen 添加到 session 会话域调用;
        System.out.println("Session  绑定 JavaBeen 数据");
    }

    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        // 将该 User 实现了 HttpSessionBindingListener 接口的 javabeen的从 session 会话域当中移除被调用
        System.out.println("Session 解绑 JaveBeen 数据");
    }

    public User() {
    }


    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(getName(), user.getName()) && Objects.equals(getPassword(), user.getPassword());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getPassword());
    }


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

package com.RainbowSea.listener;

import com.RainbowSea.been.User;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;


@WebServlet("/user")
public class TestHttpSessionBingingListener extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // 获取到 session 应用域对象
        HttpSession session = request.getSession();
        User  user = new User("Jack","123");

        // 向 session 应用域当中添加  实现了 HttpSessionBindingListener 的 JavaBeen
        session.setAttribute("user",user);

        //  将 session 应用域当中数据移除, session 当中的 javabeen
        session.removeAttribute("user");

    }
}

Debugger 测试：

Listener监听器，实现一个显示在线用户人数

举例测试：如果我们向 Session 添加的数据JavaBeen 并没有实现 HttpSessionBindingListener 这个接口，就算我们添加了 session是不会调用其中 HttpSessionBindingListener 接口中的 valueBound ()绑定和 valueUnBound() 解绑的

package com.RainbowSea.been;

import jakarta.servlet.http.HttpSessionBindingEvent;
import jakarta.servlet.http.HttpSessionBindingListener;

import java.util.Objects;

public class User {
    private String name ;
    private String password;



    public User() {
    }


    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }


    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }


    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(getName(), user.getName()) && Objects.equals(getPassword(), user.getPassword());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getPassword());
    }


    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

package com.RainbowSea.listener;

import com.RainbowSea.been.User;
import jakarta.servlet.ServletException;
import jakarta.servlet.annotation.WebServlet;
import jakarta.servlet.http.HttpServlet;
import jakarta.servlet.http.HttpServletRequest;
import jakarta.servlet.http.HttpServletResponse;
import jakarta.servlet.http.HttpSession;

import java.io.IOException;


@WebServlet("/user")
public class TestHttpSessionBingingListener extends HttpServlet {

    @Override
    protected void doGet(HttpServletRequest request, HttpServletResponse response)
            throws ServletException, IOException {

        // 获取到 session 应用域对象
        HttpSession session = request.getSession();
        User  user = new User("Jack","123");

        // 向 session 应用域当中添加  实现了 HttpSessionBindingListener 的 JavaBeen
        session.setAttribute("user",user);

        //  将 session 应用域当中数据移除, session 当中的 javabeen
        session.removeAttribute("user");

    }
}

Listener监听器，实现一个显示在线用户人数

HttpSessionBindingListener 与 HttpSessionAttrlbuteListener 的区别：

HttpSessionBindingListener 是不需要注解的也是不需要配置 web.xml 的
HttpSessionAttrlbuteListener 是需要注解/ 配置 web.xml 文件的
两者都是对应 Session 会话域的监听的。
HttpSessionBindingListener 中的如果我们向 Session 添加的数据JavaBeen 并没有实现 HttpSessionBindingListener 这个接口，就算我们添加了 session是不会调用其中 HttpSessionBindingListener 接口中的 valueBound ()绑定和 valueUnBound() 解绑的。
HttpSessionAttrlbuteListener 只要是向 session 添加，删除，修改(替换) 数据服务器都的调用其中的事件中的方法。

5. Listener监听器的案例：实现一个显示登录的在线人数

为了有助于大家阅读如下内容了解该 oa ，大家可以移步至：🔜🔜🔜 B/S 结构系统的缓存机制(Cookie) 以及基于 cookie 机制实现 oa 十天免登录的功能_ChinaRainbowSea的博客-CSDN博客

思考一个业务场景：
- 请编写一个功能，记录该网站实时的在线用户的个数。
- 我们可以通过服务器端有没有分配session对象，因为一个session代表了一个用户。有一个session就代表有一个用户。如果你采用这种逻辑去实现的话，session有多少个，在线用户就有多少个。这种方式的话：HttpSessionListener够用了。session对象只要新建，则count++，然后将count存储到ServletContext域当中，在页面展示在线人数即可。
- 业务发生改变了，只统计登录的用户的在线数量，这个该怎么办？
  - session.setAttribute("user", userObj);
  - 用户登录的标志是什么？session中曾经存储过User类型的对象。那么这个时候可以让User类型的对象实现HttpSessionBindingListener监听器，只要User类型对象存储到session域中，则count++，然后将count++存储到ServletContext对象中。页面展示在线人数即可。
实现oa项目中当前登录在线的人数。
- 什么代表着用户登录了？
  - session.setAttribute("user", userObj); User类型的对象只要往session中存储过，表示有新用户登录。
- 什么代表着用户退出了？
  - session.removeAttribute("user"); User类型的对象从session域中移除了。
  - 或者有可能是session销毁了。（session超时）

User 的 JavaBeen 核心代码：

public void valueBound(HttpSessionBindingEvent event) {
        // 用户登录了
        // Dept 类型的对象向session 中存放了
        // 获取到ServletContext 应用域对象，一个应用只要一个
        ServletContext application = event.getSession().getServletContext();

        Object onlinecount = application.getAttribute("onlinecount");

        // 用户第一次登录，一定是 onlinecout 是不存在的
        if(onlinecount == null) {
            // 向ServletContext 应用域对象，添加该用户，第一个用户的登录
            application.setAttribute("onlinecount", 1);
        } else {
            // 第二个用户的登录，就存在这个 onlinecount 应用域的对象信息了
            int count = (Integer) onlinecount;  // 将从 ServletContext 应用存储的信息用户的个数取出

            count++;
            application.setAttribute("onlinecount",count); // 修改，增加用户个数信息。
        }

    }

    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        // 用户退出了
        // Dept 类型的对象从 session 对象中删除了。
        // 存储在 ServletContext中的 onlinecount key 对应的 value 用户个数 --

        // 1. 获取到存储 ServletContext中的用户个数
        ServletContext servletContext = event.getSession().getServletContext();
        Object onlinecount = servletContext.getAttribute("onlinecount");

        int count = (Integer) onlinecount;
        count --;

        servletContext.setAttribute("onlinecount",count);

    }

完整核心代码：

package com.RainbowSea.bean;

import jakarta.servlet.ServletContext;
import jakarta.servlet.http.HttpSessionBindingEvent;
import jakarta.servlet.http.HttpSessionBindingListener;

import java.util.Objects;

public class User implements HttpSessionBindingListener {

    private String name;
    private String password;


    public User() {
    }

    public User(String name, String password) {
        this.name = name;
        this.password = password;
    }

    @Override
    public void valueBound(HttpSessionBindingEvent event) {
        // 用户登录了
        // Dept 类型的对象向session 中存放了
        // 获取到ServletContext 应用域对象，一个应用只要一个
        ServletContext application = event.getSession().getServletContext();

        Object onlinecount = application.getAttribute("onlinecount");

        // 用户第一次登录，一定是 onlinecout 是不存在的
        if(onlinecount == null) {
            // 向ServletContext 应用域对象，添加该用户，第一个用户的登录
            application.setAttribute("onlinecount", 1);
        } else {
            // 第二个用户的登录，就存在这个 onlinecount 应用域的对象信息了
            int count = (Integer) onlinecount;  // 将从 ServletContext 应用存储的信息用户的个数取出

            count++;
            application.setAttribute("onlinecount",count); // 修改，增加用户个数信息。
        }

    }

    @Override
    public void valueUnbound(HttpSessionBindingEvent event) {
        // 用户退出了
        // Dept 类型的对象从 session 对象中删除了。
        // 存储在 ServletContext中的 onlinecount key 对应的 value 用户个数 --

        // 1. 获取到存储 ServletContext中的用户个数
        ServletContext servletContext = event.getSession().getServletContext();
        Object onlinecount = servletContext.getAttribute("onlinecount");

        int count = (Integer) onlinecount;
        count --;

        servletContext.setAttribute("onlinecount",count);

    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getPassword() {
        return password;
    }

    public void setPassword(String password) {
        this.password = password;
    }

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof User)) return false;
        User user = (User) o;
        return Objects.equals(getName(), user.getName()) && Objects.equals(getPassword(), user.getPassword());
    }

    @Override
    public int hashCode() {
        return Objects.hash(getName(), getPassword());
    }

    @Override
    public String toString() {
        return "User{" +
                "name='" + name + '\'' +
                ", password='" + password + '\'' +
                '}';
    }
}

对应的JSP 列表用户，获取到存储到 Context 应用域当中在线用户的个数。

<h1 align="center">部门列表</h1>
<%--显示用户在线的个数，其信息存储在了 ServletContext()应用域当中了--%>
<h3>在线人数: <%=request.getServletContext().getAttribute("onlinecount")%></h3>
<%--注意这里使用的是 jsp 内置的 session 对象所以不可以，不要把 session 禁用了。--%>

完成的 JSP 代码：

<%@ page import="com.RainbowSea.bean.Dept" %>
<%@ page import="java.util.List" %>  <%--这是导包在jSP 当中，并翻译为import导入对于的报--%>
<%@ page import="java.lang.Integer" %>
<%@page contentType="text/html; charset=utf-8" %>

<!DOCTYPE html>
<html lang="en">
<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>部门列表页面</title>
</head>
<script type="text/javascript">
    function del(dno) {
        // 弹出确认框,用户点击确定，返回true,点击取消返回false
        var ok = window.confirm("亲,删了不可恢复哦!");
        if (ok) {
            // 发送请求进行删除数据的操作
            // 在js代码当中如何发送请求给服务器
            //
            // document.location.href="请求路径"
            // document.location = "请求路径"
            // window.location.href = "请求路径"
            // window.location = "请求路径"

            // 注意是根据所传的部门编号删除数据的
            document.location.href = "<%=request.getContextPath()%>/dept/delete?deptno=" + dno;

        }
    }
</script>

<body>
<h1 align="center">部门列表</h1>
<%--显示登录的用户名信息--%>
<%--<%

    ServletContext servletContext = session.getServletContext();
    Object onlinecount = servletContext.getAttribute("onlinecount");

%>--%>
<%--显示用户在线的个数，其信息存储在了 ServletContext()应用域当中了--%>
<h3>在线人数: <%=request.getServletContext().getAttribute("onlinecount")%></h3>
<%--注意这里使用的是 jsp 内置的 session 对象所以不可以，不要把 session 禁用了。--%>

<a href="<%=request.getContextPath()%>/user/exit">安全退出系统(手动清除 session 会话信息)</a>

<table border="1px" align="center" width="50%">
    <tr>
        <th>序号</th>
        <th>部门编号</th>
        <th>部门名称</th>
    </tr>

    <%
        // 获取到 request 域当中的数据，并取出来，我们知道是什么类型的数据，直接强制转换
        List<Dept> depList = (List<Dept>) request.getAttribute("depList");

        int i = 0;
        // 循环遍历List，取出数据
        for (Dept dept : depList) {
            // 在后台输出测试
            //System.out.println(dept.getDname());
            // 在浏览器显示 测试
            //out.write(dept.getDname() + "<br>");


    %>
    <%--    浏览器显示测试--%>
    <%--    <%=dept.getDname()%>--%>


    <tr>
        <td><%=++i%>
        </td>
        <td><%=dept.getDeptno()%>
        </td>
        <td><%=dept.getLoc()%>
        </td>
        <td>
            <!-- javascript:void(0)保持<a>超链接的格式，同时不会发生跳转
                我只是希望用户点击该超链接的时候执行一段js代码，不进行页面的跳转 -->
            <a href="javascript:void(0)" onclick="del(<%=dept.getDeptno()%>)">删除</a>
<%--            <a href="<%=request.getContextPath()%>/dept/detail?f=m&dno=<%=dept.getDeptno()%>">修改</a>--%>
<%--            <a href="<%=request.getContextPath()%>/dept/detail?f=d&dno=<%=dept.getDeptno()%>">详情</a>--%>
            <%-- 这里的修改，和详情都是需要 部门编号，我们可以进行一个统一处理，通过所传的不同的 f= 值作为
 标记，用于服务器端的 Servlet 判断转发处理到的--%>
            <%--            或者是--%>
            <a href="<%=request.getContextPath()%>/dept/detail?f=edit&dno=<%=dept.getDeptno()%>">修改</a>
            <a href="<%=request.getContextPath()%>/dept/detail?f=detail&dno=<%=dept.getDeptno()%>">详情</a>
        </td>
    </tr>

    <%
        }
    %>
</table>
<hr>
<a href="<%=request.getContextPath()%>/add.jsp">新增部门</a>
</body>

</html>

6. 总结：

监听器实际上是Servlet规范留给我们javaweb程序员的特殊时机。特殊的时刻如果想执行这段代码，你需要想到使用对应的监听器。简单的说就是，当你的程序执行过程中满足的了/触发了某个事件，则该Listener 监听器中的方法就会被调用，并执行。比如：我们的Java中的 静态代码块 （当我们对于的类加载到内存当中时，该类当中的静态代码块，就会被执行，并且只会仅仅只会执行一次。）
概念：Listener表示监听器，是JavaWeb三大组件(Servlet、Filter、Listener)之一。监听器可以监听就是在application，session，request三个对象创建、销毁或者往其中添加修改删除属性时自动执行代码的功能组件。Listener分类：JavaWeb中提供了8个监听器。
HttpSessionBindingListener 监视器的作用：是对应一个 Javabeen 对象的实现了implements HttpSessioniBingingListener 接口的添加到 Session 会话域当中的。
- 该监听器不需要使用@WebListener进行标注。
- 假设User类实现了该监听器，那么User对象在被放入session的时候触发绑定 bind事件，User对象从session中删除的时候，触发解绑 unbind事件。
- 假设Customer类没有实现该监听器，那么Customer对象放入session或者从session删除的时候，不会触发bind和unbind事件
HttpSessionBindingListener 与 HttpSessionAttrlbuteListener 的区别：
注意：所有监听器中的方法都是不需要javaweb程序员调用的，由服务器来负责调用？什么时候被调用呢？

当某个特殊的事件发生（特殊的事件发生其实就是某个时机到了。）之后，被web服务器自动调用。