import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
public void displayConfigHelp(PrintStream out, String fraction) throws IOException, ModuleLoadException {
    ModuleClassLoader cl = Module.getBootModuleLoader().loadModule("swarm.application").getClassLoader();
    Enumeration<URL> docs = cl.getResources("META-INF/configuration-meta.properties");

    Properties props = new Properties();

    while (docs.hasMoreElements()) {
        URL each = docs.nextElement();
        Properties fractionDocs = new Properties();
        fractionDocs.load(each.openStream());
        if (fraction.equals(ALL) || fraction.equals(fractionDocs.getProperty(FRACTION))) {
            fractionDocs.remove(FRACTION);
            props.putAll(fractionDocs);
        }
    }

    props.stringPropertyNames().stream()
            .sorted()
            .forEach(key -> {
                out.println("# " + key);
                out.println();
                out.println(formatDocs("    ", props.getProperty(key)));
                out.println();
            });
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
public void dumpYaml(PrintStream out, String fraction) throws IOException, ModuleLoadException {
    ModuleClassLoader cl = Module.getBootModuleLoader().loadModule("swarm.application").getClassLoader();
    Enumeration<URL> docs = cl.getResources("META-INF/configuration-meta.properties");

    Properties props = new Properties();

    while (docs.hasMoreElements()) {
        URL each = docs.nextElement();
        Properties fractionDocs = new Properties();
        fractionDocs.load(each.openStream());
        if (fraction.equals(ALL) || fraction.equals(fractionDocs.getProperty(FRACTION))) {
            fractionDocs.remove(FRACTION);
            props.putAll(fractionDocs);
        }
    }

    YamlDumper.dump(out, props);
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
private static void setupLoggingSystem(ModuleLoader moduleLoader) {
    final ModuleIdentifier logModuleId = ModuleIdentifier.create(MODULE_ID_LOGMANAGER);
    final Module logModule;
    try {
        logModule = moduleLoader.loadModule(logModuleId);
    } catch (final ModuleLoadException mle) {
        throw EmbeddedLogger.ROOT_LOGGER.moduleLoaderError(mle, MODULE_ID_LOGMANAGER, moduleLoader);
    }

    final ModuleClassLoader logModuleClassLoader = logModule.getClassLoader();
    final ClassLoader tccl = WildFlySecurityManager.getCurrentContextClassLoaderPrivileged();
    try {
        WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(logModuleClassLoader);
        WildFlySecurityManager.setPropertyPrivileged(SYSPROP_KEY_LOGMANAGER, SYSPROP_VALUE_JBOSS_LOGMANAGER);

        final Class<?> actualLogManagerClass = LogManager.getLogManager().getClass();
        if (actualLogManagerClass == LogManager.class) {
            System.err.println("Cannot not load JBoss LogManager. The LogManager has likely been accessed prior to this initialization.");
        } else {
            Module.setModuleLogger(new JDKModuleLogger());
        }
    } finally {
        // Reset TCCL
        WildFlySecurityManager.setCurrentContextClassLoaderPrivileged(tccl);
    }
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
@Override
public void contextInitialized(ServletContextEvent event) {

    // [TODO] #41 Invalid class load of embedded interface despite defined dependency
    // https://issues.jboss.org/browse/WFLY-3511
    try {
        ModuleClassLoader classLoader = (ModuleClassLoader) getClass().getClassLoader();
        org.jboss.modules.Module graviaModule = classLoader.getModule().getModuleLoader().loadModule(ModuleIdentifier.create("org.jboss.gravia"));
        org.jboss.modules.Module osgiModule = classLoader.getModule().getModuleLoader().loadModule(ModuleIdentifier.create("org.osgi.enterprise"));
        Class<?> interfClass = loadClass(null, osgiModule.getClassLoader(), "org.osgi.service.http.HttpService");
        Class<?> implClass = loadClass(null, graviaModule.getClassLoader(), "org.apache.felix.http.base.internal.service.HttpServiceImpl");
        if (!interfClass.isAssignableFrom(implClass)) {
            System.out.println("NOT ASSIGNABLE: " + interfClass + " <= " + implClass);
        }
    } catch (Exception ex) {
        throw new IllegalStateException(ex);
    }

    ServletContext servletContext = event.getServletContext();

    // HttpService integration
    Runtime runtime = RuntimeLocator.getRequiredRuntime();
    Module sysmodule = runtime.getModuleContext().getModule();
    BundleContext bundleContext = sysmodule.adapt(Bundle.class).getBundleContext();
    servletContext.setAttribute(BundleContext.class.getName(), bundleContext);
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
/**
 * Compiles and links the scripts within the module by locating the correct compiler
 * and delegating the compilation. the classes will be loaded into the module's classloader
 * upon completion.
 * @param module module to be compiled
 * @param moduleCompilationRoot the directory to store compiled classes in.
 */
protected void compileModule(Module module, Path moduleCompilationRoot) throws ScriptCompilationException, IOException {
    // compile the script archive for the module, and inject the resultant classes into
    // the ModuleClassLoader
    ModuleClassLoader moduleClassLoader = module.getClassLoader();
    if (moduleClassLoader instanceof JBossModuleClassLoader) {
        JBossModuleClassLoader jBossModuleClassLoader = (JBossModuleClassLoader)moduleClassLoader;
        ScriptArchive scriptArchive = jBossModuleClassLoader.getScriptArchive();
        List<ScriptArchiveCompiler> candidateCompilers = findCompilers(scriptArchive);
        if (candidateCompilers.size() == 0) {
            throw new ScriptCompilationException("Could not find a suitable compiler for this archive.");
        }

        // Compile iteratively
        for (ScriptArchiveCompiler compiler: candidateCompilers) {
            compiler.compile(scriptArchive, jBossModuleClassLoader, moduleCompilationRoot);
        }
    }
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
/**
 * Verify that the module creates the expected set of dependencies for a {@link PathScriptArchive}
 */
@Test
public void testPathResources() throws Exception {
    Path jarPath = CoreTestResourceUtil.getResourceAsPath(TEST_TEXT_PATH);
    ScriptArchive jarScriptArchive = new PathScriptArchive.Builder(jarPath)
        .setModuleSpec(new ScriptModuleSpec.Builder(ModuleId.create("testModuleId"))
            .addMetadata(METADATA_NAME, METADATA_VALUE)
            .build())
        .build();
    ModuleIdentifier revisionId = JBossModuleUtils.createRevisionId(TEST_TEXT_PATH.getModuleId(), 1);
    ModuleSpec.Builder moduleSpecBuilder = ModuleSpec.build(revisionId);
    JBossModuleLoader moduleLoader = new JBossModuleLoader();
    JBossModuleUtils.populateModuleSpecWithCoreDependencies(moduleSpecBuilder, jarScriptArchive);
    JBossModuleUtils.populateModuleSpecWithResources(moduleSpecBuilder, jarScriptArchive);
    moduleLoader.addModuleSpec(moduleSpecBuilder.create());

    Module module = moduleLoader.loadModule(revisionId);
    ModuleClassLoader moduleClassLoader = module.getClassLoader();

    // verify the metadata was transfered
    assertEquals(module.getProperty(METADATA_NAME), METADATA_VALUE);
    // verify that the archive resource match exactly the module resources
    Set<String> actualPaths = getResourcePaths(moduleClassLoader);

    assertEquals(actualPaths, TEST_TEXT_PATH.getContentPaths());
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
@SuppressWarnings("unchecked")
protected void deployServletProcessApplication(ServletProcessApplication processApplication) {

  ClassLoader contextClassloader = ClassLoaderUtil.getContextClassloader();
  String moduleName = ((ModuleClassLoader)contextClassloader).getModule().getIdentifier().toString();

  ServiceName serviceName = ServiceNames.forNoViewProcessApplicationStartService(moduleName);
  ServiceName paModuleService = ServiceNames.forProcessApplicationModuleService(moduleName);

  if(serviceContainer.getService(serviceName) == null) {

    ServiceController<ServiceTarget> requiredService = (ServiceController<ServiceTarget>) serviceContainer.getRequiredService(paModuleService);

    NoViewProcessApplicationStartService service = new NoViewProcessApplicationStartService(processApplication.getReference());
    requiredService.getValue()
      .addService(serviceName, service)
      .setInitialMode(Mode.ACTIVE)
      .install();

  }
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
@Test
public void testInside() throws Exception {

    // confirm we can load a custom module from a custom repo
    ClassLoader classLoader = ArquillianTest.class.getClassLoader();
    Assert.assertTrue(classLoader instanceof ModuleClassLoader);
    Assert.assertNotNull(classLoader.getResource("progress/bar.clj"));

    // confirm the resource injectors work
    Assert.assertEquals(EXPECTED_URL, url);
    Assert.assertEquals(EXPECTED_URI, uri);
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
@SuppressWarnings("unchecked")
private void executeOperation(Object deploymentOperations, String operation) throws Exception {
    Class defaultBootModuleLoaderHolder = this.getClass().getClassLoader().loadClass("org.jboss.modules.DefaultBootModuleLoaderHolder");
    Field instance = defaultBootModuleLoaderHolder.getDeclaredField("INSTANCE");
    instance.setAccessible(true);
    ModuleLoader loader = (ModuleLoader) instance.get(null);
    Module module = loader.loadModule(ModuleIdentifier.fromString("org.jboss.as.deployment-scanner"));
    traceln("ServerLoaderhelper", "Module " + module.toString() + " loaded.");
    ModuleClassLoader cl = module.getClassLoader();
    Class modelNodeClass = cl.loadClassLocal("org.jboss.dmr.ModelNode");
    traceln("ServerLoaderhelper", "org.jboss.dmr.ModelNode class loaded.");
    Object modelNode = modelNodeClass.newInstance();
    Method getMethod = modelNodeClass.getDeclaredMethod("get", String.class);
    Method setMethod = modelNodeClass.getDeclaredMethod("set", String.class);
    Method setAddressMethod = modelNodeClass.getDeclaredMethod("set", modelNodeClass);
    Method setEmptyListMethod = modelNodeClass.getDeclaredMethod("setEmptyList");
    Object operationNode = getMethod.invoke(modelNode, "operation");
    setMethod.invoke(operationNode, operation);
    Object operationAddressNode = getMethod.invoke(modelNode, "address");
    Object addressNode = modelNodeClass.newInstance();
    setEmptyListMethod.invoke(addressNode);
    setAddressMethod.invoke(operationAddressNode, addressNode);
    traceln("ServerLoaderhelper", "We have computed the following operation " + modelNode.toString());
    for (Method deployMethod : deploymentOperations.getClass().getDeclaredMethods()) {
        if ("deploy".equals(deployMethod.getName())) {
            deployMethod.setAccessible(true);
            traceln("ServerLoaderhelper", "We have found the execution method.");
            deployMethod.invoke(deploymentOperations, modelNode, null);
            traceln("ServerLoaderhelper", "We have executed the following operation: " + modelNode.toString());
        }
    }
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
/**
 * Create an embedded standalone server with an already established module loader.
 *
 * @param moduleLoader the module loader. Cannot be {@code null}
 * @param jbossHomeDir the location of the root of server installation. Cannot be {@code null} or empty.
 * @param cmdargs      any additional arguments to pass to the embedded server (e.g. -b=192.168.100.10)
 * @return the running embedded server. Will not be {@code null}
 */
public static StandaloneServer createStandaloneServer(ModuleLoader moduleLoader, File jbossHomeDir, String... cmdargs) {

    // in the case of a stop and a restart with a different jbossHomeDir, we need to reset some properties.
    // that are set in @org.jboss.as.ServerEnvironment
    resetEmbeddedServerProperties(jbossHomeDir.getAbsolutePath(), ProcessType.STANDALONE_SERVER);

    setupVfsModule(moduleLoader);
    setupLoggingSystem(moduleLoader);

    // Load the Embedded Server Module
    final Module embeddedModule;
    try {
        embeddedModule = moduleLoader.loadModule(ModuleIdentifier.create(MODULE_ID_EMBEDDED));
    } catch (final ModuleLoadException mle) {
        throw EmbeddedLogger.ROOT_LOGGER.moduleLoaderError(mle, MODULE_ID_EMBEDDED, moduleLoader);
    }

    // Load the Embedded Server Factory via the modular environment
    final ModuleClassLoader embeddedModuleCL = embeddedModule.getClassLoader();
    final Class<?> embeddedServerFactoryClass;
    final Class<?> standaloneServerClass;
    try {
        embeddedServerFactoryClass = embeddedModuleCL.loadClass(SERVER_FACTORY);
        standaloneServerClass = embeddedModuleCL.loadClass(StandaloneServer.class.getName());
    } catch (final ClassNotFoundException cnfe) {
        throw EmbeddedLogger.ROOT_LOGGER.cannotLoadEmbeddedServerFactory(cnfe, SERVER_FACTORY);
    }

    // Get a handle to the method which will create the server
    final Method createServerMethod;
    try {
        createServerMethod = embeddedServerFactoryClass.getMethod("create", File.class, ModuleLoader.class, Properties.class, Map.class, String[].class);
    } catch (final NoSuchMethodException nsme) {
        throw EmbeddedLogger.ROOT_LOGGER.cannotGetReflectiveMethod(nsme, "create", embeddedServerFactoryClass.getName());
    }
    // Create the server
    Object standaloneServerImpl = createManagedProcess(ProcessType.STANDALONE_SERVER, createServerMethod, moduleLoader, jbossHomeDir, cmdargs);
    return new EmbeddedManagedProcessImpl(standaloneServerClass, standaloneServerImpl);
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
/**
 * Create an embedded host controller with an already established module loader.
 *
 * @param moduleLoader the module loader. Cannot be {@code null}
 * @param jbossHomeDir the location of the root of server installation. Cannot be {@code null} or empty.
 * @param cmdargs      any additional arguments to pass to the embedded host controller (e.g. -b=192.168.100.10)
 * @return the running host controller Will not be {@code null}
 */
public static HostController createHostController(ModuleLoader moduleLoader, File jbossHomeDir, String[] cmdargs) {

    // reset properties if we've restarted with a changed jbossHomeDir
    resetEmbeddedServerProperties(jbossHomeDir.getAbsolutePath(), ProcessType.HOST_CONTROLLER);

    setupVfsModule(moduleLoader);
    setupLoggingSystem(moduleLoader);

    // Load the Embedded Server Module
    final Module embeddedModule;
    try {
        embeddedModule = moduleLoader.loadModule(ModuleIdentifier.create(MODULE_ID_EMBEDDED));
    } catch (final ModuleLoadException mle) {
        throw EmbeddedLogger.ROOT_LOGGER.moduleLoaderError(mle, MODULE_ID_EMBEDDED, moduleLoader);
    }

    // Load the Embedded Server Factory via the modular environment
    final ModuleClassLoader embeddedModuleCL = embeddedModule.getClassLoader();
    final Class<?> embeddedHostControllerFactoryClass;
    final Class<?> hostControllerClass;
    try {
        embeddedHostControllerFactoryClass = embeddedModuleCL.loadClass(HOST_FACTORY);
        hostControllerClass = embeddedModuleCL.loadClass(HostController.class.getName());
    } catch (final ClassNotFoundException cnfe) {
        throw EmbeddedLogger.ROOT_LOGGER.cannotLoadEmbeddedServerFactory(cnfe, HOST_FACTORY);
    }

    // Get a handle to the method which will create the server
    final Method createServerMethod;
    try {
        createServerMethod = embeddedHostControllerFactoryClass.getMethod("create", File.class, ModuleLoader.class, Properties.class, Map.class, String[].class);
    } catch (final NoSuchMethodException nsme) {
        throw EmbeddedLogger.ROOT_LOGGER.cannotGetReflectiveMethod(nsme, "create", embeddedHostControllerFactoryClass.getName());
    }

    // Create the server
    Object hostControllerImpl = createManagedProcess(ProcessType.HOST_CONTROLLER, createServerMethod, moduleLoader, jbossHomeDir, cmdargs);
    return new EmbeddedManagedProcessImpl(hostControllerClass, hostControllerImpl);
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
private static void initCoreModel(final ModelNode root, HostControllerEnvironment environment) {

        try {
            root.get(RELEASE_VERSION).set(Version.AS_VERSION);
            root.get(RELEASE_CODENAME).set(Version.AS_RELEASE_CODENAME);
        } catch (RuntimeException e) {
            if (HostAddHandler.class.getClassLoader() instanceof ModuleClassLoader) {
                //The standalone tests can't get this info
                throw e;
            }
        }
        root.get(MANAGEMENT_MAJOR_VERSION).set(Version.MANAGEMENT_MAJOR_VERSION);
        root.get(MANAGEMENT_MINOR_VERSION).set(Version.MANAGEMENT_MINOR_VERSION);
        root.get(MANAGEMENT_MICRO_VERSION).set(Version.MANAGEMENT_MICRO_VERSION);

        // Community uses UNDEF values
        ModelNode nameNode = root.get(PRODUCT_NAME);
        ModelNode versionNode = root.get(PRODUCT_VERSION);

        if (environment != null) {
            String productName = environment.getProductConfig().getProductName();
            String productVersion = environment.getProductConfig().getProductVersion();

            if (productName != null) {
                nameNode.set(productName);
            }
            if (productVersion != null) {
                versionNode.set(productVersion);
            }
        }

        //Set empty lists for namespaces and schema-locations to pass model validation
        root.get(NAMESPACES).setEmptyList();
        root.get(SCHEMA_LOCATIONS).setEmptyList();
    }
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
private void checkModule(String slot, ModuleIdentifier expected, String...moduleDirNames) throws Exception {
    ModuleLoader loader = createModuleLoader(moduleDirNames);
    ClassLoader classLoader = ConsoleMode.ConsoleHandler.findConsoleClassLoader(loader, slot);
    assertNotNull(classLoader);
    assertTrue(classLoader instanceof ModuleClassLoader);
    ModuleClassLoader moduleClassLoader = (ModuleClassLoader)classLoader;
    assertEquals(expected, moduleClassLoader.getModule().getIdentifier());
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
@Override
public void start(StartContext startContext) throws StartException {
    LOGGER.info("Activating Fabric Subsystem");

    Runtime runtime = injectedRuntime.getValue();
    ModuleContext syscontext = runtime.getModuleContext();

    // Install and start this as a {@link Module}
    ModuleClassLoader classLoader = (ModuleClassLoader) getClass().getClassLoader();
    try {
        Dictionary<String, String> headers = getManifestHeaders(classLoader, "wildfly-extension");
        module = runtime.installModule(classLoader, headers);

        // Attach the {@link ModuleEntriesProvider} so
        ModuleEntriesProvider entriesProvider = new ClassLoaderEntriesProvider(module);
        Attachable attachable = AbstractModule.assertAbstractModule(module);
        attachable.putAttachment(AbstractModule.MODULE_ENTRIES_PROVIDER_KEY, entriesProvider);

        // Start the module
        module.start();

    } catch (RuntimeException rte) {
        throw rte;
    } catch (Exception ex) {
        throw new StartException(ex);
    }

    // Open service trackers for {@link Resolver}, {@link Repository}, {@link Provisioner}
    trackers = new HashSet<ServiceTracker<?, ?>>();
    trackers.add(resolverTracker(syscontext, startContext.getChildTarget()));
    trackers.add(repositoryTracker(syscontext, startContext.getChildTarget()));
    trackers.add(provisionerTracker(syscontext, startContext.getChildTarget()));
    trackers.add(completeTracker(syscontext, startContext.getChildTarget()));
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
private Dictionary<String, String> getManifestHeaders(ModuleClassLoader classLoader, String jarNamePart) throws IOException {
    URL manifestURL = null;
    Enumeration<URL> resources = classLoader.getResources(JarFile.MANIFEST_NAME);
    while (resources.hasMoreElements()) {
        URL nextURL = resources.nextElement();
        if (nextURL.getPath().contains(jarNamePart)) {
            manifestURL = nextURL;
            break;
        }
    }
    IllegalStateAssertion.assertNotNull(manifestURL, "Cannot obtain manifest URL for: " + jarNamePart);
    Manifest manifest = new Manifest(manifestURL.openStream());
    Dictionary<String, String> headers = new ManifestHeadersProvider(manifest).getHeaders();
    return headers;
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
protected static ResourceLoader[] getExistingResourceLoaders(Module module) {
    ResourceLoader[] loaders;
    try {
        loaders = (ResourceLoader[])lookupMethod(ModuleClassLoader.class, "getResourceLoaders")
                .invoke(module.getClassLoader());
    } catch (IllegalAccessException | InvocationTargetException e) {
        throw new IllegalStateException(e);
    }

    return loaders;
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
private LoginContext getLoginContext(Configuration config) throws LoginException {
    IllegalStateAssertion.assertNotNull(username, "username");
    IllegalStateAssertion.assertNotNull(password, "password");

    final String configName = domain != null ? domain : "other";

    CallbackHandler cbh = new CallbackHandler() {
        public void handle(Callback[] callbacks) throws IOException, UnsupportedCallbackException {
            for (Callback current : callbacks) {
                if (current instanceof NameCallback) {
                    ((NameCallback) current).setName(username);
                } else if (current instanceof PasswordCallback) {
                    ((PasswordCallback) current).setPassword(password);
                } else {
                    throw new UnsupportedCallbackException(current);
                }
            }
        }
    };

    ClassLoader tccl = SecurityActions.getContextClassLoader();
    try {
        if (!(tccl instanceof ModuleClassLoader)) {
            ClassLoader modcl = LoginContextBuilder.class.getClassLoader();
            SecurityActions.setContextClassLoader(modcl);
        }
        return new LoginContext(configName, new Subject(), cbh, config);
    } finally {
        SecurityActions.setContextClassLoader(tccl);
    }
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
public final void deploy(final DeploymentPhaseContext phaseContext) throws DeploymentUnitProcessingException {
    DeploymentUnit depUnit = phaseContext.getDeploymentUnit();
    CamelDeploymentSettings depSettings = depUnit.getAttachment(CamelDeploymentSettings.ATTACHMENT_KEY);

    // Camel disabled
    if (!depSettings.isEnabled()) {
        return;
    }

    ContextCreateHandlerRegistry createHandlerRegistry = depUnit.getAttachment(CamelConstants.CONTEXT_CREATE_HANDLER_REGISTRY_KEY);
    ModuleClassLoader moduleClassLoader = depUnit.getAttachment(Attachments.MODULE).getClassLoader();
    ContextCreateHandler contextCreateHandler = new PackageScanClassResolverAssociationHandler(moduleClassLoader);
    depSettings.setClassResolverAssociationHandler(contextCreateHandler);
    createHandlerRegistry.addContextCreateHandler(moduleClassLoader, contextCreateHandler);
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
public void undeploy(DeploymentUnit depUnit) {
    ContextCreateHandlerRegistry createHandlerRegistry = depUnit.getAttachment(CamelConstants.CONTEXT_CREATE_HANDLER_REGISTRY_KEY);
    CamelDeploymentSettings depSettings = depUnit.getAttachment(CamelDeploymentSettings.ATTACHMENT_KEY);
    if (createHandlerRegistry != null) {
        ModuleClassLoader classLoader = depUnit.getAttachment(Attachments.MODULE).getClassLoader();
        createHandlerRegistry.removeContextCreateHandler(classLoader, depSettings.getClassResolverAssociationHandler());
    }
}
 

import org.jboss.modules.ModuleClassLoader; //导入依赖的package包/类
@Override
protected void find(PackageScanFilter filter, String packageName, ClassLoader classLoader, Set<Class<?>> classes) {
    LOGGER.info("Searching for: {} in package: {} using classloader: {}", new Object[] { filter, packageName, classLoader });

    // Would be the case for the system classloader
    if (!(classLoader instanceof ModuleClassLoader)) {
        super.find(filter, packageName, classLoader, classes);
        return;
    }

    int classLoadCount = classes.size();

    ModuleClassLoader moduleClassLoader = (ModuleClassLoader) classLoader;
    Iterator<Resource> itres = moduleClassLoader.iterateResources("/", true);
    while (itres.hasNext()) {
        Resource resource = itres.next();
        String resname = resource.getName();
        if (resname.startsWith(packageName) && resname.endsWith(".class")) {
            String className = resname.substring(0, resname.length() - 6).replace('/', '.');
            try {
                Class<?> loadedClass = moduleClassLoader.loadClass(className);
                if (filter.matches(loadedClass)) {
                    LOGGER.info("Found type in package scan: {}", loadedClass.getName());
                    classes.add(loadedClass);
                }
            } catch (ClassNotFoundException ex) {
                //ignore
            }
        }
    }

    // No classes found by previous package scan so delegate to super
    if(classes.size() == classLoadCount) {
        super.find(filter, packageName, classLoader, classes);
    }
}