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

在这里插入图片描述

每博一文案

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

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

1. 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 的销毁的，这个创建和销毁的状态事情。

在这里插入图片描述

其中两个方法是作用：

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

/**
     ** 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() 注解的方式，需要注意的是：该注解不需要赋值属性，使用默认的就可以了。

在这里插入图片描述

运行结果：

在这里插入图片描述

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

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

4.1 ServletRequestListener

ServletRequestListener 监听器的作用：监听的是 Request 请求域的状态，主要为：监听 ServletRequestListener() 销毁，requestInitialized() 创建。
在这里插入图片描述

在这里插入图片描述

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 请求对象创建了");
    }
}

运行测试结果：

在这里插入图片描述
ng)

4.2 HttpSessionListener

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

在这里插入图片描述

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

/**
     * 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 会话域对象被销毁了");
    }
}

测试效果：

在这里插入图片描述

举例2 我们启用 JSP中九大内置对象中的之一的 session 对象
在这里插入图片描述


<%@ 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 请求对象创建了");
    }
}

测试效果：

在这里插入图片描述

4.3 HttpSessionAttributeListener

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

在这里插入图片描述

同理的其中对应的这些

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

在这里插入图片描述

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

在这里插入图片描述

这三者的接口的结构是一样的，其方法的作用也是一样的，使用的方法也是一样的，这里就不多赘述了，这里就仅仅对其中的 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 断点测试验证：

在这里插入图片描述

4.4 HttpSessionBindingListener

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

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

在这里插入图片描述

如下是关于：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 测试：

在这里插入图片描述

举例测试：如果我们向 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");

    }
}

在这里插入图片描述

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服务器自动调用。

7. 最后：

限于自身水平，其中存在的错误，希望大家给予指教，韩信点兵——多多益善，谢谢大家，江湖再见，后会有期！！！

原文链接：https://www.cnblogs.com/TheMagicalRainbowSea/p/17384849.html

本站文章如无特殊说明，均为本站原创，如若转载，请注明出处：Listener监听器，实现一个显示在线用户人数 - Python技术站

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. 最后：

相关文章