public ClasspathScanLoadHelper(Collection<String> packagesToScan) { scanResult = new ClassGraph().whitelistPackages(packagesToScan.toArray(new String[] {})) .enableClassInfo() .enableAnnotationInfo().scan(); }
public Collection<String> findFunctionsInJar(File jarFile) throws IOException { ClassGraph fastClasspathScanner = new ClassGraph().disableDirScanning() .removeTemporaryFilesAfterScan().overrideClasspath(jarFile.getAbsolutePath()); ScanResult scanResult = fastClasspathScanner.enableClassInfo().scan(); Set<String> functionClasses = new HashSet<>(); functionClasses.addAll(scanResult.getClassesImplementing(Function.class.getName()).getNames()); functionClasses.addAll(scanResult.getSubclasses(FunctionAdapter.class.getName()).getNames()); return functionClasses; } }
public Set<Class<?>> scanPackagesForClassesImplementing(Class<?> implementedInterface, String... onlyFromPackages) { ClassInfoList classInfoList = scanResult.getClassesImplementing(implementedInterface.getName()) .filter(ci -> !ci.isAbstract() && !ci.isInterface() && ci.isPublic()); classInfoList = classInfoList .filter(ci -> Arrays.stream(onlyFromPackages) .anyMatch(p -> classMatchesPackage(ci.getName(), p))); return classInfoList.loadClasses().stream().collect(toSet()); }
public ClasspathScanningPrimitiveTypeRegistry(ClassLoader classLoader) { Map<String, PrimitiveType> types = CACHE.computeIfAbsent(classLoader, cl -> { final Map<String, PrimitiveType> result = new ConcurrentHashMap<>(); final String[] whitelistPackages = StringUtils.split(System.getProperty("io.atomix.whitelistPackages"), ","); final ClassGraph classGraph = whitelistPackages != null ? new ClassGraph().enableClassInfo().whitelistPackages(whitelistPackages).addClassLoader(classLoader) : new ClassGraph().enableClassInfo().addClassLoader(classLoader); try (final ScanResult scanResult = classGraph.scan()) { scanResult.getClassesImplementing(PrimitiveType.class.getName()).forEach(classInfo -> { if (classInfo.isInterface() || classInfo.isAbstract() || Modifier.isPrivate(classInfo.getModifiers())) { return; } final PrimitiveType primitiveType = newInstance(classInfo.loadClass()); final PrimitiveType oldPrimitiveType = result.put(primitiveType.name(), primitiveType); if (oldPrimitiveType != null) { LOGGER.warn("Found multiple primitives types name={}, classes=[{}, {}]", primitiveType.name(), oldPrimitiveType.getClass().getName(), primitiveType.getClass().getName()); } }); } return Collections.unmodifiableMap(result); }); primitiveTypes.putAll(types); }
ClassGraph scanner = new ClassGraph().enableAllInfo() .whitelistPackages(spec.toArray(new String[spec.size()])); ScanResult result = scanner.scan(); .anyMatch(c.getName()::startsWith); result.getClassesWithAnnotation(Path.class.getName()) .stream() .filter(once) .map(ClassInfo::getName) result.getSubclasses(Jooby.class.getName()) .stream() .filter(once) .map(ClassInfo::getName) .forEach(a -> result.getClassesWithAnnotation(a.getName()) .stream() .filter(once) .map(ClassInfo::getName) .filter(I) .filter(type -> type != Jooby.Module.class && type != Module.class && type != Service.class) .forEach(i -> result.getClassesImplementing(i.getName()) .stream() .filter(inPackage) .filter(once)
@Override public List<String> getClassNamesForClasspath(URL[] urls) { try (ScanResult scan = new ClassGraph() .disableNestedJarScanning() .enableClassInfo() .ignoreClassVisibility() .overrideClasspath(urls) .scan()) { return scan.getAllClasses().getNames(); } }
final String[] whitelistPackages = StringUtils.split(System.getProperty("io.atomix.whitelistPackages"), ","); final ClassGraph classGraph = whitelistPackages != null ? new ClassGraph().enableAnnotationInfo().whitelistPackages(whitelistPackages).addClassLoader(classLoader) : new ClassGraph().enableAnnotationInfo().addClassLoader(classLoader); try (final ScanResult scanResult = classGraph.scan()) { scanResult.getClassesWithAnnotation(AtomixResource.class.getName()).forEach(classInfo -> { deployment.getRegistry().addPerInstanceResource(classInfo.loadClass(), "/v1"); });
private static <T> List<Class<?>> searchForPublicConcreteSubTypesOf(final Class<T> type) { String typeName = type.getCanonicalName(); ClassInfoList subTypes = type.isInterface() ? scanResult.getClassesImplementing(typeName) : scanResult.getSubclasses(typeName); List<Class<?>> loadedSubTypes = subTypes.filter(subType -> subType.isPublic() && !subType.isAbstract()).loadClasses(true); return Collections.unmodifiableList(loadedSubTypes); } }
public Set<Class<?>> scanClasspathForAnnotation(Class<?> annotation, String... onlyFromPackages) { ClassInfoList classInfoList = scanResult.getClassesWithAnnotation(annotation.getName()); classInfoList = classInfoList .filter(ci -> Arrays.stream(onlyFromPackages) .anyMatch(p -> classMatchesPackage(ci.getName(), p))); return classInfoList.loadClasses().stream().collect(toSet()); }
/** * Get all annotation classes found during the scan. See also * {@link #getAllInterfacesOrAnnotationClasses(Collection, ScanSpec, ScanResult)} ()}. * * @return A list of all annotation classes found during the scan, or the empty list if none. */ static ClassInfoList getAllAnnotationClasses(final Collection<ClassInfo> classes, final ScanSpec scanSpec, final ScanResult scanResult) { return new ClassInfoList( ClassInfo.filterClassInfo(classes, scanSpec, /* strictWhitelist = */ true, ClassType.ANNOTATION), /* sortByName = */ true); }
/** * @param annotationName * The name of an annotation. * @return true if this field has the named annotation. */ public boolean hasAnnotation(final String annotationName) { return getAnnotationInfo().containsName(annotationName); }
@Override void setScanResult(final ScanResult scanResult) { super.setScanResult(scanResult); if (value != null) { value.setScanResult(scanResult); } }
/** * @param annotationName * The name of an annotation. * @return true if this method has the named annotation. */ public boolean hasAnnotation(final String annotationName) { return getAnnotationInfo().containsName(annotationName); }
/** * @param superclassName * The name of a superclass. * @return true if this class extends the named superclass. */ public boolean extendsSuperclass(final String superclassName) { return getSuperclasses().containsName(superclassName); }
/** * Get a the named annotation on this module, or null if the module does not have the named annotation. * * @param annotationName * The annotation name. * @return An {@link AnnotationInfo} object representing the named annotation on this module, or null if the * module does not have the named annotation. */ public AnnotationInfo getAnnotationInfo(final String annotationName) { return getAnnotationInfo().get(annotationName); }
@Override void setScanResult(final ScanResult scanResult) { super.setScanResult(scanResult); if (elementTypeSignature != null) { elementTypeSignature.setScanResult(scanResult); } }
@SuppressWarnings("unchecked") private ClasspathScanningRegistry(ClassLoader classLoader, Set<String> whitelistPackages) { final Map<Class<? extends NamedType>, Map<String, NamedType>> registrations = CACHE.computeIfAbsent(classLoader, cl -> { final ClassGraph classGraph = !whitelistPackages.isEmpty() ? new ClassGraph().enableClassInfo().whitelistPackages(whitelistPackages.toArray(new String[0])).addClassLoader(classLoader) : new ClassGraph().enableClassInfo().addClassLoader(classLoader); try (final ScanResult scanResult = classGraph.scan()) { final Map<Class<? extends NamedType>, Map<String, NamedType>> result = new ConcurrentHashMap<>(); scanResult.getClassesImplementing(NamedType.class.getName()).forEach(classInfo -> { if (classInfo.isInterface() || classInfo.isAbstract() || Modifier.isPrivate(classInfo.getModifiers())) { return; } final Class<?> type = classInfo.loadClass(); final Class<? extends NamedType> classType = getClassType(type); final NamedType instance = newInstance(type); final NamedType oldInstance = result.computeIfAbsent(classType, t -> new HashMap<>()).put(instance.name(), instance); if (oldInstance != null) { LOGGER.warn("Found multiple types with name={}, classes=[{}, {}]", instance.name(), oldInstance.getClass().getName(), instance.getClass().getName()); } }); return result; } }); this.registrations.putAll(registrations); }
@Override public List<String> getClassNamesForClasspath(URL[] urls) { try (ScanResult scan = new ClassGraph() .disableNestedJarScanning() .enableClassInfo() .ignoreClassVisibility() .overrideClasspath(urls) .scan()) { return scan.getAllClasses().getNames(); } }
/** * @return The list of classes that are directly (i.e. are not meta-annotated) annotated with the requested * annotation, or the empty list if none. */ ClassInfoList getClassesWithAnnotationDirectOnly() { return new ClassInfoList( this.filterClassInfo(RelType.CLASSES_WITH_ANNOTATION, /* strictWhitelist = */ !isExternalClass), /* sortByName = */ true); }