Java 类org.reflections.util.ConfigurationBuilder 实例源码

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

@Test
public void tweetEntities() {
  Reflections reflections = new Reflections(new ConfigurationBuilder()
      .setUrls(ClasspathHelper.forJavaClassPath())
      .forPackages(TweetEntity.class.getPackage().getName())
  );

  List<Class<?>> allClasses = new ArrayList<>();
  List<Class<? extends TweetEntity>> classes = list(reflections, TweetEntity.class);
  allClasses.add(MediaEntity.Variant.class);
  allClasses.add(MediaEntity.Size.class);
  allClasses.addAll(classes);


  for (Class<?> cls : allClasses) {
    StringBuilder builder = new StringBuilder();
    processClass(cls, builder);

    System.out.println(builder);
  }


}

@BeforeEach
public void before() throws MalformedURLException {
  log.info("before() - Configuring reflections to use package '{}'", packages());

  if (null == this.reflections) {
    this.reflections = new Reflections(new ConfigurationBuilder()
        .setUrls(ClasspathHelper.forJavaClassPath())
        .forPackages(packages())
    );
  }

  List<Class<? extends Transformation>> transformClasses = list(Transformation.class);
  List<Class<? extends SourceConnector>> sourceConnectorClasses = list(SourceConnector.class);
  List<Class<? extends SinkConnector>> sinkConnectorClasses = list(SinkConnector.class);

  this.pluginTemplate = PluginTemplate.from(sourceConnectorClasses, sinkConnectorClasses, transformClasses);
}

private void computeClasses() {
    this.annotatedClassMap = new HashMap<>();
    this.otherClassMap = new HashMap<>();

    TypesHandled handlesTypes = handlesTypes();
    // check if any type is handled
    if (!handlesTypes.isEmpty()) {
        // create reflections
        Reflections reflections = new Reflections(new ConfigurationBuilder().setExpandSuperTypes(false).setUrls(getURLs()));

        // add types annotated for each type to be handled
        for (Class<? extends Annotation> annotationType : handlesTypes.getAnnotationTypes()) {
            this.annotatedClassMap.put(annotationType, reflections.getTypesAnnotatedWith(annotationType));
        }
        // add subtype of other types to be handled
        for (Class<?> otherType : handlesTypes.getOtherTypes()) {
            this.otherClassMap.put(otherType, (Set<Class<?>>) reflections.getSubTypesOf(otherType));
        }
    }
}

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

}

private ArrayList<String> getResourceDirectoryContent(String resourcePattern) {
    ArrayList<String> tempFilesContentList = new ArrayList<>();

    Reflections reflections = new Reflections(new ConfigurationBuilder()
                                                    .setUrls(ClasspathHelper.forPackage("io.logz"))
                                                    .setScanners(new ResourcesScanner())
                                                    .filterInputsBy(new FilterBuilder().include(resourcePattern)));
    Set<String> properties = reflections.getResources(Pattern.compile(".*\\.json"));

    properties.forEach((resourceName) -> {

        URL resourceUrl = Resources.getResource(resourceName);
        try {
            tempFilesContentList.add(Resources.toString(resourceUrl, Charset.forName("utf-8")).replace("\n", ""));

        } catch (IOException e) {
            logger.info("Could not read file {}", resourceUrl.toString());
        }
    });

    if (tempFilesContentList.isEmpty())
        throw new RuntimeException("Did not find any files under "+ resourcePattern +"!");

    return tempFilesContentList;
}

Set<Class<? extends T>> scan(Class<? extends T> aClass) {
    Configuration configuration = ConfigurationBuilder.build((Object[]) packages).addClassLoaders(classLoaders)
                                                      .addScanners(new AssignableScanner(aClass));
    Reflections reflections = new Reflections(configuration);
    Predicate<Class<? extends T>> classPredicate = klass ->
            Modifier.isPublic(klass.getModifiers()) &&
                    (!klass.isMemberClass() || (klass.isMemberClass() && Modifier
                            .isStatic(klass.getModifiers()))) &&
                    !Modifier.isInterface(klass.getModifiers()) &&
                    !Modifier.isAbstract(klass.getModifiers());
    HashSet<Class<? extends T>> subtypes = Sets.newHashSet(
            ReflectionUtils.forNames(
                    reflections.getStore()
                               .getAll(AssignableScanner.class.getSimpleName(),
                                       Collections.singletonList(aClass.getName())), classLoaders));
    return subtypes.stream().filter(classPredicate).collect(Collectors.toSet());
}

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

public void scan(String base) {
    Reflections reflections = new Reflections(new ConfigurationBuilder()
        .setUrls(ClasspathHelper.forPackage(base))
        .setScanners(new MethodAnnotationsScanner())
    );

    Set<Method> predicateMethods = reflections.getMethodsAnnotatedWith(Predicate.class);

    for (Method method : predicateMethods) {
        String name = method.getAnnotation(Predicate.class).name();

        if (name.isEmpty()) {
            name = method.getName();
        }

        this.register(method, name);
    }
}

/**
 * For a specific jar file, this method will extract any implementing Plugin
 * classes of the specified type.
 *
 * @param pluginJar Plugin jar file from which to extract any concrete
 * plugins.
 * @param pluginType Plugin types to extract.
 * @return An ArrayList of plugin classes.
 * @throws MalformedURLException If there is a problem reading the plugin
 * jar.
 */
public static ArrayList<Class<? extends Plugin>> getPluginsFromExternalJar(File pluginJar, Class pluginType) throws MalformedURLException
{
    URL[] urlArray = new URL[1];
    urlArray[0] = pluginJar.toURI().toURL();
    URLClassLoader childJar = new URLClassLoader(urlArray);
    Reflections reflections = new Reflections(new ConfigurationBuilder().setUrls(urlArray).addClassLoader(childJar));//confusing, but it works
    ArrayList<Class<? extends Plugin>> csfi = new ArrayList(reflections.getSubTypesOf(pluginType));
    ArrayList<Class<? extends Plugin>> toReturn = new ArrayList<>();
    for (Class<? extends Plugin> c : csfi)
    {
        if (!Modifier.isAbstract(c.getModifiers()))//don't pick up abstract plugins, we can't implement them anyway
        {
            toReturn.add(c);
            logger.debug("Read class: " + c.getCanonicalName() + " from jar: " + pluginJar.getAbsolutePath());
        }
    }
    return toReturn;
}

private String getKeywordClassList(URLClassLoader cl) throws Exception {
    URL url = cl.getURLs()[0];
    try {
        Reflections reflections = new Reflections(new ConfigurationBuilder().setUrls(url)
                .addClassLoader(cl).setScanners(new MethodAnnotationsScanner()));
        Set<Method> methods = reflections.getMethodsAnnotatedWith(Keyword.class);
        Set<String> kwClasses = new HashSet<>();
        for(Method method:methods) {
            kwClasses.add(method.getDeclaringClass().getName());
        }
        StringBuilder kwClassnamesBuilder = new StringBuilder();
        kwClasses.forEach(kwClassname->kwClassnamesBuilder.append(kwClassname+";"));
        return kwClassnamesBuilder.toString();
    } catch (Exception e) {
        String errorMsg = "Error while looking for methods annotated with @Keyword in "+url.toString();
        throw new Exception(errorMsg, 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);
}

/**
 * Gets and stores all of the commands in a HashMap for easier use.
 * @author Jared314
 */
public static void init() {
    commands=new HashMap<>();
    Reflections r = new Reflections(new ConfigurationBuilder().setUrls(ClasspathHelper.forJavaClassPath()));

    // Find all commands
    Set<Class<? extends Command>> commandClassList = r.getSubTypesOf(Command.class);

    // Add command instances to the commands hash map
    for(Class<? extends Command> cClass: commandClassList){

        try {
            Command c = cClass.newInstance();
            commands.put(c.getCommandText(), c);
        } catch (Exception e) {
            logger.log(Level.WARNING, "An error occurred initializing a command", e);
        }
    }
}

private static Set<Class<?>> getReflected() {
    synchronized (LOCK) {
        if (reflected != null) {
            return reflected;
        }
        Reflections reflections = new Reflections(new ConfigurationBuilder()
                .setUrls(ClasspathHelper.forPackage("com.jivesoftware"))
                .setScanners(new MethodAnnotationsScanner(), new TypeAnnotationsScanner()));
        Set<Class<?>> result = reflections.getTypesAnnotatedWith(Path.class);
        Set<Method> methods = reflections.getMethodsAnnotatedWith(Path.class);
        for (Method method : methods) {
            result.add(method.getDeclaringClass());
        }
        reflected = Collections.unmodifiableSet(result);
        return reflected;
    }
}

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 static Iterable<URL> scan(String pattern) {

        // lookup from classpath
        ConfigurationBuilder rcp = new ConfigurationBuilder()//
                .setUrls(ClasspathHelper.forClassLoader())//
                .setScanners(new ResourcesScanner());
        {
            String path = pathChar.replaceFrom(pattern, '.');
            rcp.setInputsFilter(in -> (false == in.startsWith("java.")) && Wildcard.match(in, path));
        }

        Set<String> scans = new Reflections(rcp).getResources(Predicates.alwaysTrue());

        // transforms strings to urls
        return Iterables.transform(scans, res -> getURL(res));
    }

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

    final Set<Method> methods = reflections.getMethodsAnnotatedWith(Cached.class);
    System.out.println("Found " + methods.size() + " methods annotated with " + Cached.class);

    for (final Method method : methods)
    {
        testMethod(method);
    }

    assertNoExceptions();
}

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

/**
 * Scans the specified packages for annotated classes, and applies Config values to them.
 * 
 * @param config the Config to derive values from
 * @param packageNamePrefix the prefix to limit scanning to - e.g. "com.github"
 * @return The constructed TypesafeConfigModule.
 */
public static TypesafeConfigModule fromConfigWithPackage(Config config, String packageNamePrefix) {
     ConfigurationBuilder configBuilder = 
         new ConfigurationBuilder()
         .filterInputsBy(new FilterBuilder().includePackage(packageNamePrefix))
         .setUrls(ClasspathHelper.forPackage(packageNamePrefix))
         .setScanners(
            new TypeAnnotationsScanner(), 
            new MethodParameterScanner(), 
            new MethodAnnotationsScanner(), 
            new FieldAnnotationsScanner()
         );
    Reflections reflections = new Reflections(configBuilder);

    return new TypesafeConfigModule(config, reflections);
}

private void _processPackages(final Set<String> packages) {
    if (CollectionUtils.hasData(_packages)) {
        // [1] - Find all types annotated with @XmlRootElement 
        Set<Class<?>> allPckgsTypes = Sets.newHashSet(); 

List<URL> urls = new ArrayList<URL>();
//urls.addAll(ClasspathHelper.forPackage("javax.xml.bind.annotation"));
        for (String p : packages) {
            //Reflections typeScanner = new Reflections(p);
    urls.addAll(ClasspathHelper.forPackage(p)); // see https://code.google.com/p/reflections/issues/detail?id=53
    log.debug("Scanning package {} for @XmlRootElement annotated types",p);
        }
Reflections typeScanner = new Reflections(new ConfigurationBuilder()
                                                    .setUrls(urls));                    
Set<Class<?>> pckgTypes = typeScanner.getTypesAnnotatedWith(XmlRootElement.class);
if (CollectionUtils.hasData(pckgTypes)) {
        for (Class<?> type : pckgTypes) log.trace(">Type {}",type);
    allPckgsTypes.addAll(pckgTypes);
} else {
    log.debug("NO types annotated with @XmlRootElement");
}
        // [2] - Process...
        _processTypes(allPckgsTypes);
    }
 }

private Map<String, String> getAllDocStrings0(ClassLoader classLoader) {
    final Configuration configuration = new ConfigurationBuilder()
            .filterInputsBy(new FilterBuilder().includePackage(path))
            .setUrls(ClasspathHelper.forPackage(path))
            .addClassLoader(classLoader)
            .setScanners(new ResourcesScanner());
    if (configuration.getUrls() == null || configuration.getUrls().isEmpty()) {
        return Collections.emptyMap();
    }
    Map<String, byte[]> files = new Reflections(configuration)
            .getResources(this::acceptFile).stream()
            .map(f -> {
                try {
                    URL url = classLoader.getResource(f);
                    if (url == null) {
                        throw new IllegalStateException("not found: " + f);
                    }
                    return new SimpleImmutableEntry<>(f, Resources.toByteArray(url));
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            })
            .collect(toImmutableMap(Entry::getKey, Entry::getValue));
    return getDocStringsFromFiles(files);
}

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

public static List<URL> urls( String atPackage, String ext ) {
    final ExecutorService executorService = Executors.newFixedThreadPool(
        Runtime.getRuntime().availableProcessors(),
        new ThreadFactoryBuilder().setNameFormat( "reflections-%d" ).build()
    );
    try {
        final ConfigurationBuilder configuration = new ConfigurationBuilder()
            .setUrls( ClasspathHelper.forPackage( atPackage ) )
            .setScanners( new ResourcesScanner() )
            .filterInputsBy( new FilterBuilder().includePackage( atPackage ) )
            .setExecutorService( executorService );
        final Reflections reflections = new Reflections( configuration );

        final Set<String> resources = reflections.getResources( in -> in.endsWith( "." + ext ) );
        return new ArrayList<>( Sets.map( resources, r -> Thread.currentThread().getContextClassLoader().getResource( r ) ) );
    } finally {
        executorService.shutdown();
    }
}

/**
 * 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);

}