Java Reflections.getSubTypesOf方法代码示例

import org.reflections.Reflections; //导入方法依赖的package包/类
public static void main(String[] args) throws Exception {
    Reflections reflections = new Reflections();
    LukkitPlus.BUKKIT_EVENTS = reflections.getSubTypesOf(Event.class);
    ClassPool classpath = ClassPool.getDefault();
    CtClass eventClass = classpath.makeClass("online.pizzacrust.lukkitplus" +
            ".EventCallback");
    for (Class<? extends Event> event : LukkitPlus.BUKKIT_EVENTS) {
        CtMethod eventMethod = CtNewMethod.make(CtClass.voidType, "on" + event.getSimpleName
                (), new CtClass[] { classpath.get(event.getName()) }, new CtClass[0], "online" +
                ".pizzacrust.lukkitplus.EventCallbackGenerator.call($1);", eventClass);
        eventClass.addMethod(eventMethod);
        AnnotationsAttribute attribute = new AnnotationsAttribute(eventClass.getClassFile()
                .getConstPool(), AnnotationsAttribute.visibleTag);
        Annotation eventHandlerAnnt = new Annotation(EventHandler.class.getName(), eventClass
                .getClassFile().getConstPool());
        attribute.addAnnotation(eventHandlerAnnt);
        eventMethod.getMethodInfo().addAttribute(attribute);
    }
    System.out.println("Done!");
    eventClass.writeFile();
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public static AntFactory[] getImplementations() {
	Reflections reflections = new Reflections("");
	Set<Class<? extends AntFactory>> classes = reflections.getSubTypesOf(AntFactory.class);

	List<AntFactory> ret = new ArrayList<>();

	for (Class<? extends AntFactory> it : classes) {
		try {
			ret.add(it.getConstructor().newInstance());
		} catch (InstantiationException | IllegalAccessException | IllegalArgumentException
				| InvocationTargetException | NoSuchMethodException | SecurityException e) {
			e.printStackTrace();
		}
	}

	return ret.stream().toArray(AntFactory[]::new);
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private <T> Collection<PluginDesc<T>> getPluginDesc(
        Reflections reflections,
        Class<T> klass,
        ClassLoader loader
) throws InstantiationException, IllegalAccessException {
    Set<Class<? extends T>> plugins = reflections.getSubTypesOf(klass);

    Collection<PluginDesc<T>> result = new ArrayList<>();
    for (Class<? extends T> plugin : plugins) {
        if (PluginUtils.isConcrete(plugin)) {
            // Temporary workaround until all the plugins are versioned.
            if (Connector.class.isAssignableFrom(plugin)) {
                result.add(
                        new PluginDesc<>(
                                plugin,
                                ((Connector) plugin.newInstance()).version(),
                                loader
                        )
                );
            } else {
                result.add(new PluginDesc<>(plugin, "undefined", loader));
            }
        }
    }
    return result;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public void load() {
	Reflections reflect = new Reflections(new Object[]{Manager.class});
	Set managers = reflect.getSubTypesOf(Manager.class);
	float progress = 0;
	for (Object obj : managers) {
		Class objClass = (Class)obj;
		try {
			progress += 100.0f / managers.size();
			Manager manager = (Manager)objClass.newInstance();

			this.managers.add(manager);

			ScaledResolution scaledresolution = new ScaledResolution(Minecraft.getMinecraft());
			ProgressBar progressBar = new ProgressBar(scaledresolution.getScaledWidth() / 2, scaledresolution.getScaledHeight() / 2, 100, 10, progress, "Loading Managers " + this.managers.size() + " / " + managers.size(), -1);
			ProgressBarList.addProgress(0, progressBar);

			Thread.sleep(10);
		} catch (Exception e) {;}
	}

	this.managers.sort((o2, o1) -> o2.getLoadLevel() - o1.getLoadLevel());
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private static void populateMap(final Map<String, FsConnRuleCommand<FsConnRuleCmdParamBean, FsConnRuleCmdResultBean>> commands) {
    final String commandPackage = "com.espirit.moddev.fstesttools.rules.firstspirit.commands";
    LOGGER.info("Scanning class path in '{}' for command classes...", commandPackage);
    Reflections reflections = new Reflections(commandPackage);
    Set<Class<? extends FsConnRuleCommand>> commandsFromPackage = reflections.getSubTypesOf(FsConnRuleCommand.class);

    int counter = 0;
    for (Class<? extends FsConnRuleCommand> commandClass : commandsFromPackage) {
        if (commandClass.isAnonymousClass()) {
            continue;
        }
        LOGGER.debug("Processing '{}'...", commandClass.getSimpleName());
        counter = handleEnumCommands(commands, counter, commandClass);
        counter = handleSimpleCommands(commands, counter, commandClass);
    }
    LOGGER.info("Loaded {} commands!", counter);
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private static <T> List<Class<? extends T>> concreteSubTypesOf(final Class<? extends T> clazz) {
    final ConfigurationBuilder conf = new ConfigurationBuilder()
            .setUrls(ClasspathHelper.forClass(clazz))
            .setScanners(new SubTypesScanner(true));
    final Reflections reflections = new Reflections(conf);
    final List<Class<? extends T>> result = new ArrayList<>();
    for (final Class<? extends T> type : reflections.getSubTypesOf(clazz)) {
        if (type.isInterface()) {
            continue;
        }

        if (Modifier.isAbstract(type.getModifiers())) {
            continue;
        }

        result.add(type);
    }

    return result;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private Set<Class<? extends ILoggerFactory>> scanContextForLoggerFactories() {
    final Set<Class<? extends ILoggerFactory>> loggerFactories;
    final Collection<URL> set = ClasspathHelper.forPackage(PACKAGE_TO_SCAN);
    final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner()));

    loggerFactories = reflections.getSubTypesOf(ILoggerFactory.class);
    loggerFactories.remove(this.getClass());
    return loggerFactories;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
/**
 * Instantiates a new Cas logger factory.
 * Configures the reflection scanning engine to be prepared to scan <code>org.slf4j.impl</code>
 * in order to find other available factories.
 */
public CasLoggerFactory() {
    this.loggerMap = new ConcurrentHashMap<>();
    final Collection<URL> set = ClasspathHelper.forPackage(PACKAGE_TO_SCAN);
    final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner()));

    final Set<Class<? extends ILoggerFactory>> subTypesOf = reflections.getSubTypesOf(ILoggerFactory.class);
    subTypesOf.remove(this.getClass());

    if (subTypesOf.size() > 1) {
        Util.report("Multiple ILoggerFactory bindings are found on the classpath:");
        for (final Class<? extends ILoggerFactory> c : subTypesOf) {
            Util.report("* " + c.getCanonicalName());
        }
    }

    if (subTypesOf.isEmpty()) {
        final RuntimeException e = new RuntimeException("No ILoggerFactory could be found on the classpath."
                + " CAS cannot determine the logging framework."
                + " Examine the project dependencies and ensure that there is one and only one logging framework available.");

        Util.report(e.getMessage(), e);
        throw e;
    }
    this.realLoggerFactoryClass = subTypesOf.iterator().next();
    Util.report("ILoggerFactory to be used for logging is: " + this.realLoggerFactoryClass.getName());
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
static Set<Class<?>> getClasses(String packageName) {
    List<ClassLoader> classLoadersList = new LinkedList<>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());

    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(false /* don't exclude Object.class */), new ResourcesScanner())
            .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName))));

    Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
    return classes;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private Set<Class<?>> getClasses(Reflections reflections) {
  Set<Class<?>> annotatedClasses = reflections.getSubTypesOf(Object.class);
  for (Iterator<Class<?>> iterator = annotatedClasses.iterator(); iterator.hasNext(); ) {
    Class<?> annotatedClass = iterator.next();

    if (Modifier.isAbstract(annotatedClass.getModifiers())) {
      iterator.remove();
    } else if (!matchesPatternOrIsEnabledSuite(annotatedClass)) {
      iterator.remove();
    }
  }
  return annotatedClasses;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public static <T> Kryo registerAllSubtypes(Kryo destination, Class<T> baseType, String sourcePackageName)
{
    Reflections reflections = new Reflections(sourcePackageName);
    @SuppressWarnings("unchecked")
    Set<Class<?>> subtypes = (Set<Class<?>>) (Set<?>) reflections.getSubTypesOf(baseType);
    registerCollection(destination, subtypes);
    return destination;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public OidcProfileScopeToAttributesFilter(final PrincipalFactory principalFactory,
                                          final ServicesManager servicesManager,
                                          final Collection<BaseOidcScopeAttributeReleasePolicy> userScopes,
                                          final OidcAttributeToScopeClaimMapper attributeToScopeClaimMapper) {
    this.attributeToScopeClaimMapper = attributeToScopeClaimMapper;
    this.filters = new HashMap<>();

    final String packageName = BaseOidcScopeAttributeReleasePolicy.class.getPackage().getName();
    final Reflections reflections =
            new Reflections(new ConfigurationBuilder()
                    .filterInputsBy(new FilterBuilder().includePackage(packageName))
                    .setUrls(ClasspathHelper.forPackage(packageName))
                    .setScanners(new SubTypesScanner(true)));

    final Set<Class<? extends BaseOidcScopeAttributeReleasePolicy>> subTypes =
            reflections.getSubTypesOf(BaseOidcScopeAttributeReleasePolicy.class);
    subTypes.forEach(Unchecked.consumer(t -> {
        final BaseOidcScopeAttributeReleasePolicy ex = t.newInstance();
        filters.put(ex.getScopeName(), ex);
    }));

    userScopes.forEach(t -> filters.put(t.getScopeName(), t));

    this.principalFactory = principalFactory;
    this.servicesManager = servicesManager;
    this.userScopes = userScopes;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
private VariableResolvers loadVariableResolverClasses() {
    Reflections reflections = new Reflections("br.com.moip.mockkid");
    Set<Class<? extends VariableResolver>> conditionals = reflections.getSubTypesOf(VariableResolver.class);
    VariableResolvers instances = new VariableResolvers();

    for (Class<? extends VariableResolver> conditional : conditionals) {
        try {
            instances.add(conditional.newInstance());
        } catch (IllegalAccessException | InstantiationException e) {
            logger.error("Couldn't instantiate class " + conditional.getName() + ", skipping...", e);
        }
    }

    return instances;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
public static Set<Class<? extends ObjectPayload>> getPayloadClasses () {
    final Reflections reflections = new Reflections(ObjectPayload.class.getPackage().getName());
    final Set<Class<? extends ObjectPayload>> payloadTypes = reflections.getSubTypesOf(ObjectPayload.class);
    for ( Iterator<Class<? extends ObjectPayload>> iterator = payloadTypes.iterator(); iterator.hasNext(); ) {
        Class<? extends ObjectPayload> pc = iterator.next();
        if ( pc.isInterface() || Modifier.isAbstract(pc.getModifiers()) ) {
            iterator.remove();
        }
    }
    return payloadTypes;
}
 

import org.reflections.Reflections; //导入方法依赖的package包/类
/**
 * @param scanPack
 * @param specifyPluginNames
 *
 * @throws WispPluginException
 */
@Override
public void loadPlugin(String scanPack, Set<String> specifyPluginNames) throws WispPluginException {

    Reflections reflections = ReflectionUtil.getReflection(scanPack);
    Set<Class<? extends IWispRouter>> wispRouters = reflections.getSubTypesOf(IWispRouter
            .class);

    boolean isFirst = true;
    for (Class<? extends IWispRouter> canalInjector : wispRouters) {

        String pluginName = canalInjector.getAnnotation(PluginName.class).name();

        if (!specifyPluginNames.contains(pluginName)) {
            continue;
        }

        LOGGER.info("loading router: {} - {}", pluginName, canalInjector.toString());

        try {
            Class<IWispRouter> canalInjectorClass = (Class<IWispRouter>) canalInjector;

            innerWispRouterMap.put(pluginName, canalInjectorClass.newInstance());

            if (isFirst) {
                firstWispRouter = innerWispRouterMap.get(pluginName);
                isFirst = false;
            }

        } catch (Exception e) {
            LOGGER.error(e.toString());
        }
    }
}