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

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

/**
 * Initializes correlations between json paths and xpaths
 */
private static PathCorrelation loadPathCorrelation() {
    PathCorrelation pathCorrelation;

    try {
        InputStream input = ClasspathHelper.contextClassLoader().getResourceAsStream(config);
        ObjectMapper mapper = new ObjectMapper();
        pathCorrelation = mapper.readValue(input, PathCorrelation.class);
        flattenCorrelations(pathCorrelation);
    } catch (IOException ioe) {
        String message = "Problem loading path correlation configuration";
        DEV_LOG.error(message, ioe);
        throw new PathCorrelationException(message, ioe);
    }

    return pathCorrelation;
}

public static Map<String, MeasureConfig> grabConfiguration(String fileName) {
    ObjectMapper mapper = new ObjectMapper();

    InputStream measuresInput = ClasspathHelper.contextClassLoader().getResourceAsStream(fileName);

    try {
        TypeReference<List<MeasureConfig>> measureConfigType = new TypeReference<List<MeasureConfig>>() {};
        List<MeasureConfig> configurations = mapper.readValue(measuresInput, measureConfigType);
        return configurations.stream()
                .collect(Collectors.toMap(MeasureConfigs::getMeasureId, Function.identity()));
    } catch (IOException e) {
        String message = "failure to correctly read measures config json";
        DEV_LOG.error(message);
        throw new IllegalArgumentException(message, e);
    }
}

@Test
void parseClinicalDocument() throws Exception {
    InputStream stream =
            ClasspathHelper.contextClassLoader().getResourceAsStream("valid-QRDA-III-abridged.xml");
    String xmlFragment = IOUtils.toString(stream, StandardCharsets.UTF_8);

    Context context = new Context();
    Node clinicalDocumentNode = XmlInputDecoder.decodeXml(context, XmlUtils.stringToDom(xmlFragment));

    // remove default nodes (will fail if defaults change)
    DefaultDecoder.removeDefaultNode(clinicalDocumentNode.getChildNodes());

    QppOutputEncoder encoder = new QppOutputEncoder(context);
    encoder.setNodes(Collections.singletonList(clinicalDocumentNode));

    StringWriter sw = new StringWriter();
    encoder.encode(new BufferedWriter(sw));

    assertThat(sw.toString()).isEqualTo(expected);
}

@BeforeAll
static void setup() {
    ObjectMapper mapper = new ObjectMapper();

    InputStream stream =
            ClasspathHelper.contextClassLoader().getResourceAsStream("measures-data-aci-test.json");

    try {
        TypeReference<List<MeasureConfig>> measureConfigType = new TypeReference<List<MeasureConfig>>() {};
        measureConfigs = mapper.readValue(stream, measureConfigType);
    } catch (IOException e) {
        throw new IllegalArgumentException("failure to correctly read measures config json", e);
    }

    theConfig = measureConfigs.get(0);
}

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

@Test
public void doExecute() throws Exception {
    final PackageMojo mojo = getMojoFromPom();
    final PackageMojo mojoSpy = spy(mojo);
    ReflectionUtils.setVariableValueInObject(mojoSpy, "finalName", "artifact-0.1.0");
    doReturn(mock(AnnotationHandler.class)).when(mojoSpy).getAnnotationHandler();
    doReturn(ClasspathHelper.forPackage("com.microsoft.azure.maven.function.handlers").toArray()[0])
            .when(mojoSpy)
            .getTargetClassUrl();
    doReturn("target/azure-functions").when(mojoSpy).getDeploymentStageDirectory();
    doReturn("target").when(mojoSpy).getBuildDirectoryAbsolutePath();
    doReturn(mock(MavenProject.class)).when(mojoSpy).getProject();
    doReturn(mock(MavenSession.class)).when(mojoSpy).getSession();
    doReturn(mock(MavenResourcesFiltering.class)).when(mojoSpy).getMavenResourcesFiltering();

    mojoSpy.doExecute();
}

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

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

/**
 * This is copied from {@link ClasspathHelper}, but there's a bug when using default packages, so the implementation is changed.
 *
 * @param aClass
 * @param classLoaders
 * @return
 */
public static URL forClass(Class<?> aClass, ClassLoader... classLoaders) {
    final ClassLoader[] loaders = ClasspathHelper.classLoaders(classLoaders);
    final String resourceName = aClass.getName().replace(".", "/") + ".class";
    for (ClassLoader classLoader : loaders) {
        try {
            final URL url = classLoader.getResource(resourceName);
            if (url != null) {
                Package aPackage = aClass.getPackage();
                String externalForm = url.toExternalForm();
                if(aPackage != null) {
                    String convertedPackageName = aPackage.getName().replace(".", "/");
                    final String normalizedUrl = externalForm.substring(0, externalForm.lastIndexOf(convertedPackageName));
                    return new URL(normalizedUrl);
                }
                return url;
            }
        } catch (MalformedURLException e) {
            if (Reflections.log != null) {
                Reflections.log.warn("Could not get URL", e);
            }
        }
    }
    return null;
}

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

/**
 * Derives the OpenGamma build from the classpath and dependencies.
 * 
 * @return the build, null if not known
 */
public static String deriveBuild() {
  URL url = ClasspathHelper.forClass(VersionUtils.class, VersionUtils.class.getClassLoader());
  if (url != null && url.toString().contains(".jar")) {
    try {
      final String part = ClasspathHelper.cleanPath(url);
      try (JarFile myJar = new JarFile(part)) {
        final Manifest manifest = myJar.getManifest();
        if (manifest != null) {
          Attributes attributes = manifest.getMainAttributes();
          if (attributes != null) {
            if (attributes.getValue(IMPLEMENTATION_BUILD) != null) {
              return attributes.getValue(IMPLEMENTATION_BUILD);
            }
          }
        }
      }
    } catch (Exception ex) {
      s_logger.warn(ex.getMessage(), ex);
    }
  }
  return null;
}

/**
 * Derives the OpenGamma build ID from the classpath and dependencies.
 * <p>
 * This ID is derived from the CI server.
 * 
 * @return the build ID, null if not known
 */
public static String deriveBuildId() {
  URL url = ClasspathHelper.forClass(VersionUtils.class, VersionUtils.class.getClassLoader());
  if (url != null && url.toString().contains(".jar")) {
    try {
      final String part = ClasspathHelper.cleanPath(url);
      try (JarFile myJar = new JarFile(part)) {
        final Manifest manifest = myJar.getManifest();
        if (manifest != null) {
          Attributes attributes = manifest.getMainAttributes();
          if (attributes != null) {
            if (attributes.getValue(IMPLEMENTATION_BUILD_ID) != null) {
              return attributes.getValue(IMPLEMENTATION_BUILD_ID);
            }
          }
        }
      }
    } catch (Exception ex) {
      s_logger.warn(ex.getMessage(), ex);
    }
  }
  return null;
}

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

/**
 * Creates an Anno4j instance that can use the concepts contained in the given JAR file.
 * @param ontologyJar A JAR file containing concepts.
 * @param classLoader The class loader to use.
 * @param persistSchemaAnnotations Whether schema annotations should be scanned.
 * @return Returns an Anno4j instance.
 * @throws Exception Thrown on error.
 */
private static Anno4j getAnno4jWithClassLoader(File ontologyJar, ClassLoader classLoader, boolean persistSchemaAnnotations) throws Exception {
    Set<URL> clazzes = new HashSet<>();
    clazzes.addAll(ClasspathHelper.forManifest(ontologyJar.toURI().toURL()));
    Anno4j anno4j = new Anno4j(new SailRepository(new MemoryStore()), new IDGeneratorAnno4jURN(), null, persistSchemaAnnotations, clazzes);

    // Register concepts found in JAR:
    RoleMapper mapper = anno4j.getObjectRepository().getConnection().getObjectFactory().getResolver().getRoleMapper();
    for (final String className : getClassNamesInJar(ontologyJar)) {
        Class<?> clazz = classLoader.loadClass(className);
        if(clazz.getAnnotation(Iri.class) != null) {
            mapper.addConcept(clazz);
        }
    }

    return anno4j;
}

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