How to run "jdeps" command from JDK lib\modules JImage file?

"jdeps" command allows you to shows the package-level or class-level dependencies of Java class files. The input class can be a path name to a .class file or a directory.

"jdeps" command is supported by the jmods\jdk.jdeps.jmod module file, which is also linked into the lib\modules JImage file.

You can run the "jdeps" command using the lib\modules JImage file as described below:

fyicenter> %JDK_HOME%\bin\java --module jdk.jdeps/com.sun.tools.jdeps.Main

Usage: jdeps <options> <path ...>]
<path> can be a pathname to a .class file, a directory, a JAR file.

Possible options include:
  -dotoutput <dir>
  --dot-output <dir>            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 <path>
  -classpath <path>
  --class-path <path>           Specify where to find class files
  --module-path <module path>   Specify module path
  --upgrade-module-path <module path>  Specify upgrade module path
  --system <java-home>          Specify an alternate system module path
  --add-modules <module-name>[,<module-name>...]
                                Adds modules to the root set for analysis
  --multi-release <version>     Specifies the version when processing
                                multi-release jar files.  <version> should
                                be integer >= 9 or base.
  -q       -quiet               Suppress warning messages
  -version --version            Version information

Module dependence analysis options:
  -m <module-name>
  --module <module-name>        Specify the root module for analysis
  --generate-module-info <dir>  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 <dir>  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 <module-name>[,<module-name>...
                                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 JDK internal API packages if referenced.
                                This option does not show dependences on the
                                class path or not found.
  --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.

Options to filter dependences:
  -p <pkg>
  -package <pkg>
  --package <pkg>               Finds dependences matching the given package
                                name (may be given multiple times).
  -e <regex>
  -regex <regex>
  --regex <regex>               Finds dependences matching the given pattern.
  --require <module-name>       Finds dependences matching the given module
                                name (may be given multiple times). --package,
                                --regex, --require are mutual exclusive.
  -f <regex> -filter <regex>    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.

Options to filter classes to be analyzed:
  -include <regex>              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.
  -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.

⇒ jdk.jdeps/com.sun.tools.jdeps.Profile - JDeps Profiler

⇐ jdk.jdeps/com.sun.tools.jdeprscan.Main - "jdeprscan" Command

⇑ Tools Supported from JDK 9+ lib\modules JImage

⇑⇑ FAQ for JDK (Java Development Kit)