public ConfigurationBuilder forPackages(String... packages) { for (String pkg : packages) { addUrls(ClasspathHelper.forPackage(pkg)); } return this; }
public ConfigurationBuilder forPackages(String... packages) { for (String pkg : packages) { addUrls(ClasspathHelper.forPackage(pkg)); } return this; }
private void configureReflections() { ConfigurationBuilder builder = new ConfigurationBuilder(); Set<URL> packagesToScan = getPackagesToScanForRoutes(); builder.addUrls(packagesToScan); builder.addScanners(new MethodAnnotationsScanner()); reflections = new Reflections(builder); }
builder.addUrls(ClasspathHelper.forPackage((String) param, classLoaders)); filter.includePackage((String) param); try { builder.addScanners(((Scanner) ((Class) param).newInstance())); } catch (Exception e) { /*fallback*/ } builder.addUrls(ClasspathHelper.forClass((Class) param, classLoaders)); filter.includePackage(((Class) param)); else if (param instanceof URL) { builder.addUrls((URL) param); } else if (param instanceof ClassLoader) { /* already taken care */ } else if (param instanceof Predicate) { filter.add((Predicate<String>) param); } builder.addUrls(ClasspathHelper.forClassLoader(classLoaders)); //default urls getResources("") } else { builder.addUrls(ClasspathHelper.forClassLoader()); //default urls getResources("")
if (!isIgnored(pkg)) { acceptablePackages.add(pkg); config.addUrls(ClasspathHelper.forPackage(pkg));
if (!isIgnored(pkg)) { acceptablePackages.add(pkg); config.addUrls(ClasspathHelper.forPackage(pkg));
builder.addUrls(ClasspathHelper.forPackage((String) param, classLoaders)); filter.includePackage((String) param); try { builder.addScanners(((Scanner) ((Class) param).newInstance())); } catch (Exception e) { /*fallback*/ } builder.addUrls(ClasspathHelper.forClass((Class) param, classLoaders)); filter.includePackage(((Class) param)); else if (param instanceof URL) { builder.addUrls((URL) param); } else if (param instanceof ClassLoader) { /* already taken care */ } else if (param instanceof Predicate) { filter.add((Predicate<String>) param); } builder.addUrls(ClasspathHelper.forClassLoader(classLoaders)); //default urls getResources("") } else { builder.addUrls(ClasspathHelper.forClassLoader()); //default urls getResources("")
/** * Return the classes from the given package and subpackages using the supplied classloader * * @param classLoader classloader to be used * @param pkg package to scan * @return set of found classes * @throws IOException */ public static Set<Class<?>> scanPackage(ClassLoader classLoader, String pkg) throws IOException { Reflections reflections = new Reflections(new ConfigurationBuilder() .addUrls(ClasspathHelper.forPackage(pkg, classLoader)) .addClassLoader(classLoader) .setScanners(new SubTypesScanner(false))); Set<Class<?>> classes = new HashSet<Class<?>>(); for (String typeNames : reflections.getStore().get(SubTypesScanner.class.getSimpleName()).values()) { Class<?> clazz = safeClassForName(classLoader, typeNames); if (clazz != null) { classes.add(clazz); } } return classes; }
@Test public void testNoDefaultEncoding() throws Exception { final Reflections reflections = new Reflections(new ConfigurationBuilder() .useParallelExecutor(Runtime.getRuntime().availableProcessors()) .addUrls(ClasspathHelper.forPackage("org.apache.flink")) .addScanners(new MemberUsageScanner())); for (ForbiddenCall forbiddenCall : forbiddenCalls) { final Set<Member> methodUsages = forbiddenCall.getUsages(reflections); methodUsages.removeAll(forbiddenCall.getExclusions()); assertEquals("Unexpected calls: " + methodUsages, 0, methodUsages.size()); } } }
@TaskAction public void generateSpec() throws IOException, GenerateException { ClassLoader loader = projectClassLoader(); Set<Class<?>> classes = new HashSet<>(); for (String pkg : apiPackages) { Reflections reflections = new Reflections( new ConfigurationBuilder() .addClassLoaders(loader) .addUrls(ClasspathHelper.forPackage(pkg, loader)) .setExpandSuperTypes(false) .filterInputsBy(new FilterBuilder().includePackage(pkg))); Set<Class<?>> springMVCClasses = reflections.getTypesAnnotatedWith( org.springframework.web.bind.annotation.RestController.class); classes.addAll(springMVCClasses); } SpringMvcApiReader reader = new SpringMvcApiReader(new Swagger(), log); Swagger swagger = reader.read(classes); for (SwaggerFilter filter : filters) { filter.apply(swagger); } Yaml.pretty().writeValue(swaggerFile, swagger); }
public static Set<Class<?>> getClassesWithAnnotation(Class<? extends Annotation> annotation, String[] packageNames) { Reflections reflections; Set<Class<?>> classes = new HashSet<Class<?>>(); ConfigurationBuilder builder=new ConfigurationBuilder(); for (String packageName : packageNames) { builder.addUrls(ClasspathHelper.forPackage(packageName)); } builder.setScanners(new SubTypesScanner(),new TypeAnnotationsScanner()); reflections = new Reflections(builder); classes.addAll(reflections.getTypesAnnotatedWith(annotation)); return classes; }
private static Reflections buildReflections(final Collection<URL> urls) { final ClassLoader classLoader = new URLClassLoader(urls.toArray(new URL[urls.size()]), Thread .currentThread().getContextClassLoader()); final ConfigurationBuilder builder = new ConfigurationBuilder(); builder.setScanners(SCANNER).addClassLoader(classLoader).addUrls(urls); final Reflections reflections = new Reflections(builder); return reflections; }
public TorchCompilerModule(TorchCompilerEntrypoint entrypoint, RoundEnvironment roundEnvironment) { this.entrypoint = entrypoint; this.roundEnvironment = roundEnvironment; ConfigurationBuilder configurationBuilder = new ConfigurationBuilder(); configurationBuilder.setUrls(ClasspathHelper.forClassLoader()); configurationBuilder.addUrls(TorchCompilerModule.class.getProtectionDomain().getCodeSource().getLocation()); reflections = new Reflections(configurationBuilder); }
@Override public void searchPackage(String prefix) { parent.searchPackage(prefix); builder.addUrls(ClasspathHelper.forPackage(prefix)); isAnnotationScanningNecessary = true; }
/** * Add ClasspathUrls from MANIFEST Class-Path directive into builder. * * @param builder Reflection ConfigurationBuilder */ private static void addNestedClasspathUrls(final ConfigurationBuilder builder) { final ClassLoader[] cls = ClasspathHelper.classLoaders(builder.getClassLoaders()); builder.addUrls(ClassLoaderUtil.getAlsoNestedClasspathUrls(Arrays.asList(cls))); }
private Reflections createReflections() { Configuration config = new ConfigurationBuilder() .setScanners(new SubTypesScanner()) .addUrls(ClasspathHelper.getUrls()) .filterInputsBy(new FilterBuilder().include(".+\\.class")); return new Reflections(config); }
private Reflections createReflections() { Configuration config = new ConfigurationBuilder() .setScanners(new SubTypesScanner()) .addUrls(ClasspathHelper.getUrls()) .filterInputsBy(new FilterBuilder().include(".+\\.class")); return new Reflections(config); }
@Override public Set<Method> findFunctions(final List<URL> urls) { return new Reflections( new ConfigurationBuilder() .addUrls(urls) .setScanners(new MethodAnnotationsScanner()) .addClassLoader(getClassLoader(urls))) .getMethodsAnnotatedWith(FunctionName.class); }
private static Reflections getReflections(Application app, String packageName) { if (app.isTest()) { return ReflectionsCache$.MODULE$.getReflections(app.classloader(), packageName); } else { return new Reflections( new ConfigurationBuilder() .addUrls(ClasspathHelper.forPackage(packageName, app.classloader())) .filterInputsBy(new FilterBuilder().include(FilterBuilder.prefix(packageName + "."))) .setScanners(new TypesScanner(), new TypeAnnotationsScanner())); } }