带有Servlet 3.0的嵌入式Tomcat-如何在扫描时跳过某些jar？

Question

Here is a simple method for an embedded Tomcat server that scans for Servlet 3.0 initializers:

public static void main(String[] args) throws ServletException, LifecycleException {
    Tomcat tomcat = new Tomcat();
    tomcat.setPort(8080);

    StandardContext ctx = (StandardContext) tomcat.addWebapp("/", new File("web").getAbsolutePath());

    //declare an alternate location for your "WEB-INF/classes" dir:     
    File additionWebInfClasses = new File("target/classes");
    VirtualDirContext resources = new VirtualDirContext();
    resources.setExtraResourcePaths("/WEB-INF/classes=" + additionWebInfClasses);
    ctx.setResources(resources);

    tomcat.start();
    System.out.println("Started");
    tomcat.getServer().await();
}

I know that the property tomcat.util.scan.DefaultJarScanner.jarsToSkip in catalina.properties allows you to limit which jars are scanned to speed deployment time. How would I incorporate this same idea into the embedded Tomcat code here?

BONUS: Is there a way to specify which jars to include instead of which jars to skip ?

Answer 1

While I don't have a specific way of loading individual catalina.properties properties, I found it convenient enough to just overload the JarScanner itself on the Tomcat container contexts like so:

Answer is in Groovy (sorry, I get lazy)

public static void main(String[] args) throws ServletException, LifecycleException {
    Tomcat tomcat = new TomcatWithFastJarScanner()
    tomcat.setPort(8080)

    StandardContext ctx = (StandardContext) tomcat.addWebapp("/", new File("web").getAbsolutePath())

    //declare an alternate location for your "WEB-INF/classes" dir:     
    VirtualDirContext resources = new VirtualDirContext()
    resources.setExtraResourcePaths("/WEB-INF/classes=" + new File("target/classes"))
    ctx.setResources(resources)

    tomcat.start()
    println "Started server on port 8080"
    tomcat.getServer().await()
}

private static class TomcatWithFastJarScanner extends Tomcat {
    @Override
    public void start() throws LifecycleException {
        getServer().findServices().each { service ->
            service.getContainer().findChildren().each { container ->
                container.findChildren().each { c ->
                    ((Context) c).setJarScanner(new FastJarScanner())
                }
            }
        }
        super.start()
    }
}


private static class FastJarScanner extends StandardJarScanner {
    def jarsToInclude = [ 'spring-web.*' ]

    @Override
    public void scan(ServletContext context, ClassLoader classloader,
            JarScannerCallback callback, Set<String> jarsToSkip) {
        jarsToSkip = new HashSet<String>();

        ((URLClassLoader) classloader.getParent()).getURLs().each {
            def jar = it.path.find(/[^\/]+\.jar$/)
            if(!jar) return
            for(String inclusionPattern : jarsToInclude) {
                if(jar.find(inclusionPattern))  
                    println "including jar: " + jar
                else jarsToSkip.add(jar)
            }
        }

        super.scan(context, classloader, callback, jarsToSkip);
    }
}

The basic idea is that we are looking at all the jars which the classloader can see, and excluding all of the jars that we don't want to include.

Tomcat embedded starts up real fast like this!

Answer 2

The following is speculative, only reading the specs. One could use a web-fragment, with its own META-INF/web.xml with metadata-complete=true signaling no annotation scanning.

Answer 3

You can extend Tomcat setting scanClassPath to false, something like - this is on top of what user jkschneider here has pointed out):

new Tomcat() {
    @Override
    public void start() throws LifecycleException {
        for (final org.apache.catalina.Service service : getServer().findServices()) {
            for (final Container container : service.getContainer().findChildren()) {
                for (final Container subContainer : container.findChildren()) {
                    final StandardJarScanner jarScanner = (StandardJarScanner) ((Context) subContainer).getJarScanner();
                    jarScanner.setScanClassPath(false);
                }
            }
        }
        super.start();
    }
};

btw better approach may be as follows:

final Tomcat tomcat = new Tomcat();
final StandardHost tomcatHost = (StandardHost) tomcat.getHost();
        tomcatHost.setContextClass("com.fullclassname....FastStandardContext");

where FastStandardContext is

public class FastStandardContext extends StandardContext {
    public FastStandardContext() {
        ((StandardJarScanner) getJarScanner()).setScanClassPath(false);
    }
}

This will cover cases where new webapps are added after tomcat is running.