如何在Tomcat启动时根据配置文件条件阻止特定Web应用部署？

Great question! When you need to prevent certain web applications from deploying during Tomcat startup using predefined config rules, there are a couple of robust, customizable approaches. Let’s walk through the most practical ones:

Approach 1: Custom Lifecycle Listener (Simplest for Most Cases) #

Tomcat uses lifecycle events to manage its components, and you can hook into these events to intercept and block app deployments before they complete.

Step 1: Implement the LifecycleListener #

Create a listener class that listens for the Host's startup event, loads your config rules, and removes any unwanted contexts before they deploy:

import org.apache.catalina.Lifecycle;
import org.apache.catalina.LifecycleEvent;
import org.apache.catalina.LifecycleListener;
import org.apache.catalina.Host;
import org.apache.catalina.Context;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.IOException;

public class BlockAppListener implements LifecycleListener {
    private Properties blockConfig = new Properties();

    @Override
    public void lifecycleEvent(LifecycleEvent event) {
        // Trigger when the Host is about to start
        if (Lifecycle.BEFORE_START_EVENT.equals(event.getType()) && event.getSource() instanceof Host) {
            Host host = (Host) event.getSource();
            
            // Load your block rules from a config file (adjust path as needed)
            try {
                String configPath = host.getServer().getCatalinaBase() + "/conf/block-apps.properties";
                blockConfig.load(new FileInputStream(configPath));
            } catch (IOException e) {
                System.err.println("Failed to load block app config: " + e.getMessage());
                return;
            }

            // Check each app context and block if configured
            for (String contextName : host.findChildren()) {
                Context context = (Context) host.findChild(contextName);
                String appName = context.getPath().isEmpty() ? "ROOT" : context.getPath().substring(1);
                
                if ("true".equals(blockConfig.getProperty("block." + appName))) {
                    host.removeChild(context);
                    System.out.println("Blocked deployment of application: " + appName);
                }
            }
        }
    }
}

Step 2: Configure the Listener in server.xml #

Add your listener to the <Host> section of conf/server.xml so Tomcat loads it during startup:

<Host name="localhost"  appBase="webapps"
      unpackWARs="true" autoDeploy="true">
    <!-- Register your custom listener -->
    <Listener className="com.yourpackage.BlockAppListener" />
    
    <!-- Existing Host config (Valves, etc.) -->
</Host>

Step 3: Create the Config File #

Make a block-apps.properties file in Tomcat's conf directory with rules like:

# Block "myapp" and "ROOT" apps
block.myapp=true
block.ROOT=true

Approach 2: Custom Host Component (Fine-Grained Control) #

If you need more control (like blocking apps before they’re even unpacked), extend Tomcat's StandardHost class to override deployment logic:

Step 1: Extend StandardHost #

import org.apache.catalina.core.StandardHost;
import org.apache.catalina.Context;
import java.util.Properties;
import java.io.FileInputStream;
import java.io.IOException;

public class BlockableHost extends StandardHost {
    private Properties blockConfig = new Properties();

    @Override
    public void deploy() {
        // Load config before starting deployment
        try {
            String configPath = getServer().getCatalinaBase() + "/conf/block-apps.properties";
            blockConfig.load(new FileInputStream(configPath));
        } catch (IOException e) {
            System.err.println("Failed to load block app config: " + e.getMessage());
        }
        super.deploy();
    }

    @Override
    public Context addChild(Context child) {
        String appName = child.getPath().isEmpty() ? "ROOT" : child.getPath().substring(1);
        
        // Reject the app if it's marked for blocking
        if ("true".equals(blockConfig.getProperty("block." + appName))) {
            System.out.println("Rejected deployment of application: " + appName);
            return null; // Returning null prevents the context from being added
        }
        return super.addChild(child);
    }
}

Step 2: Use the Custom Host in server.xml #

Replace the default <Host> tag with your custom implementation:

<Host className="com.yourpackage.BlockableHost" name="localhost"  appBase="webapps"
      unpackWARs="true" autoDeploy="true">
    <!-- Existing Host config -->
</Host>

Key Notes #

• Class Placement: Package your custom classes into a JAR file and place it in Tomcat's lib directory (so Tomcat's common classloader can find it).
• Dynamic Config: If you want to update rules without restarting Tomcat, add logic to reload the properties file periodically (e.g., using a scheduled thread) or expose an MBean to trigger manual reloads.
• Tomcat Version Compatibility: The examples above work for Tomcat 8+; for older versions, check the official docs for minor API differences.

内容的提问来源于stack exchange，提问作者senthalan