jdeps

Java class dependency analyzer.

TLDR

Analyze the dependencies of a .jar or .class file

$ jdeps [path/to/filename.class]

Print a summary of all dependencies of a specific .jar file

$ jdeps [path/to/filename.jar] -summary

Print all class-level dependencies of a .jar file

$ jdeps [path/to/filename.jar] -verbose

Output the results of the analysis in a DOT file into a specific directory

$ jdeps [path/to/filename.jar] -dotoutput [path/to/directory]

Display help

$ jdeps --help

Help

Usage: jdeps  ]
can be a pathname to a .class file, a directory, a JAR file.

Possible options include:
  -h -? --help                  Print this help message
  -dotoutput

  --dot-output             Destination directory for DOT file output
  -s       -summary             Print dependency summary only.
  -v       -verbose             Print all class level dependences
                                Equivalent to -verbose:class -filter:none.
  -verbose:package              Print package-level dependences excluding
                                dependences within the same package by default
  -verbose:class                Print class-level dependences excluding
                                dependences within the same package by default
  -apionly
  --api-only                    Restrict analysis to APIs i.e. dependences
                                from the signature of public and protected
                                members of public classes including field
                                type, method parameter types, returned type,
                                checked exception types etc.
  -jdkinternals
  --jdk-internals               Finds class-level dependences on JDK internal
                                APIs. By default, it analyzes all classes
                                on --class-path and input files unless -include
                                option is specified. This option cannot be
                                used with -p, -e and -s options.
                                WARNING: JDK internal APIs are inaccessible.
  -cp
  -classpath
  --class-path            Specify where to find class files
  --module-path    Specify module path
  --upgrade-module-path   Specify upgrade module path
  --system

Specify an alternate system module path
--add-modules

[,...]
                                Adds modules to the root set for analysis
  --multi-release      Specifies the version when processing
                                multi-release jar files.   should
                                be integer >= 9 or base.
  -q       -quiet               Suppress warning messages
  -version --version            Version information

Module dependence analysis options:
  -m

--module

        Specify the root module for analysis
  --generate-module-info   Generate module-info.java under the specified
                                directory. The specified JAR files will be
                                analyzed. This option cannot be used with
                                --dot-output or --class-path. Use
                                --generate-open-module option for open modules.
  --generate-open-module   Generate module-info.java for the specified
                                JAR files under the specified directory as
                                open modules. This option cannot be used with
                                --dot-output or --class-path.
  --check

[,...
                                Analyze the dependence of the specified modules
                                It prints the module descriptor, the resulting
                                module dependences after analysis and the
                                graph after transition reduction.  It also
                                identifies any unused qualified exports.
  --list-deps                   Lists the module dependences.  It also prints
                                any internal API packages if referenced.
                                This option transitively analyzes libraries on
                                class path and module path if referenced.
                                Use --no-recursive option for non-transitive
                                dependency analysis.
  --list-reduced-deps           Same as --list-deps with not listing
                                the implied reads edges from the module graph.
                                If module M1 reads M2, and M2 requires
                                transitive on M3, then M1 reading M3 is implied
                                and is not shown in the graph.
  --print-module-deps           Same as --list-reduced-deps with printing
                                a comma-separated list of module dependences.
                                This output can be used by jlink --add-modules
                                in order to create a custom image containing
                                those modules and their transitive dependences.
  --ignore-missing-deps         Ignore missing dependences.

Options to filter dependences:
  -p
  -package
  --package                Finds dependences matching the given package
                                name (may be given multiple times).
  -e
  -regex
  --regex                Finds dependences matching the given pattern.
  --require

       Finds dependences matching the given module
                                name (may be given multiple times). --package,
                                --regex, --require are mutual exclusive.
  -f  -filter     Filter dependences matching the given
                                pattern. If given multiple times, the last
                                one will be used.
  -filter:package               Filter dependences within the same package.
                                This is the default.
  -filter:archive               Filter dependences within the same archive.
  -filter:module                Filter dependences within the same module.
  -filter:none                  No -filter:package and -filter:archive
                                filtering.  Filtering specified via the
                                -filter option still applies.

  --missing-deps                Finds missing dependences.  This option
                                cannot be used with -p, -e and -s options.

Options to filter classes to be analyzed:
  -include               Restrict analysis to classes matching pattern
                                This option filters the list of classes to
                                be analyzed.  It can be used together with
                                -p and -e which apply pattern to the dependences
  -P       -profile             Show profile containing a package
  -R
  --recursive                   Recursively traverse all run-time dependences.
                                The -R option implies -filter:none.  If -p,
                                -e, -f option is specified, only the matching
                                dependences are analyzed.
  --no-recursive                Do not recursively traverse dependences.
  -I
  --inverse                     Analyzes the dependences per other given options
                                and then find all artifacts that directly
                                and indirectly depend on the matching nodes.
                                This is equivalent to the inverse of
                                compile-time view analysis and print
                                dependency summary.  This option must use
                                with --require, --package or --regex option.
  --compile-time                Compile-time view of transitive dependences
                                i.e. compile-time view of -R option.
                                Analyzes the dependences per other given options
                                If a dependence is found from a directory,
                                a JAR file or a module, all classes in that
                                containing archive are analyzed.