优雅地关闭嵌入式 Tomcat (不使用 Spring)-java教程-PHP中文网

优雅地关闭嵌入式 Tomcat (不使用 Spring)

霞舞

发布： 2025-10-23 14:08:01

原创

802人浏览过

优雅地关闭嵌入式 tomcat (不使用 spring)

本文介绍如何在不使用 Spring 框架的情况下，优雅地关闭嵌入式 Tomcat 服务器。通过手动管理 Tomcat 生命周期，确保资源得到正确释放，避免潜在的内存泄漏或其他问题。核心在于正确地销毁连接器、上下文和Tomcat实例，并处理Servlet的销毁事件。

在使用嵌入式 Tomcat 时，优雅地关闭服务器至关重要，尤其是在生产环境中。这可以防止数据丢失、连接中断和其他潜在问题。以下步骤演示了如何实现这一目标，并解决了ServletDestroy事件未被调用的问题。

1. 创建嵌入式 Tomcat 实例

首先，需要创建一个 Tomcat 实例并配置其基本设置，例如端口号和上下文路径。

import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.connector.Connector;
import org.apache.catalina.startup.Tomcat;

public class EmbeddedTomcat {

    private Tomcat tomcat;
    private String hostName = "localhost";
    private int port = 8080;
    private String contextPath = "/";
    private String appBase = "."; // webapp 目录

    public EmbeddedTomcat() {
        tomcat = new Tomcat();
        tomcat.setHostname(hostName);
        tomcat.setPort(port);
        tomcat.setBaseDir(appBase);
    }

    public void start() throws LifecycleException {
        Context context = tomcat.addContext(contextPath, appBase);

        // 添加 Servlet (例如，使用注解)
        // Tomcat.addServlet(contextPath, "myServlet", new MyServlet());
        // context.addServletMappingDecoded("/myServlet", "myServlet");

        tomcat.start();
    }

    public void stop() throws LifecycleException, InterruptedException {
        // 销毁连接器
        for (Connector connector : tomcat.getService().findConnectors()) {
            connector.destroy();
        }

        // 等待一段时间 (可选，但推荐)
        Thread.sleep(5000);

        // 销毁上下文
        tomcat.getHost().removeChild(tomcat.getContext());
        tomcat.removeContext(contextPath);
        // 等待一段时间 (可选，但推荐)
        Thread.sleep(5000);

        // 停止 Tomcat
        tomcat.stop();

        // 等待一段时间 (可选，但推荐)
        Thread.sleep(5000);

        // 销毁 Tomcat
        tomcat.destroy();
    }

    public static void main(String[] args) throws LifecycleException, InterruptedException {
        EmbeddedTomcat embeddedTomcat = new EmbeddedTomcat();
        embeddedTomcat.start();

        // 在适当的时候停止 Tomcat
        // 例如，通过一个 shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                embeddedTomcat.stop();
            } catch (LifecycleException | InterruptedException e) {
                e.printStackTrace();
            }
        }));

        // 保持程序运行，直到手动停止
        Thread.currentThread().join();
    }
}

登录后复制

2. 优雅关闭的步骤

以下是优雅关闭嵌入式 Tomcat 的关键步骤：

销毁连接器 (Connectors): 这是第一步，关闭所有接受新连接的入口点。
销毁上下文 (Context): 卸载 Web 应用程序，触发 ServletContextListener 的 contextDestroyed 方法。

SpeakingPass-打造你的专属雅思口语语料
使用chatGPT帮你快速备考雅思口语，提升分数

25

查看详情
停止 Tomcat (Tomcat): 停止 Tomcat 引擎。
销毁 Tomcat (Tomcat): 释放所有 Tomcat 实例占用的资源。

3. 解决 ServletDestroy 未被调用的问题

问题描述中提到 TS_TomcatListener.contextDestroyed 方法未被调用。这通常与 Servlet 的生命周期管理有关。一种解决方法是在创建 Servlet 实例时，手动将 Tomcat 实例传递给 Servlet，并在 Servlet 初始化时将其与 Context 关联。

import org.apache.catalina.Context;
import org.apache.catalina.LifecycleException;
import org.apache.catalina.startup.Tomcat;

import javax.servlet.Servlet;
import javax.servlet.ServletException;
import javax.servlet.http.HttpServlet;
import javax.servlet.http.HttpServletRequest;
import javax.servlet.http.HttpServletResponse;
import java.io.IOException;

public class EmbeddedTomcatWithServlet {

    private Tomcat tomcat;
    private String hostName = "localhost";
    private int port = 8080;
    private String contextPath = "/";
    private String appBase = "."; // webapp 目录

    public EmbeddedTomcatWithServlet() {
        tomcat = new Tomcat();
        tomcat.setHostname(hostName);
        tomcat.setPort(port);
        tomcat.setBaseDir(appBase);
    }

    public void start() throws LifecycleException, ServletException {
        Context context = tomcat.addContext(contextPath, appBase);

        // 创建 Servlet 实例，并将 Tomcat 实例传递给它
        MyServlet myServlet = new MyServlet(tomcat);

        // 手动将 Servlet 映射到 Context
        Tomcat.addServlet(context, "myServlet", myServlet);
        context.addServletMappingDecoded("/myServlet", "myServlet");

        tomcat.start();
    }

    public void stop() throws LifecycleException, InterruptedException {
        // 销毁连接器
        for (org.apache.catalina.connector.Connector connector : tomcat.getService().findConnectors()) {
            connector.destroy();
        }

        // 等待一段时间 (可选，但推荐)
        Thread.sleep(5000);

        // 销毁上下文
        tomcat.getHost().removeChild(tomcat.getContext());
        tomcat.removeContext(contextPath);

        // 等待一段时间 (可选，但推荐)
        Thread.sleep(5000);

        // 停止 Tomcat
        tomcat.stop();

        // 等待一段时间 (可选，但推荐)
        Thread.sleep(5000);

        // 销毁 Tomcat
        tomcat.destroy();
    }

    public static void main(String[] args) throws LifecycleException, ServletException, InterruptedException {
        EmbeddedTomcatWithServlet embeddedTomcat = new EmbeddedTomcatWithServlet();
        embeddedTomcat.start();

        // 在适当的时候停止 Tomcat
        // 例如，通过一个 shutdown hook
        Runtime.getRuntime().addShutdownHook(new Thread(() -> {
            try {
                embeddedTomcat.stop();
            } catch (LifecycleException | InterruptedException e) {
                e.printStackTrace();
            }
        }));

        // 保持程序运行，直到手动停止
        Thread.currentThread().join();
    }

    // 示例 Servlet
    public static class MyServlet extends HttpServlet {

        private Tomcat tomcat;

        public MyServlet(Tomcat tomcat) {
            this.tomcat = tomcat;
        }

        @Override
        public void init() throws ServletException {
            super.init();
            // 在初始化时进行一些操作，例如访问静态资源
            System.out.println("Servlet initialized");
        }

        @Override
        protected void doGet(HttpServletRequest req, HttpServletResponse resp) throws ServletException, IOException {
            resp.getWriter().println("Hello from MyServlet");
        }

        @Override
        public void destroy() {
            super.destroy();
            // 在销毁时进行一些清理操作
            System.out.println("Servlet destroyed");
        }
    }
}

登录后复制

4. 注意事项和总结

线程安全: 确保在关闭过程中，所有线程都已正确停止，避免数据竞争。
资源释放: 仔细检查所有资源（例如数据库连接、文件句柄）是否已正确释放。
异常处理: 在关闭过程中，妥善处理可能出现的异常，防止程序崩溃。
Shutdown Hook: 使用 Runtime.getRuntime().addShutdownHook() 可以确保在 JVM 关闭时执行关闭操作。

通过以上步骤，可以实现嵌入式 Tomcat 的优雅关闭，避免潜在的问题，并确保应用程序的稳定性和可靠性。记住，仔细的资源管理和适当的错误处理是关键。

以上就是优雅地关闭嵌入式 Tomcat (不使用 Spring)的详细内容，更多请关注php中文网其它相关文章！