如何在独立Tomcat中实现配置的热部署

<Server port="8005" shutdown="SHUTDOWN"> <!-- 保留 shutdown 端口 -->
  <Service name="Catalina">
    <Connector port="8080" protocol="org.apache.coyote.http11.Http11NioProtocol"
               maxThreads="500" connectionTimeout="30000"/> <!-- 待修改的配置 -->
  </Service>
</Server>

# 1. 先验证配置语法（避免重启失败）
/opt/tomcat/bin/configtest.sh

# 2. 优雅关闭老进程（处理完现有连接后退出）
/opt/tomcat/bin/shutdown.sh

# 3. 启动新进程（加载新配置，处理新请求）
/opt/tomcat/bin/startup.sh

# 进阶：一键平滑重启脚本（生产推荐）
#!/bin/bash
TOMCAT_HOME=/opt/tomcat
# 验证配置
$TOMCAT_HOME/bin/configtest.sh || exit 1
# 优雅关闭
$TOMCAT_HOME/bin/catalina.sh stop -force
# 启动新进程
$TOMCAT_HOME/bin/catalina.sh start
echo "Tomcat 平滑重启完成，新配置已生效"

<Context 
  reloadable="true"          <!-- 核心：开启自动重载 -->
  checkInterval="30">        <!-- 检测配置变更的间隔（秒），默认15秒 -->
  <!-- 应用配置：数据源、会话超时等 -->
  <Resource name="jdbc/MyDB"
            auth="Container"
            type="javax.sql.DataSource"
            url="jdbc:mysql://127.0.0.1:3306/test"/>
  <Manager sessionTimeout="30"/>
</Context>

<user username="admin" password="123456" roles="manager-gui,manager-script"/>

# /opt/tomcat/config/business.properties（与应用解耦）
blocked.ips=192.168.1.100,10.0.0.5
api.limit.rate=100r/s
api.test.enable=true

import javax.servlet.ServletContext;
import javax.servlet.ServletContextListener;
import java.io.File;
import java.io.FileInputStream;
import java.util.Properties;
import java.util.concurrent.Executors;
import java.util.concurrent.ScheduledExecutorService;
import java.util.concurrent.TimeUnit;

/**
 * 业务配置热加载监听器：定时检测文件变更，刷新内存缓存
 */
public class BusinessConfigListener implements ServletContextListener {
    private ServletContext servletContext;
    private File configFile;
    private long lastModified; // 记录文件最后修改时间
    private ScheduledExecutorService scheduler = Executors.newSingleThreadScheduledExecutor();

    @Override
    public void contextInitialized(ServletContextEvent event) {
        this.servletContext = event.getServletContext();
        // 从 Tomcat 全局变量获取配置文件路径（解耦）
        String configPath = System.getProperty("business.config.path", "/opt/tomcat/config/business.properties");
        this.configFile = new File(configPath);

        // 1. 初始化加载配置到缓存
        refreshConfig();

        // 2. 定时检测文件变更（每5秒检测一次）
        scheduler.scheduleAtFixedRate(this::checkConfigChange, 0, 5, TimeUnit.SECONDS);
    }

    // 检测文件是否变更，变更则刷新缓存
    private void checkConfigChange() {
        if (configFile.lastModified() > lastModified) {
            refreshConfig();
            servletContext.log("业务配置文件已变更，缓存已刷新！");
        }
    }

    // 刷新配置到 ServletContext 缓存（所有应用可访问）
    private void refreshConfig() {
        Properties props = new Properties();
        try (FileInputStream fis = new FileInputStream(configFile)) {
            props.load(fis);
            // 将配置存入缓存（覆盖旧值）
            servletContext.setAttribute("blocked.ips", props.getProperty("blocked.ips"));
            servletContext.setAttribute("api.limit.rate", props.getProperty("api.limit.rate"));
            servletContext.setAttribute("api.test.enable", props.getProperty("api.test.enable"));
            lastModified = configFile.lastModified();
        } catch (Exception e) {
            servletContext.log("加载业务配置失败：" + e.getMessage());
        }
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        scheduler.shutdown(); // 销毁定时线程池
    }
}

<web-app>
  <listener>
    <listener-class>com.example.BusinessConfigListener</listener-class>
  </listener>
</web-app>

// 从缓存读取配置，修改外部文件后5秒内生效
String blockedIps = (String) getServletContext().getAttribute("blocked.ips");
// 业务逻辑：IP封禁判断
if (blockedIps.contains(clientIp)) {
    response.setStatus(403);
    return;
}

cp nacos-client-2.3.0.jar /opt/tomcat/lib/

import com.alibaba.nacos.api.NacosFactory;
import com.alibaba.nacos.api.config.ConfigService;
import com.alibaba.nacos.api.config.listener.Listener;
import com.alibaba.nacos.api.exception.NacosException;

import javax.servlet.ServletContextListener;
import java.util.Properties;
import java.util.concurrent.Executor;

/**
 * Nacos 配置热加载监听器：配置中心变更实时推送
 */
public class NacosConfigListener implements ServletContextListener {
    private ServletContext servletContext;
    private ConfigService configService;

    @Override
    public void contextInitialized(ServletContextEvent event) {
        this.servletContext = event.getServletContext();
        try {
            // 1. 初始化 Nacos 客户端
            Properties props = new Properties();
            props.put("serverAddr", "192.168.1.100:8848"); // 配置中心地址
            configService = NacosFactory.createConfigService(props);

            // 2. 加载初始配置
            String config = configService.getConfig("business-config", "DEFAULT_GROUP", 5000);
            updateConfigToCache(config);

            // 3. 监听配置变更（实时推送）
            configService.addListener("business-config", "DEFAULT_GROUP", new Listener() {
                @Override
                public void receiveConfigInfo(String configInfo) {
                    // 配置变更，立即刷新缓存
                    updateConfigToCache(configInfo);
                    servletContext.log("Nacos 业务配置已更新，缓存实时生效！");
                }

                @Override
                public Executor getExecutor() {
                    return null;
                }
            });
        } catch (NacosException e) {
            servletContext.log("Nacos 配置加载失败：" + e.getMessage());
        }
    }

    // 将配置更新到内存缓存
    private void updateConfigToCache(String configContent) {
        String[] lines = configContent.split("\n");
        for (String line : lines) {
            if (line.contains("=")) {
                String[] kv = line.split("=", 2);
                servletContext.setAttribute(kv[0].trim(), kv[1].trim());
            }
        }
    }

    @Override
    public void contextDestroyed(ServletContextEvent event) {
        if (configService != null) {
            try {
                configService.shutDown();
            } catch (NacosException e) {
                e.printStackTrace();
            }
        }
    }
}