Package io.github.classgraph

Class ClassGraph

java.lang.Object
io.github.classgraph.ClassGraph
public class ClassGraph extends Object
Uber-fast, ultra-lightweight Java classpath and module path scanner. Scans classfiles in the classpath and/or module path by parsing the classfile binary format directly rather than by using reflection.

Documentation: https://github.com/classgraph/classgraph/wiki

  • Field Details

    • CIRCUMVENT_ENCAPSULATION

      public static ClassGraph.CircumventEncapsulationMethod CIRCUMVENT_ENCAPSULATION
      If you are running on JDK 16+, the JDK enforces strong encapsulation, and ClassGraph may be unable to read the classpath from your classloader if the classloader does not make the classpath available via a public method or field.

      To enable a workaround to this, set this static field to ClassGraph.CircumventEncapsulationMethod.NARCISSUS or ClassGraph.CircumventEncapsulationMethod.JVM_DRIVER before interacting with ClassGraph in any other way, and also include the Narcissus or JVM-Driver library respectively on the classpath or module path.

      Narcissus uses JNI to circumvent encapsulation and field/method access controls. Narcissus employs a native code library, and is currently only compiled for Linux x86/x64, Windows x86/x64, and Mac OS X x64 bit.

      JVM-Driver uses a pure JVM solution to try to circumvent encapsulation and security controls.

  • Constructor Details

    • ClassGraph

      public ClassGraph()
      Construct a ClassGraph instance.

  • Method Details

    • getVersion

      public static String getVersion()
      Get the version number of ClassGraph.
      Returns:
      the ClassGraph version, or "unknown" if it could not be determined.

    • verbose

      public ClassGraph verbose()
      Switches on verbose logging to System.err.
      Returns:
      this (for method chaining).

    • verbose

      public ClassGraph verbose(boolean verbose)
      Switches on verbose logging to System.err if verbose is true.
      Parameters:
      verbose - if true, enable verbose logging.
      Returns:
      this (for method chaining).

    • enableAllInfo

      public ClassGraph enableAllInfo()
      Enables the scanning of all classes, fields, methods, annotations, and static final field constant initializer values, and ignores all visibility modifiers, so that both public and non-public classes, fields and methods are all scanned.

      Calls enableClassInfo(), enableFieldInfo(), enableMethodInfo(), enableAnnotationInfo(), enableStaticFinalFieldConstantInitializerValues(), ignoreClassVisibility(), ignoreFieldVisibility(), and ignoreMethodVisibility().

      Returns:
      this (for method chaining).

    • enableClassInfo

      public ClassGraph enableClassInfo()
      Enables the scanning of classfiles, producing ClassInfo objects in the ScanResult. Implicitly disables enableMultiReleaseVersions().
      Returns:
      this (for method chaining).

    • ignoreClassVisibility

      public ClassGraph ignoreClassVisibility()
      Causes class visibility to be ignored, enabling private, package-private and protected classes to be scanned. By default, only public classes are scanned. (Automatically calls enableClassInfo().)
      Returns:
      this (for method chaining).

    • enableMethodInfo

      public ClassGraph enableMethodInfo()
      Enables the saving of method info during the scan. This information can be obtained using ClassInfo.getMethodInfo() etc. By default, method info is not scanned. (Automatically calls enableClassInfo().)
      Returns:
      this (for method chaining).

    • ignoreMethodVisibility

      public ClassGraph ignoreMethodVisibility()
      Causes method visibility to be ignored, enabling private, package-private and protected methods to be scanned. By default, only public methods are scanned. (Automatically calls enableClassInfo() and enableMethodInfo().)
      Returns:
      this (for method chaining).

    • enableFieldInfo

      public ClassGraph enableFieldInfo()
      Enables the saving of field info during the scan. This information can be obtained using ClassInfo.getFieldInfo(). By default, field info is not scanned. (Automatically calls enableClassInfo().)
      Returns:
      this (for method chaining).

    • ignoreFieldVisibility

      public ClassGraph ignoreFieldVisibility()
      Causes field visibility to be ignored, enabling private, package-private and protected fields to be scanned. By default, only public fields are scanned. (Automatically calls enableClassInfo() and enableFieldInfo().)
      Returns:
      this (for method chaining).

    • enableStaticFinalFieldConstantInitializerValues

      public ClassGraph enableStaticFinalFieldConstantInitializerValues()
      Enables the saving of static final field constant initializer values. By default, constant initializer values are not scanned. If this is enabled, you can obtain the constant field initializer values from FieldInfo.getConstantInitializerValue().

      Note that constant initializer values are usually only of primitive type, or String constants (or values that can be computed and reduced to one of those types at compiletime).

      Also note that it is up to the compiler as to whether or not a constant-valued field is assigned as a constant in the field definition itself, or whether it is assigned manually in static class initializer blocks -- so your mileage may vary in being able to extract constant initializer values.

      In fact in Kotlin, even constant initializers for non-static / non-final fields are stored in a field attribute in the classfile (and so these values may be picked up by ClassGraph by calling this method), although any field initializers for non-static fields are supposed to be ignored by the JVM according to the classfile spec, so the Kotlin compiler may change in future to stop generating these values, and you probably shouldn't rely on being able to get the initializers for non-static fields in Kotlin. (As far as non-final fields, javac simply does not add constant initializer values to the field attributes list for non-final fields, even if they are static, but the spec doesn't say whether or not the JVM should ignore constant initializers for non-final fields.)

      Automatically calls enableClassInfo() and enableFieldInfo().

      Returns:
      this (for method chaining).

    • enableAnnotationInfo

      public ClassGraph enableAnnotationInfo()
      Enables the saving of annotation info (for class, field, method and method parameter annotations) during the scan. This information can be obtained using ClassInfo.getAnnotationInfo(), ClassMemberInfo.getAnnotationInfo(), and MethodParameterInfo.getAnnotationInfo(). By default, annotation info is not scanned. (Automatically calls enableClassInfo().)
      Returns:
      this (for method chaining).

    • enableInterClassDependencies

      public ClassGraph enableInterClassDependencies()
      Enables the determination of inter-class dependencies, which may be read by calling ClassInfo.getClassDependencies(), ScanResult.getClassDependencyMap() or ScanResult.getReverseClassDependencyMap(). (Automatically calls enableClassInfo(), enableFieldInfo(), enableMethodInfo(), enableAnnotationInfo(), ignoreClassVisibility(), ignoreFieldVisibility() and ignoreMethodVisibility().)
      Returns:
      this (for method chaining).

    • disableRuntimeInvisibleAnnotations

      public ClassGraph disableRuntimeInvisibleAnnotations()
      Causes only runtime visible annotations to be scanned (causes runtime invisible annotations to be ignored). (Automatically calls enableClassInfo().)
      Returns:
      this (for method chaining).

    • disableJarScanning

      public ClassGraph disableJarScanning()
      Disables the scanning of jarfiles.
      Returns:
      this (for method chaining).

    • disableNestedJarScanning

      public ClassGraph disableNestedJarScanning()
      Disables the scanning of nested jarfiles (jarfiles within jarfiles).
      Returns:
      this (for method chaining).

    • disableDirScanning

      public ClassGraph disableDirScanning()
      Disables the scanning of directories.
      Returns:
      this (for method chaining).

    • disableModuleScanning

      public ClassGraph disableModuleScanning()
      Disables the scanning of modules.
      Returns:
      this (for method chaining).

    • enableExternalClasses

      public ClassGraph enableExternalClasses()
      Causes ClassGraph to return classes that are not in the accepted packages, but that are directly referred to by classes within accepted packages as a superclass, implemented interface or annotation. (Automatically calls enableClassInfo().)
      Returns:
      this (for method chaining).

    • initializeLoadedClasses

      public ClassGraph initializeLoadedClasses()
      Causes classes loaded using ClassInfo.loadClass() to be are initialized after class loading (the default is to not initialize classes).
      Returns:
      this (for method chaining).

    • removeTemporaryFilesAfterScan

      public ClassGraph removeTemporaryFilesAfterScan()
      Remove temporary files, including nested jarfiles (jarfiles within jarfiles, which have to be extracted during scanning in order to be read) from their temporary directory as soon as the scan has completed. The default is for temporary files to be removed by the ScanResult finalizer, or on JVM exit.
      Returns:
      this (for method chaining).

    • overrideClasspath

      public ClassGraph overrideClasspath(String overrideClasspath)
      Override the automatically-detected classpath with a custom path, with path elements separated by File.pathSeparatorChar. Causes system ClassLoaders and the java.class.path system property to be ignored. Also causes modules not to be scanned.

      If this method is called, nothing but the provided classpath will be scanned, i.e. this causes ClassLoaders to be ignored, as well as the java.class.path system property.

      Parameters:
      overrideClasspath - The custom classpath to use for scanning, with path elements separated by File.pathSeparatorChar.
      Returns:
      this (for method chaining).

    • overrideClasspath

      public ClassGraph overrideClasspath(Iterable<?> overrideClasspathElements)
      Override the automatically-detected classpath with a custom path. Causes system ClassLoaders and the java.class.path system property to be ignored. Also causes modules not to be scanned.

      Works for Iterables of any type whose toString() method resolves to a classpath element string, e.g. String, File or Path.

      Parameters:
      overrideClasspathElements - The custom classpath to use for scanning, with path elements separated by File.pathSeparatorChar.
      Returns:
      this (for method chaining).

    • overrideClasspath

      public ClassGraph overrideClasspath(Object... overrideClasspathElements)
      Override the automatically-detected classpath with a custom path. Causes system ClassLoaders and the java.class.path system property to be ignored. Also causes modules not to be scanned.

      Works for arrays of any member type whose toString() method resolves to a classpath element string, e.g. String, File or Path.

      Parameters:
      overrideClasspathElements - The custom classpath to use for scanning, with path elements separated by File.pathSeparatorChar.
      Returns:
      this (for method chaining).

    • filterClasspathElements

      public ClassGraph filterClasspathElements(ClassGraph.ClasspathElementFilter classpathElementFilter)
      Add a classpath element filter. The provided ClasspathElementFilter should return true if the path string passed to it is a path you want to scan.
      Parameters:
      classpathElementFilter - The filter function to use. This function should return true if the classpath element path should be scanned, and false if not.
      Returns:
      this (for method chaining).

    • filterClasspathElementsByURL

      public ClassGraph filterClasspathElementsByURL(ClassGraph.ClasspathElementURLFilter classpathElementURLFilter)
      Add a classpath element filter. The provided ClasspathElementFilter should return true if the URL passed to it is a URL you want to scan.
      Parameters:
      classpathElementURLFilter - The filter function to use. This function should return true if the classpath element URL should be scanned, and false if not.
      Returns:
      this (for method chaining).

    • addClassLoader

      public ClassGraph addClassLoader(ClassLoader classLoader)
      Add a ClassLoader to the list of ClassLoaders to scan.

      This call is ignored if overrideClasspath(String) is also called, or if this method is called before overrideClassLoaders(ClassLoader...).

      Parameters:
      classLoader - The additional ClassLoader to scan.
      Returns:
      this (for method chaining).

    • overrideClassLoaders

      public ClassGraph overrideClassLoaders(ClassLoader... overrideClassLoaders)
      Completely override (and ignore) system ClassLoaders and the java.class.path system property. Also causes modules not to be scanned. Note that you may want to use this together with ignoreParentClassLoaders() to extract classpath URLs from only the classloaders you specified in the parameter to `overrideClassLoaders`, and not their parent classloaders.

      This call is ignored if overrideClasspath(String) is called.

      Parameters:
      overrideClassLoaders - The ClassLoaders to scan instead of the automatically-detected ClassLoaders.
      Returns:
      this (for method chaining).

    • ignoreParentClassLoaders

      public ClassGraph ignoreParentClassLoaders()
      Ignore parent classloaders (i.e. only obtain paths to scan from classloaders that are not the parent of another classloader).
      Returns:
      this (for method chaining).

    • addModuleLayer

      public ClassGraph addModuleLayer(Object moduleLayer)
      Add a ModuleLayer to the list of ModuleLayers to scan. Use this method if you define your own ModuleLayer, but the scanning code is not running within that custom ModuleLayer.

      This call is ignored if it is called before overrideModuleLayers(Object...).

      Parameters:
      moduleLayer - The additional ModuleLayer to scan. (The parameter is of type Object for backwards compatibility with JDK 7 and JDK 8, but the argument should be of type ModuleLayer.)
      Returns:
      this (for method chaining).

    • overrideModuleLayers

      public ClassGraph overrideModuleLayers(Object... overrideModuleLayers)
      Completely override (and ignore) the visible ModuleLayers, and instead scan the requested ModuleLayers.

      This call is ignored if overrideClasspath() is called.

      Parameters:
      overrideModuleLayers - The ModuleLayers to scan instead of the automatically-detected ModuleLayers. (The parameter is of type Object[] for backwards compatibility with JDK 7 and JDK 8, but the argument should be of type ModuleLayer[].)
      Returns:
      this (for method chaining).

    • ignoreParentModuleLayers

      public ClassGraph ignoreParentModuleLayers()
      Ignore parent module layers (i.e. only scan module layers that are not the parent of another module layer).
      Returns:
      this (for method chaining).

    • acceptPackages

      public ClassGraph acceptPackages(String... packageNames)
      Scan one or more specific packages and their sub-packages.

      N.B. Automatically calls enableClassInfo() -- call acceptPaths(String...) instead if you only need to scan resources.

      Parameters:
      packageNames - The fully-qualified names of packages to scan (using '.' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • whitelistPackages

      @Deprecated public ClassGraph whitelistPackages(String... packageNames)
      Deprecated.
      Use acceptPackages(String...) instead.
      Use acceptPackages(String...) instead.
      Parameters:
      packageNames - The fully-qualified names of packages to scan (using '.' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • acceptPaths

      public ClassGraph acceptPaths(String... paths)
      Scan one or more specific paths, and their sub-directories or nested paths.
      Parameters:
      paths - The paths to scan, relative to the package root of the classpath element (with '/' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • whitelistPaths

      @Deprecated public ClassGraph whitelistPaths(String... paths)
      Deprecated.
      Use acceptPaths(String...) instead.
      Use acceptPaths(String...) instead.
      Parameters:
      paths - The paths to scan, relative to the package root of the classpath element (with '/' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • acceptPackagesNonRecursive

      public ClassGraph acceptPackagesNonRecursive(String... packageNames)
      Scan one or more specific packages, without recursively scanning sub-packages unless they are themselves accepted.

      N.B. Automatically calls enableClassInfo() -- call acceptPathsNonRecursive(String...) instead if you only need to scan resources.

      This may be particularly useful for scanning the package root ("") without recursively scanning everything in the jar, dir or module.

      Parameters:
      packageNames - The fully-qualified names of packages to scan (with '.' as a separator). May not include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • whitelistPackagesNonRecursive

      @Deprecated public ClassGraph whitelistPackagesNonRecursive(String... packageNames)
      Deprecated.
      Use acceptPackagesNonRecursive(String...) instead.
      Use acceptPackagesNonRecursive(String...) instead.
      Parameters:
      packageNames - The fully-qualified names of packages to scan (with '.' as a separator). May not include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • acceptPathsNonRecursive

      public ClassGraph acceptPathsNonRecursive(String... paths)
      Scan one or more specific paths, without recursively scanning sub-directories or nested paths unless they are themselves accepted.

      This may be particularly useful for scanning the package root ("") without recursively scanning everything in the jar, dir or module.

      Parameters:
      paths - The paths to scan, relative to the package root of the classpath element (with '/' as a separator). May not include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • whitelistPathsNonRecursive

      @Deprecated public ClassGraph whitelistPathsNonRecursive(String... paths)
      Deprecated.
      Use acceptPathsNonRecursive(String...) instead.
      Use acceptPathsNonRecursive(String...) instead.
      Parameters:
      paths - The paths to scan, relative to the package root of the classpath element (with '/' as a separator). May not include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • rejectPackages

      public ClassGraph rejectPackages(String... packageNames)
      Prevent the scanning of one or more specific packages and their sub-packages.

      N.B. Automatically calls enableClassInfo() -- call rejectPaths(String...) instead if you only need to scan resources.

      Parameters:
      packageNames - The fully-qualified names of packages to reject (with '.' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • blacklistPackages

      @Deprecated public ClassGraph blacklistPackages(String... packageNames)
      Deprecated.
      Use rejectPackages(String...) instead.
      Use rejectPackages(String...) instead.
      Parameters:
      packageNames - The fully-qualified names of packages to reject (with '.' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • rejectPaths

      public ClassGraph rejectPaths(String... paths)
      Prevent the scanning of one or more specific paths and their sub-directories / nested paths.
      Parameters:
      paths - The paths to reject (with '/' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • blacklistPaths

      @Deprecated public ClassGraph blacklistPaths(String... paths)
      Deprecated.
      Use rejectPaths(String...) instead.
      Use rejectPaths(String...) instead.
      Parameters:
      paths - The paths to reject (with '/' as a separator). May include a glob wildcard ('*').
      Returns:
      this (for method chaining).

    • acceptClasses

      public ClassGraph acceptClasses(String... classNames)
      Scan one or more specific classes, without scanning other classes in the same package unless the package is itself accepted.

      N.B. Automatically calls enableClassInfo().

      Parameters:
      classNames - The fully-qualified names of classes to scan (using '.' as a separator). To match a class name by glob in any package, you must include a package glob too, e.g. "*.*Suffix".
      Returns:
      this (for method chaining).

    • whitelistClasses

      @Deprecated public ClassGraph whitelistClasses(String... classNames)
      Deprecated.
      Use acceptClasses(String...) instead.
      Use acceptClasses(String...) instead.
      Parameters:
      classNames - The fully-qualified names of classes to scan (using '.' as a separator).
      Returns:
      this (for method chaining).

    • rejectClasses

      public ClassGraph rejectClasses(String... classNames)
      Specifically reject one or more specific classes, preventing them from being scanned even if they are in a accepted package.

      N.B. Automatically calls enableClassInfo().

      Parameters:
      classNames - The fully-qualified names of classes to reject (using '.' as a separator). To match a class name by glob in any package, you must include a package glob too, e.g. "*.*Suffix".
      Returns:
      this (for method chaining).

    • blacklistClasses

      @Deprecated public ClassGraph blacklistClasses(String... classNames)
      Deprecated.
      Use rejectClasses(String...) instead.
      Use rejectClasses(String...) instead.
      Parameters:
      classNames - The fully-qualified names of classes to reject (using '.' as a separator).
      Returns:
      this (for method chaining).

    • acceptJars

      public ClassGraph acceptJars(String... jarLeafNames)
      Accept one or more jars. This will cause only the accepted jars to be scanned.
      Parameters:
      jarLeafNames - The leafnames of the jars that should be scanned (e.g. "mylib.jar"). May contain a wildcard glob ("mylib-*.jar").
      Returns:
      this (for method chaining).

    • whitelistJars

      @Deprecated public ClassGraph whitelistJars(String... jarLeafNames)
      Deprecated.
      Use acceptJars(String...) instead.
      Use acceptJars(String...) instead.
      Parameters:
      jarLeafNames - The leafnames of the jars that should be scanned (e.g. "mylib.jar"). May contain a wildcard glob ("mylib-*.jar").
      Returns:
      this (for method chaining).

    • rejectJars

      public ClassGraph rejectJars(String... jarLeafNames)
      Reject one or more jars, preventing them from being scanned.
      Parameters:
      jarLeafNames - The leafnames of the jars that should be scanned (e.g. "badlib.jar"). May contain a wildcard glob ("badlib-*.jar").
      Returns:
      this (for method chaining).

    • blacklistJars

      @Deprecated public ClassGraph blacklistJars(String... jarLeafNames)
      Deprecated.
      Use rejectJars(String...) instead.
      Use rejectJars(String...) instead.
      Parameters:
      jarLeafNames - The leafnames of the jars that should be scanned (e.g. "badlib.jar"). May contain a wildcard glob ("badlib-*.jar").
      Returns:
      this (for method chaining).

    • acceptLibOrExtJars

      public ClassGraph acceptLibOrExtJars(String... jarLeafNames)
      Accept one or more jars in a JRE/JDK "lib/" or "ext/" directory (these directories are not scanned unless enableSystemJarsAndModules() is called, by association with the JRE/JDK).
      Parameters:
      jarLeafNames - The leafnames of the lib/ext jar(s) that should be scanned (e.g. "mylib.jar"). May contain a wildcard glob ('*'). Note that if you call this method with no parameters, all JRE/JDK "lib/" or "ext/" jars will be accepted.
      Returns:
      this (for method chaining).

    • whitelistLibOrExtJars

      @Deprecated public ClassGraph whitelistLibOrExtJars(String... jarLeafNames)
      Deprecated.
      Use acceptLibOrExtJars(String...) instead.
      Use acceptLibOrExtJars(String...) instead.
      Parameters:
      jarLeafNames - The leafnames of the lib/ext jar(s) that should be scanned (e.g. "mylib.jar"). May contain a wildcard glob ('*'). Note that if you call this method with no parameters, all JRE/JDK "lib/" or "ext/" jars will be accepted.
      Returns:
      this (for method chaining).

    • rejectLibOrExtJars

      public ClassGraph rejectLibOrExtJars(String... jarLeafNames)
      Reject one or more jars in a JRE/JDK "lib/" or "ext/" directory, preventing them from being scanned.
      Parameters:
      jarLeafNames - The leafnames of the lib/ext jar(s) that should not be scanned (e.g. "jre/lib/badlib.jar"). May contain a wildcard glob ('*'). If you call this method with no parameters, all JRE/JDK "lib/" or "ext/" jars will be rejected.
      Returns:
      this (for method chaining).

    • blacklistLibOrExtJars

      @Deprecated public ClassGraph blacklistLibOrExtJars(String... jarLeafNames)
      Deprecated.
      Use rejectLibOrExtJars(String...) instead.
      Use rejectLibOrExtJars(String...) instead.
      Parameters:
      jarLeafNames - The leafnames of the lib/ext jar(s) that should not be scanned (e.g. "jre/lib/badlib.jar"). May contain a wildcard glob ('*'). If you call this method with no parameters, all JRE/JDK "lib/" or "ext/" jars will be rejected.
      Returns:
      this (for method chaining).

    • acceptModules

      public ClassGraph acceptModules(String... moduleNames)
      Accept one or more modules for scanning.
      Parameters:
      moduleNames - The names of the modules that should be scanned. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • whitelistModules

      @Deprecated public ClassGraph whitelistModules(String... moduleNames)
      Deprecated.
      Use acceptModules(String...) instead.
      Use acceptModules(String...) instead.
      Parameters:
      moduleNames - The names of the modules that should be scanned. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • rejectModules

      public ClassGraph rejectModules(String... moduleNames)
      Reject one or more modules, preventing them from being scanned.
      Parameters:
      moduleNames - The names of the modules that should not be scanned. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • blacklistModules

      @Deprecated public ClassGraph blacklistModules(String... moduleNames)
      Deprecated.
      Use rejectModules(String...) instead.
      Use rejectModules(String...) instead.
      Parameters:
      moduleNames - The names of the modules that should not be scanned. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • acceptClasspathElementsContainingResourcePath

      public ClassGraph acceptClasspathElementsContainingResourcePath(String... resourcePaths)
      Accept classpath elements based on resource paths. Only classpath elements that contain resources with paths matching the accept will be scanned.
      Parameters:
      resourcePaths - The resource paths, any of which must be present in a classpath element for the classpath element to be scanned. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • whitelistClasspathElementsContainingResourcePath

      @Deprecated public ClassGraph whitelistClasspathElementsContainingResourcePath(String... resourcePaths)
      Deprecated.
      Use acceptClasspathElementsContainingResourcePath(String...) instead.
      Use acceptClasspathElementsContainingResourcePath(String...) instead.
      Parameters:
      resourcePaths - The resource paths, any of which must be present in a classpath element for the classpath element to be scanned. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • rejectClasspathElementsContainingResourcePath

      public ClassGraph rejectClasspathElementsContainingResourcePath(String... resourcePaths)
      Reject classpath elements based on resource paths. Classpath elements that contain resources with paths matching the reject will not be scanned.
      Parameters:
      resourcePaths - The resource paths which cause a classpath not to be scanned if any are present in a classpath element for the classpath element. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • blacklistClasspathElementsContainingResourcePath

      @Deprecated public ClassGraph blacklistClasspathElementsContainingResourcePath(String... resourcePaths)
      Deprecated.
      Use rejectClasspathElementsContainingResourcePath(String...) instead.
      Use rejectClasspathElementsContainingResourcePath(String...) instead.
      Parameters:
      resourcePaths - The resource paths which cause a classpath not to be scanned if any are present in a classpath element for the classpath element. May contain a wildcard glob ('*').
      Returns:
      this (for method chaining).

    • enableRemoteJarScanning

      public ClassGraph enableRemoteJarScanning()
      Enable classpath elements to be fetched from remote ("http:"/"https:") URLs (or URLs with custom schemes). Equivalent to:

      new ClassGraph().enableURLScheme("http").enableURLScheme("https");

      Scanning from http(s) URLs is disabled by default, as this may present a security vulnerability, since classes from downloaded jars can be subsequently loaded using ClassInfo.loadClass(java.lang.Class<T>, boolean).

      Returns:
      this (for method chaining).

    • enableURLScheme

      public ClassGraph enableURLScheme(String scheme)
      Enable classpath elements to be fetched from URL connections with the specified URL scheme (also works for any custom URL schemes that have been defined, as long as they have more than two characters, in order to not conflict with Windows drive letters).
      Parameters:
      scheme - the URL scheme string, e.g. "resource" for a custom "resource:" URL scheme.
      Returns:
      this (for method chaining).

    • enableSystemJarsAndModules

      public ClassGraph enableSystemJarsAndModules()
      Enables the scanning of system packages ("java.*", "javax.*", "javafx.*", "jdk.*", "oracle.*", "sun.*") -- these are not scanned by default for speed.

      N.B. Automatically calls enableClassInfo().

      Returns:
      this (for method chaining).

    • setMaxBufferedJarRAMSize

      public ClassGraph setMaxBufferedJarRAMSize(int maxBufferedJarRAMSize)
      The maximum size of an inner (nested) jar that has been deflated (i.e. compressed, not stored) within an outer jar, before it has to be spilled to disk rather than stored in a RAM-backed ByteBuffer when it is deflated, in order for the inner jar's entries to be read. (Note that this situation of having to deflate a nested jar to RAM or disk in order to read it is rare, because normally adding a jarfile to another jarfile will store the inner jar, rather than deflate it, because deflating a jarfile does not usually produce any further compression gains. If an inner jar is stored, not deflated, then its zip entries can be read directly using ClassGraph's own zipfile central directory parser, which can use file slicing to extract entries directly from stored nested jars.)

      This is also the maximum size of a jar downloaded from an http:// or https:// classpath URL to RAM. Once this many bytes have been read from the URL's InputStream, then the RAM contents are spilled over to a temporary file on disk, and the rest of the content is downloaded to the temporary file. (This is also rare, because normally there are no http:// or https:// classpath entries.)

      Default: 64MB (i.e. writing to disk is avoided wherever possible). Setting a lower max RAM size value will decrease ClassGraph's memory usage if either of the above rare situations occurs.

      Parameters:
      maxBufferedJarRAMSize - The max RAM size to use for deflated inner jars or downloaded jars. This is the limit per jar, not for the whole classpath.
      Returns:
      this (for method chaining).

    • enableMemoryMapping

      public ClassGraph enableMemoryMapping()
      If true, use a MappedByteBuffer rather than the FileChannel API to open files, which may be faster for large classpaths consisting of many large jarfiles, but uses up virtual memory space.
      Returns:
      this (for method chaining).

    • enableMultiReleaseVersions

      public ClassGraph enableMultiReleaseVersions()
      If true, provide all versions of a multi-release resource using their multi-release path prefix, instead of just the one the running JVM would select. Implicitly disables enableClassInfo() and all features depending on it.
      Returns:
      this (for method chaining).

    • enableRealtimeLogging

      public ClassGraph enableRealtimeLogging()
      Enables logging by calling verbose(), and then sets the logger to "realtime logging mode", where log entries are written out immediately to stderr, rather than only after the scan has completed. Can help to identify problems where scanning is stuck in a loop, or where one scanning step is taking much longer than it should, etc.
      Returns:
      this (for method chaining).

    • scanAsync

      public void scanAsync(ExecutorService executorService, int numParallelTasks, ClassGraph.ScanResultProcessor scanResultProcessor, ClassGraph.FailureHandler failureHandler)
      Asynchronously scans the classpath, calling a ClassGraph.ScanResultProcessor callback on success or a ClassGraph.FailureHandler callback on failure.
      Parameters:
      executorService - A custom ExecutorService to use for scheduling worker tasks.
      numParallelTasks - The number of parallel tasks to break the work into during the most CPU-intensive stage of classpath scanning. Ideally the ExecutorService will have at least this many threads available.
      scanResultProcessor - A ClassGraph.ScanResultProcessor callback to run on successful scan.
      failureHandler - A ClassGraph.FailureHandler callback to run on failed scan. This is passed any Throwable thrown during the scan.

    • scanAsync

      public Future<ScanResult> scanAsync(ExecutorService executorService, int numParallelTasks)
      Asynchronously scans the classpath for matching files, returning a Future<ScanResult>. You should assign the wrapped ScanResult in a try-with-resources statement, or manually close it when you are finished with it.
      Parameters:
      executorService - A custom ExecutorService to use for scheduling worker tasks.
      numParallelTasks - The number of parallel tasks to break the work into during the most CPU-intensive stage of classpath scanning. Ideally the ExecutorService will have at least this many threads available.
      Returns:
      a Future<ScanResult>, that when resolved using get() yields a new ScanResult object representing the result of the scan.

    • scan

      public ScanResult scan(ExecutorService executorService, int numParallelTasks)
      Scans the classpath using the requested ExecutorService and the requested degree of parallelism, blocking until the scan is complete. You should assign the returned ScanResult in a try-with-resources statement, or manually close it when you are finished with it.
      Parameters:
      executorService - A custom ExecutorService to use for scheduling worker tasks. This ExecutorService should start tasks in FIFO order to avoid a deadlock during scan, i.e. be sure to construct the ExecutorService with a LinkedBlockingQueue as its task queue. (This is the default for Executors.newFixedThreadPool(int).)
      numParallelTasks - The number of parallel tasks to break the work into during the most CPU-intensive stage of classpath scanning. Ideally the ExecutorService will have at least this many threads available.
      Returns:
      a ScanResult object representing the result of the scan.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • scan

      public ScanResult scan(int numThreads)
      Scans the classpath with the requested number of threads, blocking until the scan is complete. You should assign the returned ScanResult in a try-with-resources statement, or manually close it when you are finished with it.
      Parameters:
      numThreads - The number of worker threads to start up.
      Returns:
      a ScanResult object representing the result of the scan.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • scan

      public ScanResult scan()
      Scans the classpath, blocking until the scan is complete. You should assign the returned ScanResult in a try-with-resources statement, or manually close it when you are finished with it.
      Returns:
      a ScanResult object representing the result of the scan.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • getClasspathFiles

      public List<File> getClasspathFiles()
      Returns the list of all unique File objects representing directories or zip/jarfiles on the classpath, in classloader resolution order. Classpath elements that do not exist as a file or directory are not included in the returned list.
      Returns:
      a List<File> consisting of the unique directories and jarfiles on the classpath, in classpath resolution order.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • getClasspath

      public String getClasspath()
      Returns the list of all unique File objects representing directories or zip/jarfiles on the classpath, in classloader resolution order, in the form of a classpath path string. Classpath elements that do not exist as a file or directory are not included in the returned list. Note that the returned string contains only base files, and does not include package roots or nested jars within jars, since the path separator (':') conflicts with the URL scheme separator character (also ':') on Linux and Mac OS X. Call getClasspathURIs() to get the full URIs for classpath elements and modules.
      Returns:
      a classpath path string consisting of the unique directories and jarfiles on the classpath, in classpath resolution order.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • getClasspathURIs

      public List<URI> getClasspathURIs()
      Returns the ordered list of all unique URI objects representing directory/jar classpath elements and modules. Classpath elements representing jarfiles or directories that do not exist are not included in the returned list.
      Returns:
      the unique classpath elements and modules, as a list of URI objects.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • getClasspathURLs

      public List<URL> getClasspathURLs()
      Returns the ordered list of all unique URL objects representing directory/jar classpath elements and modules. Classpath elements representing jarfiles or directories that do not exist, as well as modules with unknown (null) location or with jrt: location URI scheme, are not included in the returned list.
      Returns:
      the unique classpath elements and modules, as a list of URL objects.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • getModules

      public List<ModuleRef> getModules()
      Returns ModuleRef references for all the visible modules.
      Returns:
      a list of ModuleRef references for all the visible modules.
      Throws:
      ClassGraphException - if any of the worker threads throws an uncaught exception, or the scan was interrupted.

    • getModulePathInfo

      public ModulePathInfo getModulePathInfo()
      Get the module path info provided on the commandline with --module-path, --add-modules, --patch-module, --add-exports, --add-opens, and --add-reads.

      Note that the returned ModulePathInfo object does not include classpath entries from the traditional classpath or system modules. Use getModules() to get all visible modules, including anonymous, automatic and system modules.

      Also, ModulePathInfo.addExports and ModulePathInfo.addOpens will not contain Add-Exports or Add-Opens entries from jarfile manifest files encountered during scanning, unless you obtain the ModulePathInfo by calling ScanResult.getModulePathInfo() rather than by calling getModulePathInfo() before scan().

      Returns:
      The ModulePathInfo.