Compiling Java Modules from Command Line

If you want to check your IDE whether it handles Java modules accurately, then you need to do a command line compilation and see what the JDK's javac compiler says. But how to do this?

Compilation Commands

Since Java 9, the javac compiler supports two kinds of module compilations: single- and multi-module.

Single Module

When your terminal window stands above the module's root directory fri.i18n.messages, following command-line would compile the module's classes into the target directory given by the -d option, in this case I named it module-classes:

The --module-path option (also -p) is necessary only when the module depends on other modules that were already compiled into module-classes. It tells the compiler where to search for referenced modules, being the future replacement for CLASSPATH.

The -d option gives the output directory where to write compiled classes into. In this case the name of the module (fri.i18n.messages) must be appended to achieve a correct output path.

The find command is available on UNIX systems only, on WINDOWS you have to download and install it. It searches all .java files inside the fri.i18n.messages directory. The `backquotes` are a UNIX-shell mechanism that puts the output of the find command into the javac command line. (Not a good solution, because the list of sources could get huge. See below for a better way to pass sources to the compiler. The new --module-source-path option was not made for this!)

Multiple Modules

A certain directory structure is required to compile several modules in one run. All modules must be located below a directory that is given as --module-source-path, in this case I named it module-sources. Each module's sources are in a directory below that is named like the module. Mind that this name is duplicated in module-info.java!

You can compile all modules contained in module-sources by following command line:

Again the --module-path option could be left out when the modules do not depend on precompiled modules.

The --module-source-path option points to the directory where the module directories are below, in this case it is module-sources.

Mind that I didn't have to put any module name into the command line, like I had to do for a single module compilation.

Huge List of Sources

Putting the find command as substitution into the javac command line is not a real-world solution. Most projects have tons of source files, and the shell command buffer may get out of bounds. There is an option to replace the list of sources by a file name tagged with '@'. You would let the find command write into a file, and then pass the file to javac. Here is an example for single module compilation:

Automation Script

Here is a UNIX shell script, named modules-compile.sh, that can do both single and multi module compilations. Put this into the directory above your module source directory like the following:

Put the list of your module directories into modules.list (no comments allowed here!):

These can be single modules (fri.i18n.messages) or directories containing multiple modules (module-sources).
IMPORTANT: keep the list in dependency order, so that basic modules are already compiled when the modules that depend on them get compiled!

# compiled classes target directory
moduleTargetDir=module-classes

srclist=sources.list

# sources must be in dependency order!
moduleDirs=`cat modules.list`

for dir in $moduleDirs
do
  # try to find module-info.java in given directory
  moduleInfo=`find \$dir -name module-info.java`
  [ -z "$moduleInfo" ] && {
    echo "ERROR: Ignoring $dir because it contains no module-info.java!" >&2
    continue
  }
 
  # check how many module-info.java files were found
  modulesCount=`echo \$moduleInfo | wc -w`
  if [ "$modulesCount" = 1 ]
  then
    # try to extract the module name from module-info.java
    moduleName=`awk '/^[ \t]*module/ {print $2}' \$moduleInfo`
    [ -z "$moduleName" ] && {
      echo "ERROR: Could not extract module name from $moduleInfo" >&2
      continue
    }
    srcdir=`dirname \$moduleInfo`
  
    echo "Compiling module $moduleName in $srcdir to $moduleTargetDir ..." >&2
  else
    # the grandparent directory of first module-info.java must be the parent of all
    firstModulesDir=`echo \$moduleInfo | awk '{print $1}'`
    srcdir=`dirname \$firstModulesDir`
    srcdir=`dirname \$srcdir`
  
    echo "Multimodule compile in $srcdir to $moduleTargetDir ...." >&2
  fi

  # write sources list into file and use the javac @sources.list option
  find $srcdir -name '*.java' >$srclist
 
  if [ "$modulesCount" = 1 ]
  then
    javac --module-path $moduleTargetDir -d $moduleTargetDir/$moduleName @$srclist
  else
    javac --module-path $moduleTargetDir -d $moduleTargetDir --module-source-path $srcdir @$srclist
  fi
 
  rm -f $srclist
done

Mind that this script requires the name of the module written in same line as the module keyword in a module-info.java of a single module (script line 23). For multi-module compilation this is not needed.

This script works with both Maven and Eclipse projects. Eclipse projects have all sources inside a src/ directory, Maven has them in src/main/java/ and src/test/java/.

It would take too much space to explain the script. Shell scripts are not well readable, they are quick & dirty, you need an expert to maintain them. But they are quite useful sometimes, so try it out !-)