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

慢吞云雾缓吐愁 · 2023-5-9 13:48:05

每博一文案

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

复制代码

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 target="_blank" href="https://www.cnblogs.com/<%=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 ，大家可以移步至：
免责声明：如果侵犯了您的权益，请联系站长，我们会及时删除侵权内容，谢谢合作！

		自动登录	找回密码
密码			立即注册

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

本帖子中包含更多资源

0 个回复

快速回复

楼主热帖

标签云