ServletContextListener 的用法笔记250417

kfepiza2025-04-18 10:35

ServletContextListener 的用法笔记250417

ServletContextListener 是 Java Servlet 规范中的一个接口，用于监听 Web 应用的启动和关闭事件。通过实现该接口，开发者可以在应用初始化时执行资源加载、配置读取等操作，在应用销毁时执行资源释放、清理等任务。

核心用法步骤

  1. 实现 ServletContextListener 接口

    java 复制代码 
    import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyAppListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 应用启动时执行初始化操作
        System.out.println("应用启动：加载配置文件/初始化数据库连接池...");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 应用关闭时执行清理操作
        System.out.println("应用关闭：释放资源/关闭连接池...");
    }
}

  2. 配置监听器

    • 方式一：使用 web.xml

      xml 复制代码 
      <listener>
    <listener-class>com.example.MyAppListener</listener-class>
</listener>

    • 方式二：使用 @WebListener 注解（Servlet 3.0+）

      java 复制代码 
      @WebListener
public class MyAppListener implements ServletContextListener { ... }

典型应用场景

  1. 初始化全局配置

    java 复制代码 
    public void contextInitialized(ServletContextEvent sce) {
    // 读取 web.xml 中的 <context-param>
    String configPath = sce.getServletContext().getInitParameter("configPath");
    // 加载配置文件到应用作用域
    Properties config = loadConfig(configPath);
    sce.getServletContext().setAttribute("appConfig", config);
}

  2. 管理数据库连接池

    java 复制代码 
    public void contextInitialized(ServletContextEvent sce) {
    // 初始化连接池（如 HikariCP）
    HikariConfig config = new HikariConfig("/db.properties");
    HikariDataSource dataSource = new HikariDataSource(config);
    sce.getServletContext().setAttribute("dataSource", dataSource);
}

public void contextDestroyed(ServletContextEvent sce) {
    // 关闭连接池
    DataSource dataSource = (DataSource) sce.getServletContext().getAttribute("dataSource");
    if (dataSource instanceof HikariDataSource) {
        ((HikariDataSource) dataSource).close();
    }
}

  3. 启动后台任务（如定时任务）

    java 复制代码 
    private ScheduledExecutorService scheduler;

public void contextInitialized(ServletContextEvent sce) {
    scheduler = Executors.newScheduledThreadPool(1);
    scheduler.scheduleAtFixedRate(() -> System.out.println("定时任务执行..."), 0, 1, TimeUnit.HOURS);
}

public void contextDestroyed(ServletContextEvent sce) {
    if (scheduler != null) {
        scheduler.shutdown();
    }
}

注意事项

  1. 执行顺序

    多个监听器的执行顺序由 web.xml 中 <listener> 的声明顺序决定，或由类加载顺序决定（使用注解时）。

  2. 避免阻塞操作
    contextInitialized 方法应避免长时间阻塞，否则会延迟应用启动。

  3. 上下文参数

    可通过 <context-param> 配置参数，在监听器中用 getInitParameter(String name) 获取。

  4. 与 Spring 集成

    Spring 的 ContextLoaderListener 是 ServletContextListener 的实现类，用于加载 Spring 的根应用上下文。

1️⃣ 参考 1

ServletContextListener 是用于监听 Web 应用生命周期事件的接口，允许在应用启动或关闭时执行初始化或清理操作。以下是其详细用法和注意事项：

1. 核心方法

  • contextInitialized(ServletContextEvent sce)

    当应用启动时调用，适合执行初始化操作（如加载配置、创建连接池）。

  • contextDestroyed(ServletContextEvent sce)

    当应用关闭时调用，用于释放资源（如关闭连接池、停止定时任务）。

2. 实现步骤

步骤 1：创建监听器类
java 复制代码 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class AppContextListener implements ServletContextListener {
    
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 初始化操作，例如创建数据库连接池
        DataSource pool = createConnectionPool();
        sce.getServletContext().setAttribute("dbPool", pool);
        System.out.println("应用启动：资源初始化完成");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 清理资源
        DataSource pool = (DataSource) sce.getServletContext().getAttribute("dbPool");
        if (pool != null) {
            pool.close();
        }
        System.out.println("应用关闭：资源已释放");
    }

    private DataSource createConnectionPool() {
        // 实现创建连接池的逻辑
        return new DataSource();
    }
}
步骤 2：注册监听器

  • 方式一：通过 web.xml 配置

    xml 复制代码 
    <web-app>
    <listener>
        <listener-class>com.example.AppContextListener</listener-class>
    </listener>
    <!-- 可配置上下文参数 -->
    <context-param>
        <param-name>dbUrl</param-name>
        <param-value>jdbc:mysql://localhost:3306/mydb</param-value>
    </context-param>
</web-app>

  • 方式二：使用 @WebListener 注解（Servlet 3.0+）

    java 复制代码 
    @WebListener
public class AppContextListener implements ServletContextListener {
    // 方法实现同上
}

3. 关键应用场景

  • 初始化全局资源：如数据库连接池、缓存系统、读取配置文件。
  • 启动/停止后台服务：如定时任务、消息队列消费者。
  • 统计应用状态：记录应用启动次数、运行时间。

4. 注意事项

  • 参数获取 ：通过 ServletContext 的 getInitParameter("paramName") 读取 web.xml 中的 <context-param>。
  • 异常处理 ：在 contextInitialized 中抛出异常会阻止应用启动，需确保代码健壮性。
  • 执行顺序 ：多个监听器的执行顺序按 web.xml 中定义的顺序或类加载顺序，无依赖时可忽略，有依赖时需显式控制。
  • 线程安全 ：存储在 ServletContext 中的对象需线程安全（如连接池），避免多线程竞争。
  • 集群环境：每个应用实例（JVM）会独立触发监听器，需确保资源管理适合分布式场景。

5. 示例：读取配置并初始化

java 复制代码 
public void contextInitialized(ServletContextEvent sce) {
    ServletContext ctx = sce.getServletContext();
    String dbUrl = ctx.getInitParameter("dbUrl");
    DataSource pool = createPool(dbUrl); // 根据配置创建连接池
    ctx.setAttribute("dbPool", pool);
}

6. 测试与验证

  • 部署应用后，观察控制台日志，确认初始化与销毁日志输出。
  • 通过访问 Servlet 验证资源（如连接池）是否可用。
  • 模拟应用关闭（如关闭服务器），确认资源释放逻辑执行。

总结

ServletContextListener 是管理 Web 应用全局生命周期任务的强大工具，合理使用可提升资源管理效率和应用可维护性。重点在于正确实现生命周期方法、合理注册监听器，并注意线程安全与异常处理。

2️⃣ 参考 2

在Java Web开发中，ServletContextListener 是用于监听 Web应用生命周期事件 的接口，它允许你在应用启动（初始化）和关闭时执行自定义逻辑。以下是其用法详解：

一、核心作用

  1. 应用启动时：执行初始化任务（如加载配置、建立数据库连接池）。
  2. 应用关闭时：执行清理任务（如释放资源、关闭连接池）。

二、实现步骤

1. 创建监听器类

实现 javax.servlet.ServletContextListener 接口，重写两个方法：

java 复制代码 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener // 注解方式（Servlet 3.0+）
public class MyAppListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 应用启动时执行
        System.out.println("应用初始化...");
        ServletContext ctx = sce.getServletContext();
        ctx.setAttribute("dbConfig", loadDatabaseConfig()); // 存储全局变量
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 应用关闭时执行
        System.out.println("应用关闭，释放资源...");
        closeResources();
    }

    private Object loadDatabaseConfig() { /* 加载配置逻辑 */ return null; }
    private void closeResources() { /* 释放资源逻辑 */ }
}
2. 配置监听器（两种方式）

方式一：注解配置（推荐）

  • 使用 @WebListener 注解，无需额外配置。

方式二：web.xml 配置（传统方式）

xml 复制代码 
<listener>
    <listener-class>com.example.MyAppListener</listener-class>
</listener>

三、典型应用场景

  1. 初始化全局资源

    java 复制代码 
    // 在 contextInitialized 中
ConnectionPool pool = new ConnectionPool();
ctx.setAttribute("dbPool", pool);

  2. 统计在线人数

    java 复制代码 
    public void sessionCreated(HttpSessionEvent se) {
    Integer count = (Integer) ctx.getAttribute("onlineCount");
    ctx.setAttribute("onlineCount", (count == null) ? 1 : count + 1);
}

  3. 加载缓存数据

    java 复制代码 
    public void contextInitialized(ServletContextEvent sce) {
    CacheManager.loadHotData();
}

四、注意事项

  1. 执行顺序 ：多个监听器按配置顺序执行，可用 @Order 注解控制（Spring环境）。
  2. 避免耗时操作 ：contextInitialized 应快速完成，否则影响应用启动速度。
  3. 线程安全：确保监听器代码线程安全，因容器可能多线程调用。

五、调试技巧

  • 日志输出：在方法中打印日志，观察应用启动/关闭时的执行流程。
  • 断点调试：在IDE中设置断点，跟踪监听器执行过程。

通过合理使用 ServletContextListener，可以实现Web应用的优雅初始化和资源释放，提升系统健壮性。

3️⃣ 参考 3

ServletContextListener 是 Java Web 开发中用于监听 Web 应用程序生命周期 的接口，主要在 应用启动 和 关闭 时触发相应方法，常用于初始化或清理全局资源。以下是其用法的详细说明：

1. 核心方法

要使用 ServletContextListener，需实现以下两个方法：

  • contextInitialized(ServletContextEvent event)
    当 Web 应用启动时调用，可用于初始化全局资源（如数据库连接池、加载配置文件等）。
  • contextDestroyed(ServletContextEvent event)
    当 Web 应用关闭时调用，用于释放资源（如关闭数据库连接、保存数据等）。

2. 实现步骤

步骤 1：创建监听器类

实现 ServletContextListener 接口，并重写上述方法。

java 复制代码 
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent event) {
        ServletContext context = event.getServletContext();
        // 初始化操作（如加载配置文件）
        String configPath = context.getInitParameter("configPath");
        // 读取配置文件并保存到 context 中
        context.setAttribute("configData", loadConfig(configPath));
        System.out.println("应用已启动，初始化完成！");
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        // 清理操作（如关闭资源）
        System.out.println("应用已关闭，资源已释放！");
    }

    private Object loadConfig(String path) {
        // 模拟加载配置文件的逻辑
        return new Object();
    }
}
步骤 2：注册监听器

有两种方式注册监听器：

方式 1：在 web.xml 中配置
xml 复制代码 
<web-app>
    <!-- 其他配置 -->
    <listener>
        <listener-class>com.example.MyContextListener</listener-class>
    </listener>
</web-app>
方式 2：使用注解（Java EE 6+）

在监听器类上添加 @WebListener 注解：

java 复制代码 
import javax.servlet.annotation.WebListener;

@WebListener
public class MyContextListener implements ServletContextListener {
    // 方法同上
}

3. 典型应用场景

场景 1：初始化数据库连接池
java 复制代码 
@Override
public void contextInitialized(ServletContextEvent event) {
    ServletContext context = event.getServletContext();
    // 初始化数据库连接池
    DataSource dataSource = new BasicDataSource();
    dataSource.setDriverClassName("com.mysql.jdbc.Driver");
    dataSource.setUrl("jdbc:mysql://localhost:3306/mydb");
    dataSource.setUsername("root");
    dataSource.setPassword("password");
    context.setAttribute("dataSource", dataSource);
}
场景 2：加载配置文件
java 复制代码 
@Override
public void contextInitialized(ServletContextEvent event) {
    ServletContext context = event.getServletContext();
    // 读取 web.xml 中的配置参数
    String configPath = context.getInitParameter("configPath");
    try (InputStream inputStream = context.getResourceAsStream(configPath)) {
        Properties props = new Properties();
        props.load(inputStream);
        context.setAttribute("appConfig", props);
    } catch (IOException e) {
        e.printStackTrace();
    }
}
场景 3：保存数据到文件

在应用关闭时，将内存中的数据持久化：

java 复制代码 
@Override
public void contextDestroyed(ServletContextEvent event) {
    ServletContext context = event.getServletContext();
    // 获取数据并保存到文件
    Object data = context.getAttribute("appData");
    try (FileWriter writer = new FileWriter("data.txt")) {
        writer.write(data.toString());
    } catch (IOException e) {
        e.printStackTrace();
    }
}

4. 生命周期说明

  • 执行顺序 ：
    • contextInitialized 在 Filter 和 Servlet 初始化之前 调用。
    • contextDestroyed 在 Filter 和 Servlet 销毁之后 调用。
  • 触发条件 ：
    • 启动：当 Web 应用首次部署或重新加载时。
    • 关闭：当 Web 应用被卸载或服务器停止时。

5. 注意事项

  1. 资源管理 ：
    • 确保在 contextDestroyed 中正确释放资源（如关闭数据库连接、线程池等）。
    • 避免在监听器中执行耗时操作，以免影响应用启动/关闭速度。
  2. 线程安全 ：
    • 监听器的方法在 单线程 中执行，无需额外线程安全处理。
  3. 兼容性 ：
    • 使用注解 @WebListener 需要 Java EE 6+ 或 Servlet 3.0+ 容器（如 Tomcat 7+）。

6. 完整示例

以下是一个完整的监听器示例，结合了初始化配置和清理资源：

java 复制代码 
import javax.servlet.*;
import javax.servlet.annotation.WebListener;
import java.io.IOException;
import java.io.FileWriter;
import java.util.Properties;

@WebListener
public class MyContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent event) {
        ServletContext context = event.getServletContext();
        // 加载配置文件
        String configPath = "/WEB-INF/config.properties";
        try (InputStream inputStream = context.getResourceAsStream(configPath)) {
            Properties props = new Properties();
            props.load(inputStream);
            context.setAttribute("appConfig", props);
            System.out.println("配置文件加载完成：" + props);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        ServletContext context = event.getServletContext();
        // 保存数据到文件
        Properties props = (Properties) context.getAttribute("appConfig");
        try (FileWriter writer = new FileWriter("backup.properties")) {
            props.store(writer, "Backup on shutdown");
            System.out.println("数据已备份！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

总结

ServletContextListener 是管理 Web 应用全局生命周期的利器，适用于初始化和清理操作。通过合理使用，可以确保资源高效利用并避免内存泄漏。根据实际需求，可以选择在 web.xml 或通过注解进行配置，灵活应对不同场景。

4️⃣ 参考 4

ServletContextListener 是 Java Servlet API 中的一个接口，它属于 Servlet 监听器的一种。其作用是对 ServletContext 的生命周期进行监听，当 ServletContext 对象被创建（也就是 Web 应用启动时）或者被销毁（即 Web 应用关闭时），会触发相应的事件，进而执行特定的操作。

用法步骤

  1. 创建一个类实现 ServletContextListener 接口 ：需要实现 contextInitialized 和 contextDestroyed 这两个方法。
  2. 在 contextInitialized 方法中编写 Web 应用启动时要执行的代码。
  3. 在 contextDestroyed 方法中编写 Web 应用关闭时要执行的代码。
  4. 配置监听器 ：可以通过 web.xml 文件或者使用注解的方式进行配置。

示例代码

以下是一个使用 ServletContextListener 的示例：

java 复制代码 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

// 使用 @WebListener 注解配置监听器
@WebListener
public class MyServletContextListener implements ServletContextListener {

    // 当 ServletContext 被创建时调用
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Web 应用启动，初始化操作开始");
        // 可以在这里进行一些初始化操作，比如数据库连接池的初始化
    }

    // 当 ServletContext 被销毁时调用
    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("Web 应用关闭，清理操作开始");
        // 可以在这里进行一些清理操作，比如关闭数据库连接池
    }
}

代码解释

  • @WebListener 注解 ：该注解用于将 MyServletContextListener 类注册为一个监听器。
  • contextInitialized 方法 ：当 Web 应用启动，ServletContext 对象创建时，此方法会被调用，可在此方法中执行初始化操作。
  • contextDestroyed 方法 ：当 Web 应用关闭，ServletContext 对象销毁时，此方法会被调用，可在此方法中执行清理操作。

使用 web.xml 配置监听器

若不使用注解，也可以通过 web.xml 文件来配置监听器，示例如下：

xml 复制代码 
<listener>
    <listener-class>com.example.MyServletContextListener</listener-class>
</listener>

要把 com.example.MyServletContextListener 替换成你实际的监听器类的全限定名。

5️⃣ 参考 5

ServletContextListener 是 Java Web 开发中用于监听 ServletContext 生命周期的接口，它可以帮助开发者在 Web 应用程序启动和销毁时执行特定的逻辑。以下是 ServletContextListener 的具体用法：

1. 接口方法

ServletContextListener 接口定义了两个方法：

  • contextInitialized(ServletContextEvent sce)：当 Servlet 容器启动 Web 应用时调用此方法。在该方法执行完毕后，容器会初始化 Filter 和需要在启动时初始化的 Servlet。
  • contextDestroyed(ServletContextEvent sce)：当 Servlet 容器终止 Web 应用时调用此方法。在该方法执行之前，容器会先销毁所有的 Servlet 和 Filter。

2. 实现步骤

（1）创建监听器类

创建一个类并实现 ServletContextListener 接口，重写上述两个方法。例如：

java 复制代码 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class MyServletContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Web 应用程序启动");
        // 在这里执行初始化逻辑，例如加载数据库配置、初始化缓存等
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("Web 应用程序销毁");
        // 在这里执行清理逻辑，例如关闭数据库连接、保存缓存数据等
    }
}
（2）注册监听器

将监听器注册到 Web 应用程序中，可以通过以下两种方式：

  • 在 web.xml 中配置 ：

    xml 复制代码 
    <listener>
    <listener-class>com.example.MyServletContextListener</listener-class>
</listener>

  • 使用 @WebListener 注解 （Servlet 3.0 及以上版本支持）：

    java 复制代码 
    import javax.servlet.annotation.WebListener;

@WebListener
public class MyServletContextListener implements ServletContextListener {
    // 方法实现与上面相同
}

3. 示例应用

（1）加载数据库数据到内存

在 Web 应用启动时，从数据库加载数据并将其存储到 ServletContext 中，供其他 Servlet 使用：

java 复制代码 
import java.sql.*;
import java.util.HashMap;
import java.util.Map;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class DataLoadListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();
        Map<Integer, String> data = new HashMap<>();
        try {
            Connection conn = DriverManager.getConnection("jdbc:mysql://localhost:3306/mydb", "user", "password");
            Statement stmt = conn.createStatement();
            ResultSet rs = stmt.executeQuery("SELECT id, name FROM mytable");
            while (rs.next()) {
                data.put(rs.getInt("id"), rs.getString("name"));
            }
            context.setAttribute("myData", data);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 清理资源
    }
}
（2）统计页面访问次数

创建一个计数器，统计 Web 应用启动后页面被访问的次数，并在应用销毁时将计数器值保存到文件：

java 复制代码 
import java.io.*;
import javax.servlet.ServletContext;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;

public class VisitCounterListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();
        int count = 0;
        try {
            BufferedReader reader = new BufferedReader(new FileReader("count.txt"));
            count = Integer.parseInt(reader.readLine());
            reader.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
        context.setAttribute("visitCount", count);
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        ServletContext context = sce.getServletContext();
        int count = (int) context.getAttribute("visitCount");
        try {
            PrintWriter writer = new PrintWriter("count.txt");
            writer.println(count);
            writer.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        }
    }
}

通过以上方式，ServletContextListener 可以在 Web 应用的生命周期中执行各种初始化和清理操作，从而提高应用程序的灵活性和可维护性。

6️⃣ 参考 6

ServletContextListener 是一个接口，用于监听 Servlet 上下文的生命周期事件。通过实现这个接口，可以在 Web 应用启动和关闭时执行特定的代码。

步骤：

  1. 创建一个类 ，实现 ServletContextListener 接口。
  2. 重写两个方法 ：
    • contextInitialized(ServletContextEvent sce)：在应用启动时调用。
    • contextDestroyed(ServletContextEvent sce)：在应用关闭时调用。
  3. 在 web.xml 文件中注册监听器 ，或者使用注解 @WebListener。

代码示例：

1. 创建监听器类
java 复制代码 
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class MyServletContextListener implements ServletContextListener {

    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("Web应用启动...");
        // 在这里执行初始化操作，例如加载配置文件、初始化数据库连接池等
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("Web应用关闭...");
        // 在这里执行清理操作，例如关闭数据库连接池等
    }
}
2. 使用 web.xml 注册监听器（可选）

如果你不使用注解，可以在 web.xml 文件中注册监听器：

xml 复制代码 
<listener>
    <listener-class>com.example.MyServletContextListener</listener-class>
</listener>

解释：

  • @WebListener 注解：这是 Servlet 3.0 及以上版本提供的注解，用于简化监听器的注册。
  • contextInitialized 方法：在 Web 应用启动时调用，可以在这里进行一些初始化操作。
  • contextDestroyed 方法：在 Web 应用关闭时调用，可以在这里进行一些清理操作。

通过这种方式，你可以更好地控制 Web 应用的生命周期，执行必要的初始化和清理任务。

7️⃣ 参考 7

ServletContextListener 使用方法及示例代码

一、核心作用

ServletContextListener 是 Java Web 应用的生命周期监听器，主要监听以下两个事件：

  1. 应用启动时 ：通过 contextInitialized() 初始化全局资源（如数据库连接池、配置文件加载）
  2. 应用关闭时 ：通过 contextDestroyed() 释放资源，避免内存泄漏
二、实现步骤

  1. 创建监听器类

    实现 javax.servlet.ServletContextListener 接口并重写方法：

    java 复制代码 
    import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener
public class AppInitListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        // 应用启动时执行
        String configPath = sce.getServletContext().getInitParameter("configPath");
        DatabasePool.init(configPath); // 初始化数据库连接池
        System.out.println("✅ 应用启动：资源加载完成");
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        // 应用关闭时执行
        DatabasePool.close();
        System.out.println("⏹️ 应用关闭：资源已释放");
    }
}

  2. 配置方式（二选一）

    • 注解配置 ：添加 @WebListener 注解（需 Servlet 3.0+）

    • XML 配置 ：在 web.xml 中添加：

      xml 复制代码 
      <listener>
    <listener-class>com.example.AppInitListener</listener-class>
</listener>
三、典型应用场景
场景 实现方式示例 作用
全局配置加载 读取 web.xml 的 <context-param> 集中管理数据库配置、API密钥等
定时任务启动 在 contextInitialized() 启动 Quartz 执行日志清理、数据同步任务
第三方服务初始化 初始化消息队列连接 确保服务可用性
缓存预热 加载高频访问数据到 Redis 提升应用启动后首次访问速度
四、注意事项

  1. 执行顺序问题
    监听器的初始化顺序由 web.xml 中 <listener> 声明顺序决定，注解方式无法控制顺序

  2. 异常处理
    若 contextInitialized() 抛出异常，Web 容器将无法启动

    java 复制代码 
    public void contextInitialized(ServletContextEvent sce) {
    try {
        // 初始化代码
    } catch (Exception e) {
        throw new RuntimeException("初始化失败: " + e.getMessage());
    }
}

  3. 多模块环境
    在 Spring 项目中可结合 ContextLoaderListener 使用，但要注意初始化顺序

8️⃣ 参考 8

ServletContextListener是Java Web应用中用于监听ServletContext对象生命周期的接口，主要用于在Web应用启动和关闭时执行全局初始化或资源释放操作。以下是其核心用法及实践要点：

一、核心方法及作用

  1. contextInitialized(ServletContextEvent sce)

    在Web应用启动时触发，早于Filter和Servlet的初始化 。适用于：

    • 初始化数据库连接池、线程池等全局资源

    • 加载Spring/IOC容器配置

    • 读取web.xml中的<context-param>参数并存入ServletContext属性

    示例代码片段：

    java 复制代码 
    public void contextInitialized(ServletContextEvent sce) {
    ServletContext context = sce.getServletContext();
    // 从数据库加载数据并存入全局属性
    Map<Integer, String> depts = loadFromDatabase();
    context.setAttribute("dept", depts);
}

  2. contextDestroyed(ServletContextEvent sce)

    在Web应用关闭时触发，晚于所有Servlet和Filter的销毁 。适用于：

    • 关闭数据库连接池

    • 停止后台定时任务线程

    示例：

    java 复制代码 
    public void contextDestroyed(ServletContextEvent sce) {
    // 释放资源
    DataSourcePool.close();
}

二、实现与配置步骤

  1. 创建监听器类

    实现ServletContextListener接口并重写上述两个方法。类可通过@WebListener注解（Servlet 3.0+）或web.xml配置：

    java 复制代码 
    @WebListener
public class MyListener implements ServletContextListener { ... }

  2. XML配置（非注解方式）

    在web.xml中添加：

    xml 复制代码 
    <listener>
    <listener-class>com.example.MyListener</listener-class>
</listener>

  3. 访问上下文参数

    通过ServletContextEvent获取ServletContext对象：

    java 复制代码 
    // 获取web.xml中的全局参数
String param = sce.getServletContext().getInitParameter("webParam");
// 设置全局属性供其他组件使用
sce.getServletContext().setAttribute("config", loadConfig());

三、典型应用场景

场景 实现方式 来源
数据预加载 启动时从数据库读取数据存入ServletContext属性，供全站共享
资源初始化 创建Spring容器、MyBatis连接池等需全局单例的对象
定时任务管理 在contextInitialized中启动定时线程，contextDestroyed中终止线程
统计在线人数 结合HttpSessionListener实现会话计数

四、注意事项

  1. 执行顺序
    contextInitialized在Web容器启动时最早执行，确保初始化完成后再处理请求。

  2. 异常处理

    若contextInitialized抛出异常，Web应用将无法启动，需确保代码健壮性。

  3. 配置验证

    若监听器未生效，检查web.xml中类路径是否正确，或确认是否使用了重复的注解配置。

  4. 服务器关闭
    contextDestroyed可能因非正常关闭（如强制终止Tomcat）未触发，需通过日志监控确认。

通过合理使用ServletContextListener，开发者能实现Web应用级别的资源生命周期管理，提升系统稳定性和可维护性。具体实现可参考示例代码及配置文档。

9️⃣ 参考 9

ServletContextListener 是 Java Web 开发中用于监听 ServletContext（即应用上下文）生命周期的接口。它允许你在 Web 应用启动和关闭时执行自定义逻辑（如初始化资源、清理资源等）。以下是其核心用法：

核心方法

  1. contextInitialized(ServletContextEvent sce)

    • 在 Web 应用启动时触发（如服务器启动或应用部署时）。
    • 常用于初始化全局资源（如数据库连接池、缓存等）。

  2. contextDestroyed(ServletContextEvent sce)

    • 在 Web 应用关闭时触发（如服务器关闭或应用卸载时）。
    • 常用于释放资源或执行清理操作。

使用步骤

  1. 实现接口

    创建一个类实现 ServletContextListener 接口，并重写两个方法：

    java 复制代码 
    import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import javax.servlet.annotation.WebListener;

@WebListener // 使用注解注册监听器（Servlet 3.0+）
public class MyContextListener implements ServletContextListener {
    @Override
    public void contextInitialized(ServletContextEvent sce) {
        System.out.println("应用已启动！");
        // 初始化逻辑（如加载配置、连接数据库）
    }

    @Override
    public void contextDestroyed(ServletContextEvent sce) {
        System.out.println("应用已关闭！");
        // 清理逻辑（如关闭数据库连接）
    }
}

  2. 配置监听器

    • 方式 1：通过 @WebListener 注解（推荐，无需额外配置）。

    • 方式 2：在 web.xml 中声明 ：

      xml 复制代码 
      <listener>
    <listener-class>com.example.MyContextListener</listener-class>
</listener>

典型应用场景

  • 启动时初始化 ：
    如加载全局配置文件、初始化日志系统、预加载数据到缓存等。
  • 关闭时清理 ：
    如关闭数据库连接池、释放线程池资源、保存运行时数据等。

注意事项

  • 若需访问 ServletContext，可通过 sce.getServletContext() 获取。
  • 在分布式集群或热部署场景中，需确保资源初始化和清理的线程安全。

通过这种方式，你可以优雅地管理 Web 应用的生命周期行为。

🔟 参考 10

ServletContextListener是用于监听ServletContext对象生命周期的接口，主要用于在Web应用启动和关闭时执行一些特定的操作。以下是其用法概述：

  1. 定义接口方法：

    • contextInitialized(ServletContextEvent sce): 当Servlet容器启动Web应用时调用此方法。在调用完该方法之后，容器再对Filter初始化，并且对那些在Web应用启动时就需要被初始化的Servlet进行初始化[^1^][^2^]。
    • contextDestroyed(ServletContextEvent sce): 当Servlet容器终止Web应用时调用此方法。在调用该方法之前，容器会先销毁所有的Servlet和Filter过滤器[^1^][^2^]。

  2. 实现接口：

    • 创建一个类实现ServletContextListener接口，并重写上述两个方法。例如，可以创建一个名为MyServletContextListener的类，并在其中实现contextInitialized和contextDestroyed方法[^4^][^5^]。

  3. 注册监听器：

    • 在web.xml文件中配置<listener>元素来注册监听器。指定监听器的类名，以便Servlet容器在启动或关闭Web应用时能够调用相应的方法[^2^][^4^]。
    • 在Spring Boot等现代Java框架中，可以通过使用注解（如@WebListener）来简化配置，无需在web.xml中进行配置[^3^]。

  4. 应用场景举例：

    • 加载资源：在Web应用启动时，从数据库或其他数据源加载数据，并将其存储在ServletContext中，以便在整个Web应用中共享[^1^][^2^]。
    • 统计信息：维护Web应用级别的统计信息，如请求计数器、性能指标等。在Web应用启动时初始化这些统计信息，并在每次请求时更新它们[^5^]。
    • 缓存预热：在Web应用启动时，预先加载常用的数据到缓存中，以提高系统的响应速度。
    • 清理资源：在Web应用关闭时，执行一些清理工作，如关闭数据库连接、释放文件句柄等[^5^]。

综上所述，ServletContextListener为开发者提供了一个强大的机制来管理Web应用的生命周期事件，通过合理利用这一接口，可以有效地提升Web应用的性能和可维护性。

相关推荐
it-搬运工12 分钟前
远程调用负载均衡LoadBalancer
java·微服务·负载均衡
努力努力再努力wz18 分钟前
【Linux实践系列】：进程间通信：万字详解共享内存实现通信
java·linux·c语言·开发语言·c++
-曾牛30 分钟前
Azure OpenAI 聊天功能全解析：Java 开发者指南
java·开发语言·人工智能·spring·flask·azure·大模型应用
zhojiew1 小时前
service mesh的定制化与性能考量
java·云原生·service_mesh
cdut_suye1 小时前
【Linux系统】从零开始构建简易 Shell：从输入处理到命令执行的深度剖析
java·linux·服务器·数据结构·c++·人工智能·python
-qOVOp-1 小时前
zst-2001 历年真题 设计模式
java·算法·设计模式
张狂年少2 小时前
【十五】Mybatis动态SQL实现原理
java·sql·mybatis
元亓亓亓2 小时前
Java后端开发day46--多线程（二）
java·开发语言
七七小报2 小时前
uniapp-商城-51-后台 商家信息（logo处理）
java·服务器·windows·uni-app
神奇小永哥2 小时前
浅谈装饰模式
java
热门推荐
01KGG转MP3工具|非KGM文件|解密音频02从零安装 LLaMA-Factory 微调 Qwen 大模型成功及所有的坑03YOLOv8入门 | 重要性能衡量指标、训练结果评价及分析及影响mAP的因素【发论文关注的指标】04数据分析实战 | K-means算法——蛋白质消费特征分析05【SpeedAI科研小助手】2分钟极速解决知网维普重复率、AIGC率过高，一键全文降！文件格式不变，公式都保留的！06西电B测-计算机网络综合实验(含验收问题)07【解决】Android Gradle Sync 报错 Could not read workspace metadata08苍穹外卖面试总结09DeepSeek各版本说明与优缺点分析10YOLOv5改进 | 添加CA注意力机制 + 增加预测层 + 更换损失函数之GIoU