如何在 Tomcat 中实现动态修改配置文件

import org.apache.catalina.connector.Connector;
import org.apache.coyote.http11.Http11NioProtocol;
import org.springframework.boot.web.embedded.tomcat.TomcatWebServer;
import org.springframework.boot.web.servlet.context.ServletWebServerApplicationContext;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.web.bind.annotation.PostMapping;
import org.springframework.web.bind.annotation.RequestParam;
import org.springframework.web.bind.annotation.RestController;

@RestController
public class TomcatConfigController {

    @Autowired
    private ServletWebServerApplicationContext applicationContext;

    /**
     * 动态修改 Tomcat 线程池/超时时间（无需重启，立即生效）
     */
    @PostMapping("/tomcat/updateConfig")
    public String updateTomcatConfig(
            @RequestParam(required = false) Integer maxThreads,
            @RequestParam(required = false) Integer connectionTimeout) {
        try {
            // 1. 获取内嵌 Tomcat 核心实例
            TomcatWebServer tomcatServer = (TomcatWebServer) applicationContext.getWebServer();
            Connector connector = tomcatServer.getTomcat().getService().getConnectors()[0];
            Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();

            // 2. 动态修改配置（直接操作内存对象）
            if (maxThreads != null) {
                protocol.setMaxThreads(maxThreads); // 最大线程数，立即生效
            }
            if (connectionTimeout != null) {
                protocol.setConnectionTimeout(connectionTimeout); // 连接超时，立即生效
            }

            return "Tomcat 配置修改成功！当前 maxThreads：" + protocol.getMaxThreads();
        } catch (Exception e) {
            return "配置修改失败：" + e.getMessage();
        }
    }
}

# 修改最大线程数为 1000
curl -X POST "http://localhost:8080/tomcat/updateConfig?maxThreads=1000"
# 返回：Tomcat 配置修改成功！当前 maxThreads：1000

/**
 * 动态修改会话超时时间（单位：分钟）
 */
@PostMapping("/tomcat/updateSessionTimeout")
public String updateSessionTimeout(@RequestParam int timeout) {
    TomcatWebServer tomcatServer = (TomcatWebServer) applicationContext.getWebServer();
    // 获取应用上下文（对应 context.xml）
    org.apache.catalina.Context context = (org.apache.catalina.Context) tomcatServer.getTomcat().getHost().findChildren()[0];
    context.setSessionTimeout(timeout); // 动态修改会话超时，新会话立即生效
    return "会话超时时间已修改为 " + timeout + " 分钟";
}

import org.springframework.beans.factory.annotation.Value;
import org.springframework.cloud.context.config.annotation.RefreshScope;
import org.springframework.web.bind.annotation.GetMapping;
import org.springframework.web.bind.annotation.RestController;

/**
 * 自定义 Tomcat 配置动态刷新（需引入 Spring Cloud Config/Nacos）
 */
@RestController
@RefreshScope // 关键：开启配置刷新
public class CustomConfigController {

    // 从配置中心拉取的自定义配置
    @Value("${tomcat.custom.maxConnections:10000}")
    private int maxConnections;

    /**
     * 修改 Nacos 中的 tomcat.custom.maxConnections 后，访问该接口可看到最新值
     */
    @GetMapping("/getCustomConfig")
    public String getCustomConfig() {
        // 可将该值同步到 Tomcat 连接器配置
        updateTomcatMaxConnections(maxConnections);
        return "当前自定义 maxConnections：" + maxConnections;
    }

    // 同步自定义配置到 Tomcat 内存实例
    private void updateTomcatMaxConnections(int maxConn) {
        TomcatWebServer tomcatServer = (TomcatWebServer) applicationContext.getWebServer();
        Connector connector = tomcatServer.getTomcat().getService().getConnectors()[0];
        Http11NioProtocol protocol = (Http11NioProtocol) connector.getProtocolHandler();
        protocol.setMaxConnections(maxConn);
    }
}

<!-- 示例：修改线程池配置 -->
<Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"
           maxThreads="1000" minSpareThreads="100" connectionTimeout="20000"/>

# 1. 关闭老进程（处理完现有连接后退出）
CATALINA_HOME/bin/shutdown.sh

# 2. 启动新进程（新连接用新配置）
CATALINA_HOME/bin/startup.sh

# 进阶：使用 Tomcat 自带的平滑重启脚本（需配置 server.xml 中的 shutdown 端口）
CATALINA_HOME/bin/catalina.sh stop -force
CATALINA_HOME/bin/catalina.sh start

<Context reloadable="true"> <!-- 关键：开启上下文自动重载 -->
    <!-- 其他配置 -->
</Context>

<Context>
    <!-- 引入自定义配置文件 -->
    <Environment name="customConfig" type="java.lang.String" 
                 value="conf/custom.properties" override="true"/>
</Context>

import org.apache.catalina.Context;
import org.apache.catalina.startup.ContextConfig;
import javax.servlet.ServletContextEvent;
import javax.servlet.ServletContextListener;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;

public class CustomConfigListener implements ServletContextListener {

    private Properties config = new Properties();
    private File configFile;
    private long lastModified;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        // 初始化加载配置
        String configPath = event.getServletContext().getInitParameter("customConfig");
        configFile = new File(configPath);
        loadConfig();
        // 启动定时任务，检测文件变更
        new Thread(() -> {
            while (true) {
                if (configFile.lastModified() > lastModified) {
                    loadConfig(); // 配置变更，重新加载
                }
                try {
                    Thread.sleep(5000); // 每 5 秒检测一次
                } catch (InterruptedException e) {
                    e.printStackTrace();
                }
            }
        }).start();
    }

    private void loadConfig() {
        try (FileInputStream fis = new FileInputStream(configFile)) {
            config.load(fis);
            lastModified = configFile.lastModified();
            // 将配置同步到 Tomcat 连接器
            updateTomcatConfig(config);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    // 同步自定义配置到 Tomcat 连接器
    private void updateTomcatConfig(Properties config) {
        int maxThreads = Integer.parseInt(config.getProperty("tomcat.maxThreads", "200"));
        // 获取 Tomcat Connector 并修改（独立 Tomcat 需通过 MBean 获取）
        // 省略 MBean 获取逻辑，核心是调用 setMaxThreads 等方法
    }
}