Java 类org.reflections.scanners.SubTypesScanner 实例源码

protected GuiceApplication(String... basePackages) {
  final ConfigurationBuilder confBuilder = new ConfigurationBuilder();
  final FilterBuilder filterBuilder = new FilterBuilder();

  if (basePackages.length == 0) {
    basePackages = new String[] {};
  }

  logger.info("op=create, auto_scan_packages={}", (Object[]) basePackages);

  for (String pkg : basePackages) {
    confBuilder.addUrls(ClasspathHelper.forPackage(pkg));
    filterBuilder.include(FilterBuilder.prefix(pkg));
  }

  confBuilder.filterInputsBy(filterBuilder)
      .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());

  this.reflections = new Reflections(confBuilder);
}

/**
 * Prepares the logger context. Locates the context and
 * sets the configuration file.
 * @return the logger context
 */
private ServletContextListener prepareAndgetContextListener() {
    try {
        if (StringUtils.isNotBlank(this.loggerContextPackageName)) {
            final Collection<URL> set = ClasspathHelper.forPackage(this.loggerContextPackageName);
            final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner()));
            final Set<Class<? extends ServletContextListener>> subTypesOf = reflections.getSubTypesOf(ServletContextListener.class);
            final ServletContextListener loggingContext = subTypesOf.iterator().next().newInstance();
            this.context.setInitParameter(this.logConfigurationField, this.logConfigurationFile.getURI().toString());
            return loggingContext;
        }
        return null;
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}

/**
 * Gets cas banner instance.
 *
 * @return the cas banner instance
 */
public static Banner getCasBannerInstance() {
    final String packageName = CasEmbeddedContainerUtils.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 AbstractCasBanner>> subTypes = reflections.getSubTypesOf(AbstractCasBanner.class);
    subTypes.remove(DefaultCasBanner.class);

    if (subTypes.isEmpty()) {
        return new DefaultCasBanner();
    }
    try {
        final Class<? extends AbstractCasBanner> clz = subTypes.iterator().next();
        LOGGER.debug("Created banner [{}]", clz);
        return clz.newInstance();
    } catch (final Exception e) {
        LOGGER.error(e.getMessage(), e);
    }
    return new DefaultCasBanner();
}

public ReflectionsServiceDiscovery(String resourceSearchPackages, JsonServiceLocator locator) {
    this.locator = locator;

    ConfigurationBuilder builder = new ConfigurationBuilder();

    PreconditionUtil.assertNotNull("no resourceSearchPackage configured", resourceSearchPackages);

    FilterBuilder filter = new FilterBuilder();
    for (String resourceSearchPackage : resourceSearchPackages.split(",")) {
        builder = builder.addUrls(ClasspathHelper.forPackage(resourceSearchPackage));
        filter.includePackage(resourceSearchPackage);
    }
    filter.includePackage(Repository.class.getPackage().getName());
    filter.includePackage(ResourceRepository.class.getPackage().getName());
    builder = builder.filterInputsBy(filter);

    builder = builder.addUrls(ClasspathHelper.forClass(Repository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepositoryV2.class));

    builder = builder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner());
    reflections = new Reflections(builder);
}

public CommandHandler() {
  try {
    Set<URL> classPathList = new HashSet<>();
    classPathList.addAll(ClasspathHelper.forJavaClassPath());
    Set<Class<? extends Command>> result = new Reflections(
        new ConfigurationBuilder().setScanners(new SubTypesScanner()).setUrls(classPathList))
        .getSubTypesOf(Command.class);

    for (Class<? extends Command> c : result) {
      String[] categoryString = c.getPackage().toString().split("\\.");
      String category = categoryString[categoryString.length - 1];
      if (category.equalsIgnoreCase("commands")) {
        category = "default";
      }
      Command command = c.newInstance();
      command.getSettings().setCategory(category);
      commands.add(command);
    }
  } catch (Exception e) {
    e.printStackTrace();
  }
}

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;
}

@Override
public List<TreeItem<Pair<AnnotatedElement, Object>>> query() {
    final List<TreeItem<Pair<AnnotatedElement, Object>>> results = new ArrayList<>();
    final Predicate<String> childPredicate = Pattern.compile("^" + (pakkage != null ? "\\." + pakkage.getName() : "") + REGEX_CHILD_SUFFIX).asPredicate();
    Arrays.asList(Package.getPackages()).stream().filter(p -> childPredicate.test(p.getName())).map(PackageTreeItem::new).forEach(results::add);

    if (pakkage != null) {
        final Reflections reflections = new Reflections(pakkage.getName(), new SubTypesScanner(false));
        reflections.getStore().getSubTypesOf(Object.class.getName()).stream().map(s -> {
            try {
                return Class.forName(s);
            } catch (ClassNotFoundException e) {
                e.printStackTrace();
            }
            return null;
        }).map(c -> ((QueriableTreeItem) new ReflectiveTreeItem.StaticReflectiveTreeItem(c))).filter(qti -> !qti.query().isEmpty()).forEach(results::add);
    }
    return results;
}

private void doPackage(FilterBuilder fb, List<RuleFactory> resultL) throws Exception {
    List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
    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(fb));      

    Set<Class<? extends RuleFactory>> subTypes = reflections.getSubTypesOf(RuleFactory.class);        
    for(Class<? extends RuleFactory> clazz : subTypes) {
        RuleFactory factory = clazz.newInstance();
        resultL.add(factory);
    }
}

@Test
public void testReflections() throws Exception {
    List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());

    String packageName = "org.dnal.core.world";
    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<String> types = reflections.getAllTypes();
    for(String s : types) {
        System.out.println(s);
    }

    Set<Class<? extends RuleFactory>> subTypes = reflections.getSubTypesOf(RuleFactory.class);        
    for(Class<? extends RuleFactory> clazz : subTypes) {
        System.out.println("sub: " + clazz.getName());
        RuleFactory factory = clazz.newInstance();
        RuleDeclaration decl = factory.getDeclaration();
        System.out.println("d: " + decl.ruleName);
    }

}

public BeanScanner(final BeanManagerImpl beanManager, final ClassLoader classLoader, final String packageToScan)
{
    this.beanManager = beanManager;
    final ConfigurationBuilder config = new ConfigurationBuilder();

    config.setClassLoaders(new ClassLoader[] {classLoader});
    config.setUrls(ClasspathHelper.forPackage(packageToScan, classLoader));
    if (StringUtils.isNotEmpty(packageToScan))
    {
        config.filterInputsBy(new FilterBuilder().includePackage(packageToScan));
    }
    config.useParallelExecutor();
    config.setScanners(new SubTypesScanner(false));

    this.reflections = new Reflections(config);
}

public ReflectionsServiceDiscovery(String resourceSearchPackages, JsonServiceLocator locator) {
    this.locator = locator;

    ConfigurationBuilder builder = new ConfigurationBuilder();

    PreconditionUtil.assertNotNull("no resourceSearchPackage configured", resourceSearchPackages);

    FilterBuilder filter = new FilterBuilder();
    for (String resourceSearchPackage : resourceSearchPackages.split(",")) {
        builder = builder.addUrls(ClasspathHelper.forPackage(resourceSearchPackage));
        filter.includePackage(resourceSearchPackage);
    }
    filter.includePackage(Repository.class.getPackage().getName());
    filter.includePackage(ResourceRepository.class.getPackage().getName());
    builder = builder.filterInputsBy(filter);

    builder = builder.addUrls(ClasspathHelper.forClass(Repository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepository.class));
    builder = builder.addUrls(ClasspathHelper.forClass(ResourceRepositoryV2.class));

    builder = builder.setScanners(new SubTypesScanner(false), new TypeAnnotationsScanner());
    reflections = new Reflections(builder);
}

/**
 * Finds all package names starting with prefix
 * @param prefix The package in which to start searching
 * @param statik True to statically return components names
 * @return a set of component name
 */
public List<String> findAllPackagesStartingWith(final String prefix, final boolean statik) {
    final List<ClassLoader> classLoadersList = new ArrayList<>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());

    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(false), new ResourcesScanner())
            .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()])))
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(prefix))));
    Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);

    final Set<String> packages = new HashSet<>();
    for (final Class classInstance : classes) {
        String packageName = classInstance.getPackage().getName();
        packageName = packageName.split("\\.")[packageName.split("\\.").length-1].toLowerCase();
        packages.add(packageName);
    }
    return new ArrayList<>(packages);
}

/**
 * Prepares the logger context. Locates the context and
 * sets the configuration file.
 * @return the logger context
 */
private ServletContextListener prepareAndgetContextListener() {
    try {
        if (StringUtils.isNotBlank(this.loggerContextPackageName)) {
            final Collection<URL> set = ClasspathHelper.forPackage(this.loggerContextPackageName);
            final Reflections reflections = new Reflections(new ConfigurationBuilder().addUrls(set).setScanners(new SubTypesScanner()));
            final Set<Class<? extends ServletContextListener>> subTypesOf = reflections.getSubTypesOf(ServletContextListener.class);
            final ServletContextListener loggingContext = subTypesOf.iterator().next().newInstance();
            this.context.setInitParameter(this.logConfigurationField, this.logConfigurationFile.getURI().toString());
            return loggingContext;
        }
        return null;
    } catch (final Exception e) {
        throw new RuntimeException(e);
    }
}

private static Collection<? extends Class<?>> getPackageTypes(String packageToPase, Collection<URL> urls) {
    Set<Class<?>> classes = new HashSet<>();
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(false /* exclude Object.class */), new ResourcesScanner(), new TypeElementsScanner())
            .setUrls(urls)
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageToPase)).exclude("java.*")));

    Set<String> types;
    types = reflections.getStore().get("TypeElementsScanner").keySet();
    for (String type: types) {
        Class<?> aClass = TypesHelper.loadClass(type, CLASS_LOADER);
        boolean wantedElement = StringUtils.startsWith(type, packageToPase);
        if (null != aClass && wantedElement) {
            logger.log(Level.INFO, "looking up for type: " + type);
            classes.add(aClass);
        }
    }
    return classes;
}

public static void scanForCommands() {
    //Populate all the cmds
    System.out.println("[EvenWurse] Reloading cmd list...");
    ArrayList<ClassLoader> classLoadersList = new ArrayList<>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());
    Reflections reflections = new Reflections(
            new ConfigurationBuilder().setScanners(new SubTypesScanner(), new ResourcesScanner()).setUrls(
                    ClasspathHelper
                            .forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()]))));
    Set<Class<? extends Cmd>> classes = reflections.getSubTypesOf(Cmd.class);
    KNOWN_CMDS = new Class[classes.size()];
    for (int i = 0; i < classes.size(); i++) {
        KNOWN_CMDS[i] = (Class<? extends Cmd>) classes.toArray()[i];
        System.out.println("[EvenWurse] Found cmd: " + KNOWN_CMDS[i].getSimpleName() + "!");
    }
    System.out.println("[EvenWurse] Found " + KNOWN_CMDS.length + " cmds!");
}

public static void scanForMods() {
    //Populate all the mods
    System.out.println("[EvenWurse] Reloading mod list...");
    ArrayList<ClassLoader> classLoadersList = new ArrayList<>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());
    Reflections reflections = new Reflections(
            new ConfigurationBuilder().setScanners(new SubTypesScanner(), new ResourcesScanner()).setUrls(
                    ClasspathHelper
                            .forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()]))));
    Set<Class<? extends Mod>> classes = reflections.getSubTypesOf(Mod.class);
    KNOWN_MODS = new Class[classes.size()];
    for (int i = 0; i < classes.size(); i++) {
        KNOWN_MODS[i] = (Class<? extends Mod>) classes.toArray()[i];
        System.out.println("[EvenWurse] Found mod: " + KNOWN_MODS[i].getSimpleName() + "!");
    }
    System.out.println("[EvenWurse] Found " + KNOWN_MODS.length + " mods!");
}

public void addLoader(ClassLoader loader) {
    if (builder == null) {
        this.builder = new ConfigurationBuilder();
        builder.setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
    }
    builder.addClassLoader(loader);
    builder.addUrls(ClasspathHelper.forClassLoader(loader));

    if(loader instanceof JoinClassLoader) {
        // When the object "reflections" is created in the method scanClassPath(), are scanned the URLs so
        // it is necessary to add the URLs from the enclosing class loader in the JoinClassLoader that it
        // contains the fixture classpath (see org.reflections.Reflections.scan()).
        builder.addUrls(ClasspathHelper.forClassLoader(((JoinClassLoader) loader).getEnclosingClassLoader()));
    }

    scanClassPath(builder);
}

public synchronized void init(ServletContext context) {
    if (HANDLERS != null) {
        return;
    }
    LOG.info("Initializing output handlers...");
    Map<String, Class<? extends IOutputHandler>> handlers = new HashMap<>();
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .addUrls(ClasspathHelper.forWebInfLib(context))
            .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner(false)));
    Set<Class<?>> classes = reflections.getTypesAnnotatedWith(OutputHandler.class);
    for (Class<?> clazz : classes) {
        LOG.info("Found annotated output handler class: " + clazz.getName());
        if (IOutputHandler.class.isAssignableFrom(clazz)) {
            String id = clazz.getAnnotation(OutputHandler.class).id();
            //noinspection unchecked
            handlers.put(id, (Class<? extends IOutputHandler>)clazz);
            LOG.info("Added output handler " + id + " in class: " + clazz.getName());
        }
    }
    HANDLERS = handlers;
    LOG.info("Initialization of output handlers completed.");
}

public void test()
{
    final Reflections reflections = new Reflections(new ConfigurationBuilder()
            .addUrls(ClasspathHelper.forClassLoader())
            .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner())
            );

    final Set<Class<?>> classes_withValidator = reflections.getTypesAnnotatedWith(Validator.class);
    System.out.println("Found " + classes_withValidator.size() + " classes annotated with " + Validator.class);

    final Set<Class<?>> classes_withInterceptor = reflections.getTypesAnnotatedWith(Interceptor.class);
    System.out.println("Found " + classes_withInterceptor.size() + " classes annotated with " + Interceptor.class);

    final Set<Class<?>> classes = ImmutableSet.<Class<?>> builder()
            .addAll(classes_withValidator)
            .addAll(classes_withInterceptor)
            .build();
    System.out.println("=> " + classes.size() + " classes to test");

    for (final Class<?> clazz : classes)
    {
        testClass(clazz);
    }

    assertNoExceptions();
}

private void scanConceptsWithReflections() throws ObjectStoreConfigException {
    logger.debug("Search for concepts with reflections");
    Set<URL> classpath = new HashSet<>();
    classpath.addAll(ClasspathHelper.forClassLoader());
    classpath.addAll(ClasspathHelper.forJavaClassPath());
    classpath.addAll(ClasspathHelper.forManifest());
    classpath.addAll(ClasspathHelper.forPackage(""));
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(classpath)
.useParallelExecutor()
.filterInputsBy(FilterBuilder.parsePackages("-java, -javax, -sun, -com.sun"))
            .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner()));

    Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(Iri.class, true);
    logger.debug("Search for concepts with reflections resulted in " + annotated.size() + " classes");
    for (Class clazz : annotated) {
        logger.debug("Found concept class: " + clazz.getCanonicalName());
        roleMapper.addConcept(clazz);
    }
}

/**
 * Init stuff is responsible to grab all DTOs found in classpath (classloader) and setup model for
 * String Template
 */
protected void init() {

  ConfigurationBuilder configurationBuilder =
      new ConfigurationBuilder().setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
  if (useClassPath) {
    configurationBuilder.setUrls(forJavaClassPath());
  } else {
    configurationBuilder.setUrls(forClassLoader());
  }

  // keep only DTO interfaces
  Reflections reflections = new Reflections(configurationBuilder);
  List<Class<?>> annotatedWithDtos =
      new ArrayList<>(reflections.getTypesAnnotatedWith(DTO.class));
  List<Class<?>> interfacesDtos =
      annotatedWithDtos
          .stream()
          .filter(clazz -> clazz.isInterface())
          .collect(Collectors.toList());
  interfacesDtos.stream().forEach(this::analyze);
}

@Override
public void execute() throws MojoExecutionException, MojoFailureException {
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(ClasspathHelper.forPackage(basePackage)).setScanners(
                    new SubTypesScanner(), new TypeAnnotationsScanner()));

    Set<Class<?>> resources = reflections
            .getTypesAnnotatedWith(Resource.class);

    Set<Class<?>> apis = reflections
            .getTypesAnnotatedWith(ApiGateway.class);

    Map<String, EndpointResource> endpointResources = getEndpointResources(resources);
    String apiName = getApiName(apis);
    fileWriter.createSwaggerFile(new ArrayList<EndpointResource>(endpointResources.values()), apiName);

}

@SuppressWarnings("unchecked")
private void registerScriptEngineFactories() {
    List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(), new TypeAnnotationsScanner(), new ResourcesScanner())
            .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("com.jsen"))));

    Set<Class<?>> annotated = reflections.getTypesAnnotatedWith(ScriptEngineFactory.class);

    for (Class<?> clazz : annotated) {
        if (AbstractScriptEngineFactory.class.isAssignableFrom(clazz)) {
            registerMimeContentFactory((Class<AbstractScriptEngineFactory>)clazz);  
        }
    }
}

public ModelInfoLookup(ModelNamingStrategy namingStrategy, String packageName, ClassLoader classLoader) {
    this.packageName = packageName;
    this.namingStrategy = namingStrategy;

    this.classLoader = classLoader;
    Reflections reflections = new Reflections(packageName, new SubTypesScanner(false));
    Set<String> typeNames = reflections.getAllTypes();

    System.out.println("type names size: " + typeNames.size());
    typeNames.forEach(typeName -> {
        try {
            addClass(classLoader.loadClass(typeName));
        } catch (ClassNotFoundException e) {
            logger.error("error loading model info lookup", e);
        }
    });
    addSuperAndSubclassInfo();
    inConstructor = false;
}

private Set<Class<?>> getSubtypes(final Class<?> type) throws ComboBoxIsTooFullException {
    final ClassLoader[] classloaders = new ClassLoader[] { currentModelHandler.getCustomClassLoader(),
                                                           currentModelHandler.getCustomClassLoader().getParent() };
    final ConfigurationBuilder builder = new ConfigurationBuilder().
            addUrls(ClasspathHelper.forClassLoader(currentModelHandler.getCustomClassLoader())). 
            addClassLoaders(classloaders).
            setScanners(new SubTypesScanner(false));
    final Reflections ref = new Reflections(builder);
    final Set<Class<?>> result = new HashSet<Class<?>>();
    final Set<String> subTypesStr = ref.getStore().getSubTypesOf(type.getName());
    if (subTypesStr.size() > MAX_SIZE_OF_SUBPARAMETER_COMBOBOX)
        throw new ComboBoxIsTooFullException();

    for (final String clsName : subTypesStr) {
        try {
            result.add(ReflectionUtils.forName(clsName,classloaders));
        } catch (final ReflectionsException e) {
            // intentionally blank
        }
    }

    return result;
}

/**
 * Creates a {@link org.reflections.Reflections} with the given packages (configuration)
 *
 * @param scanPackages
 */
private void createReflections(String[] scanPackages) {
    if (scanPackages.length < 1) {
        LOGGER.warn("No package defined in configuration (scanPackages)!");
        return;
    }
    ConfigurationBuilder configurationBuilder = new ConfigurationBuilder();
    FilterBuilder filterBuilder = new FilterBuilder();
    for (String packageName : scanPackages) {
        configurationBuilder.addUrls(ClasspathHelper.forPackage(packageName));
        filterBuilder.include(FilterBuilder.prefix(packageName));
    }

    configurationBuilder.filterInputsBy(filterBuilder).setScanners(new SubTypesScanner(), new TypeAnnotationsScanner());
    this.reflections = new Reflections(configurationBuilder);

}

/**
 * creates a sortedset of all hook implementations found for the given hook. Ordering is done through
 * {@link com.github.cherimojava.orchidae.hook.HookHandler.HookComparator} in reverse order
 * 
 * @param hook to find all implementations from
 * @param url where to search for hook implementations
 * @param <H> Hook type
 * @return sortedset with all found hook implementation
 */
public static <H> SortedSet<? extends H> getHookOrdering( Class<H> hook, URL url )
{
    Configuration config = new ConfigurationBuilder().addUrls( url )
        .addUrls( ClasspathHelper.forPackage( HookHandler.class.getPackage().getName() ) )
        .setScanners( new SubTypesScanner() );
    Reflections reflect = new Reflections( config );
    SortedSet<H> hooks = Sets.newTreeSet( new ReverseComparator( comparator ) );
    LOG.info( "Searching for hooks of {}", hook );
    for ( Class<? extends H> c : reflect.getSubTypesOf( hook ) )
    {
        try
        {
            LOG.info( "Found hook {}", c );
            hooks.add( c.newInstance() );
        }
        catch ( IllegalAccessException | InstantiationException e )
        {
            LOG.error( "Failed to instantiate {} please make sure it has a no param Constructor. {}", c, e );
        }
    }
    return hooks;
}

/**
 * Creates reflection for package and base class.
 * @param pack
 * @param clazz
 */
public Reflection(String pack, Class clazz) {
    if (clazz.equals(Object.class)) {
        // @see http://stackoverflow.com/a/9571146
        List<ClassLoader> classLoadersList = new LinkedList();
        classLoadersList.add(ClasspathHelper.contextClassLoader());
        classLoadersList.add(ClasspathHelper.staticClassLoader());

        this.reflections = new Reflections(new ConfigurationBuilder()
                .setScanners(new SubTypesScanner(false), new ResourcesScanner())
                .addUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[0])))
                .addUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[1])))
                .addUrls(ClasspathHelper.forJavaClassPath())
                .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(pack))));

    } else {
        this.reflections = new Reflections(clazz);
    }
}

private void init() {
    providers = Maps.newConcurrentMap();

    // use reflection to load providers
    final Set<Class<? extends IRealizationProvider>> realizationProviders = new Reflections("org.apache.kylin", new SubTypesScanner()).getSubTypesOf(IRealizationProvider.class);
    List<Throwable> es = Lists.newArrayList();
    for (Class<? extends IRealizationProvider> cls : realizationProviders) {
        try {
            IRealizationProvider p = (IRealizationProvider) cls.getMethod("getInstance", KylinConfig.class).invoke(null, config);
            providers.put(p.getRealizationType(), p);

        } catch (Exception | NoClassDefFoundError e) {
            es.add(e);
        }

        if (es.size() > 0) {
            for (Throwable exceptionOrError : es) {
                logger.error("Create new store instance failed ", exceptionOrError);
            }
            throw new IllegalArgumentException("Failed to find metadata store by url: " + config.getMetadataUrl());
        }
    }

    logger.info("RealizationRegistry is " + providers);
}

private Reflections buildReflections(String packages) {
    String[] packagesArray = packages.replaceAll(" ", "").split(",");

    FilterBuilder filter = new FilterBuilder();

    Set<URL> urls = new HashSet();

    for (String packageStr : packagesArray) {
        urls.addAll(ClasspathHelper.forPackage(packageStr));
        filter.include(FilterBuilder.prefix(packageStr));
    }

    return new Reflections(new ConfigurationBuilder()
            .addUrls(urls)
            .filterInputsBy(filter)
            .setScanners(new TypeAnnotationsScanner(), new SubTypesScanner()));
}

@Test
public void testAll() throws IOException {

    List<ClassLoader> classLoadersList = ImmutableList.of(
        ClasspathHelper.contextClassLoader(),
        ClasspathHelper.staticClassLoader()
    );

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

    for (Class clazz : reflections.getSubTypesOf(Object.class)) {
        System.out.print(clazz);
        String c = clazz.getName();
        c = c.substring(c.lastIndexOf('.') + 1); // There might be a better way than this!
        ExtendedRandomAccessFile in = open( clazz, c + ".class" );
        new PngDissector().read(in); // Read but don't do anything with it
        System.out.println(" [OK]");
    }
}

private Set<String> findAllPackages() {
    final List<ClassLoader> classLoadersList = new LinkedList<ClassLoader>();
    classLoadersList.add(ClasspathHelper.contextClassLoader());
    classLoadersList.add(ClasspathHelper.staticClassLoader());

    final Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setScanners(new SubTypesScanner(false), new ResourcesScanner())
            .setUrls(ClasspathHelper.forClassLoader(classLoadersList.toArray(new ClassLoader[classLoadersList.size()])))
            .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(basePackage))));
    final Set<Class<?>> classes = reflections.getSubTypesOf(Object.class);
    final Set<String> packageNameSet = new TreeSet<String>();
    for (final Class classInstance : classes) {
        packageNameSet.add(classInstance.getPackage().getName());
    }
    return packageNameSet;
}

private static void RegisterActors(Binder binder) {
    Logger.debug("Actor Scanner Started...");
    final Map<String, ActorHolder> map = new HashMap<>();       
    final ConfigurationBuilder configBuilder = build();
    final Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner()));
    final Set<Class<? extends UntypedActor>> actors = reflections.getSubTypesOf(UntypedActor.class);
       final Set<Class<? extends AbstractActor>> abstractActors = reflections.getSubTypesOf(AbstractActor.class);
       loopOnActors(map, actors);
       loopOnAbstractActors(map, abstractActors);
       if(!map.isEmpty()) Logger.debug("Registering actors: ");
    for(final String key : map.keySet()) {
        final ActorHolder actorHolder = map.get(key);
        final Class<? extends Actor> actor = actorHolder.getActor();
        if(actorHolder.isSingleton()) {
            Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Singleton Scoped.");
            binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, true)).in(Singleton.class);
        } else {
            Logger.debug("Binding class " + actor.getSimpleName() + " to name: " + key + " Request Scoped.");
            binder.bind(ActorRef.class).annotatedWith(Names.named(key)).toProvider(new ActorRefProvider(actor, key, false));
            PropsContext.put(key, actorHolder);
        }
    }
}

protected void loadCompressors() {
    /*
        We scan classpath for NDArrayCompressor implementations and add them one by one to codecs map
     */
    codecs = new ConcurrentHashMap<>();
    Set<Class<? extends NDArrayCompressor>> classes = new Reflections(new ConfigurationBuilder()
                    .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix("org.nd4j"))
                                    .exclude("^(?!.*\\.class$).*$")) //Consider only .class files (to avoid debug messages etc. on .dlls, etc
                    .setUrls(ClasspathHelper.forPackage("org.nd4j")).setScanners(new SubTypesScanner()))
                                    .getSubTypesOf(NDArrayCompressor.class);

    for (Class<? extends NDArrayCompressor> impl : classes) {
        if (Modifier.isAbstract(impl.getModifiers()) || impl.isInterface())
            continue;

        try {
            NDArrayCompressor compressor = impl.newInstance();

            codecs.put(compressor.getDescriptor().toUpperCase(), compressor);
        } catch (InstantiationException i) {
            ; // we need catch there, to avoid exceptions at abstract classes
        } catch (Exception e) {
            throw new RuntimeException(e);
        }
    }
}

private void addSupportedOperations(String[] opPackages) {
    Set<URL> packages = new HashSet<>();
    for (String opPackage : opPackages) {
        packages.addAll(ClasspathHelper.forPackage(opPackage));
    }

    Reflections reflections = new Reflections(packages, new SubTypesScanner());
    for (Class<? extends Operation> opClass : reflections.getSubTypesOf(Operation.class)) {
        if (Modifier.isAbstract(opClass.getModifiers())) continue;

        DisplayName displayName = opClass.getAnnotation(DisplayName.class);
        if (displayName != null ) {
            operations.put(displayName.value(), opClass);
        }else{
            throw new RuntimeException(opClass.getSimpleName() + " is an invalid Operation.");
        }
    }
}

private void init(String packageName) {
  FilterBuilder filters = new FilterBuilder().includePackage(packageName);

  Scanner[] scanners = {
      new TypeAnnotationsScanner(),
      new MethodAnnotationsScanner(),
      new MethodParameterScanner(),
      new FieldAnnotationsScanner(),
      new SubTypesScanner().filterResultsBy(filters)
  };

  reflections = new ConfigurationBuilder()
      .addUrls(ClasspathHelper.forPackage(packageName))
      .addScanners(scanners)
      .filterInputsBy(filters)
      .build();
}

/**
 * https://github.com/ronmamo/reflections/issues/81
 */
@Test
public void reflections_scan_is_thread_safe() throws Exception {

    Callable<Set<Class<? extends ImmutableMap>>> callable = new Callable<Set<Class<? extends ImmutableMap>>>() {
        @Override
        public Set<Class<? extends ImmutableMap>> call() throws Exception {
            final Reflections reflections = new Reflections(new ConfigurationBuilder()
                    .setUrls(singletonList(ClasspathHelper.forClass(ImmutableMap.class)))
                    .setScanners(new SubTypesScanner(false)));

            return reflections.getSubTypesOf(ImmutableMap.class);
        }
    };

    final ExecutorService pool = Executors.newFixedThreadPool(2);

    final Future<?> first = pool.submit(callable);
    final Future<?> second = pool.submit(callable);

    assertEquals(first.get(5, SECONDS), second.get(5, SECONDS));
}

public static ArrayList<Class> getSubtypes(String rootPackage) {
    log.debug("------------ Getting all children of MOI from package: " + rootPackage);
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .filterInputsBy(new FilterBuilder.Include(FilterBuilder.prefix(rootPackage)))
            .setUrls(ClasspathHelper.forPackage(rootPackage))
            .setScanners(new SubTypesScanner(),
                    new TypeAnnotationsScanner(),
                    new ResourcesScanner()));
    ArrayList<Class> annoList = new ArrayList<Class>();
    annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true));
    log.debug("annoList.size()::" + annoList.size());
    ArrayList<Class> subTypesList = new ArrayList<Class>();
    subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class));
    log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList);
    subTypesList.removeAll(annoList);
    log.debug("getSubtypes: found types: " + subTypesList);
    return subTypesList;
}

public static ArrayList<Class> getSubtypes(Class rootClass) {
    log.debug("------------ Getting all children of MOI for class: " + rootClass.getCanonicalName());
    Reflections reflections = new Reflections(new ConfigurationBuilder()
            .setUrls(ClasspathHelper.forClass(rootClass))
            .setScanners(new SubTypesScanner(),
                    new TypeAnnotationsScanner(),
                    new ResourcesScanner()));
    ArrayList<Class> annoList = new ArrayList<Class>();
    annoList.addAll(reflections.getTypesAnnotatedWith(IgnoreFromTableCreation.class, true));
    log.debug("annoList.size()::" + annoList.size());
    ArrayList<Class> subTypesList = new ArrayList<Class>();
    subTypesList.addAll(reflections.getSubTypesOf(ModelObjectInterface.class));
    log.debug("getSubtypes: removing because it's annotated with @IgnoreFromTableCreation clazz = " + annoList);
    subTypesList.removeAll(annoList);
    log.debug("getSubtypes: found types: " + subTypesList);
    return subTypesList;
}

@Path("virtualips")
public Object retrieveVirtualIpsResource() throws IllegalAccessException, InstantiationException {
    String enabledExtension = PluginConfiguration.getExtensionPrefix();
    ConfigurationBuilder configBuilder = new ConfigurationBuilder();
    configBuilder.addUrls(ClasspathHelper.forPackage("org.daylight.pathweaver." + enabledExtension + ".api"));

    // TODO: Decompose this out and dynamically resolve sub-resource base off of extensions prefix
    Reflections reflections = new Reflections(configBuilder.setScanners(new SubTypesScanner()));
    Set<Class<? extends VirtualIpsResource>> subTypes = reflections.getSubTypesOf(VirtualIpsResource.class);

    if (subTypes.iterator().hasNext()) {
        final Class<? extends VirtualIpsResource> subClass = subTypes.iterator().next();
        final VirtualIpsResource bean = PluginContextLoaderListener.getCurrentWebApplicationContext().getBean(subClass);
        bean.setLoadBalancerId(id);
        bean.setAccountId(accountId);
        return bean;
    } else {
        virtualIpsResource.setLoadBalancerId(id);
        virtualIpsResource.setAccountId(accountId);
        return  virtualIpsResource;
    }
}