import org.apache.tomcat.JarScanType; //导入依赖的package包/类
@Override
public void scan(final JarScanType scanType, final ServletContext context, final JarScannerCallback callback) {
    super.scan(scanType, context, callback);
    if (!embeddedSurefireScanning(scanType, context, callback) && isScanClassPath() && !URLClassLoader.class.isInstance(getSystemClassLoader())
            && !Boolean.getBoolean("tomee.classpath.scanning.disabled")) {
        // TODO: check on tomcat upgrade if it is fixed
        final String cp = System.getProperty("java.class.path");
        final Collection<URL> urls = new HashSet<>();
        for (final String jar : cp.split(File.pathSeparator)) {
            try {
                urls.add(new File(jar).toURI().toURL());
            } catch (MalformedURLException e) {
                // no-op
            }
        }
        doScan(scanType, callback, new LinkedList<>(urls));
    }
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
private void doScan(final JarScanType scanType, final JarScannerCallback callback, final Deque<URL> urls) {
    Method process = null;
    final boolean scanAllDirectories = isScanAllDirectories();
    for (final URL url : urls) {
        final File cpe = URLs.toFile(url);
        if ((cpe.getName().endsWith(".jar") ||
                scanType == JarScanType.PLUGGABILITY ||
                scanAllDirectories) &&
                getJarScanFilter().check(scanType, cpe.getName())) {
            try {
                if (process == null) {
                    process = StandardJarScanner.class.getDeclaredMethod("process",
                            JarScanType.class, JarScannerCallback.class, URL.class, String.class, boolean.class, Deque.class);
                    if (!process.isAccessible()) {
                        process.setAccessible(true);
                    }
                }
                process.invoke(this, scanType, callback, url, null, true, urls);
            } catch (final Exception ioe) {
                // no-op
            }
        }
    }
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
/**
 * Scan for TLDs in JARs in /WEB-INF/lib.
 */
public void scanJars() {
    JarScanner scanner = JarScannerFactory.getJarScanner(context);
    TldScannerCallback callback = new TldScannerCallback();
    scanner.scan(JarScanType.TLD, context, callback);
    if (callback.scanFoundNoTLDs()) {
        log.info(Localizer.getMessage("jsp.tldCache.noTldSummary"));
    }
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
private Map<String, WebXml> scanForFragments(WebXmlParser webXmlParser) throws JasperException {
    StandardJarScanner scanner = new StandardJarScanner();
    // TODO - enabling this means initializing the classloader first in JspC
    scanner.setScanClassPath(false);
    // TODO - configure filter rules from Ant rather then system properties
    scanner.setJarScanFilter(new StandardJarScanFilter());

    FragmentJarScannerCallback callback =
            new FragmentJarScannerCallback(webXmlParser, false, true);
    scanner.scan(JarScanType.PLUGGABILITY, this, callback);
    if (!callback.isOk()) {
        throw new JasperException(Localizer.getMessage("jspc.error.invalidFragment"));
    }
    return callback.getFragments();
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
private boolean embeddedSurefireScanning(final JarScanType scanType, final ServletContext context, final JarScannerCallback callback) {
    if (isScanClassPath() && System.getProperty("surefire.real.class.path") != null) {
        try {
            final Set<URL> urls = ClassLoaders.findUrls(context.getClassLoader().getParent());
            doScan(scanType, callback, new LinkedList<>(urls));
            return true;
        } catch (final IOException e) {
            // no-op
        }
    }
    return false;
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
@Override
public boolean check(final JarScanType jarScanType, final String jarName) {
    if (jarScanType == JarScanType.TLD) {
        if (INCLUDE.accept(jarName)) {
            return true;
        }
        if (jarName.startsWith("tomcat-websocket") || jarName.startsWith("myfaces-impl") /* see org.apache.tomee.jasper.TomEETldScanner.scanPlatform */) {
            return false;
        }
    }
    if (jarName.startsWith("johnzon-") || jarName.startsWith("xx-arquillian-tomee-")) {
        return false; // but we scan it in openejb scanning
    }
    return !NewLoaderLogic.skip(jarName) && (delegate == null || delegate.check(jarScanType, jarName));
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
@Override
public boolean check(JarScanType jarScanType, String jarName) {
    Lock readLock = configurationLock.readLock();
    readLock.lock();
    try {
        final boolean defaultScan;
        final Set<String> toSkip;
        final Set<String> toScan;
        switch (jarScanType) {
            case TLD: {
                defaultScan = defaultTldScan;
                toSkip = tldSkipSet;
                toScan = tldScanSet;
                break;
            }
            case PLUGGABILITY: {
                defaultScan = defaultPluggabilityScan;
                toSkip = pluggabilitySkipSet;
                toScan = pluggabilityScanSet;
                break;
            }
            case OTHER:
            default: {
                defaultScan = true;
                toSkip = defaultSkipSet;
                toScan = defaultScanSet;
            }
        }
        if (defaultScan) {
            if (Matcher.matchName(toSkip, jarName)) {
                if (Matcher.matchName(toScan, jarName)) {
                    return true;
                } else {
                    return false;
                }
            }
            return true;
        } else {
            if (Matcher.matchName(toScan, jarName)) {
                if (Matcher.matchName(toSkip, jarName)) {
                    return false;
                } else {
                    return true;
                }
            }
            return false;
        }
    } finally {
        readLock.unlock();
    }
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
@Override
public void scan(JarScanType scanType, ServletContext context, JarScannerCallback callback) {
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
@BeforeClass
public static void init() throws LifecycleException, ServletException {
    SLF4JBridgeHandler.removeHandlersForRootLogger();
    SLF4JBridgeHandler.install();

    tomcat = new Tomcat();
    tomcat.setPort(8080);
    tomcat.setBaseDir(".");
    Context ctx = tomcat.addWebapp("", "src/test");
    ctx.setJarScanner(new JarScanner() {
        @Override
        public void scan(JarScanType jarScanType, ServletContext servletContext, JarScannerCallback jarScannerCallback) {
        }

        @Override
        public JarScanFilter getJarScanFilter() {
            return null;
        }

        @Override
        public void setJarScanFilter(JarScanFilter jarScanFilter) {
        }
    });
    ((Host) ctx.getParent()).setAppBase("");

    final Wrapper multiRaml = ctx.createWrapper();
    multiRaml.setServletClass(RamlDocServlet.class.getName());
    multiRaml.setName("app");
    multiRaml.addInitParameter("ramlLocations", "classpath://data/basic.raml,classpath://data/second.raml,classpath://data/markdown.raml");
    multiRaml.addInitParameter("features", "online,tryout,download,docson");
    multiRaml.addInitParameter("baseUriParameters", "host=$host/$path,path=mirror");
    multiRaml.addInitParameter("customization", "classpath://");
    ctx.addChild(multiRaml);
    ctx.addServletMapping("/api/*", "app");

    final Wrapper singleRaml = ctx.createWrapper();
    singleRaml.setServletClass(RamlDocServlet.class.getName());
    singleRaml.setName("sapp");
    singleRaml.addInitParameter("ramlLocations", "classpath://data/basic.raml");
    singleRaml.addInitParameter("features", "online");
    singleRaml.addInitParameter("baseUriParameters", "host=$host/$path,path=mirror");
    ctx.addChild(singleRaml);
    ctx.addServletMapping("/sapi/*", "sapp");

    Tomcat.addServlet(ctx, "mirror", new MirrorServlet());
    ctx.addServletMapping("/mirror/v1/*", "mirror");

    tomcat.start();
    Server server = tomcat.getServer();
    server.start();
}
 

import org.apache.tomcat.JarScanType; //导入依赖的package包/类
@Override
public void scan(final JarScanType scanType, final ServletContext context,
                 final JarScannerCallback callback) {
    // no-op
}