Module

A module is a discrete unit of functionality that can be run, tested, and debugged independently. Modules include such things as source code, build scripts, unit tests, deployment descriptors, etc.

The key components of a module are:

Content roots - the directories where the files belonging to the module (source code, resources, etc.) are stored. Each directory can belong to one and only one module; it's not possible to share a content root between multiple modules.
Source roots - A content root can have multiple source roots underneath it. Source roots can have different types: regular source roots, test source roots, resource roots, etc. In IntelliJ IDEA, source roots are used as roots of the package hierarchy structure. Java classes directly under a source root will be in the root package. Source roots can also be used to implement more fine-grained dependency checks. Code under a regular source root cannot depend on code under a test source root.
Not all other IntelliJ Platform-based IDEs use source roots.
Order entries - the dependencies of a module, which are stored in an ordered list. A dependency can be a reference to an SDK, a library, or another module.
Facets - the list of framework-specific configuration entries.

In addition to that, a module can store other settings, such as a module-specific SDK, compile output path settings, etc. Plugins can store additional data associated with a module by creating facets or module-level components.

The IntelliJ Platform provides a number of classes and interfaces you can use to work with modules:

This section discusses how to complete some common tasks related to management of modules.

See Changing the Project Structure for information on modifying project/module structure.

How do I get a list of modules the project includes?

Use the ModuleManager.getModules() method.

How do I get dependencies and classpath of a module?

Order entries include SDK, libraries and other modules the module uses. With the IntelliJ IDEA UI, you can view order entries for a module on the Dependencies tab of the Project Structure dialog box.

To explore the module dependencies, use the OrderEnumerator class.

The following code snippet illustrates how you can get classpath (classes root of all dependencies) for a module:

VirtualFile[] roots = ModuleRootManager.getInstance(module).orderEntries().classes().getRoots();

How do I get the SDK the module uses?

Use the ModuleRootManager.getSdk() method. This method returns a value of the Sdk type.

The following code snippet illustrates how you can get detailed information on SDK the specified module uses:

ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
Sdk SDK = moduleRootManager.getSdk();
String jdkInfo = "Module: " + module.getName() + " SDK: " + SDK.getName() + " SDK version: "
                 + SDK.getVersionString() + " SDK home directory: " + SDK.getHomePath();

How do I get a list of modules on which this module directly depends?

Use the ModuleRootManager.getDependencies() method to get an array of the Module type values or the ModuleRootManager.getDependencyModuleNames() to get an array of module names. To clarify, consider the following code snippet:

ModuleRootManager moduleRootManager = ModuleRootManager.getInstance(module);
Module[] dependentModules = moduleRootManager.getDependencies();
String[] dependentModulesNames = moduleRootManager.getDependencyModuleNames();

How do I get a list of modules that depend on this module?

Use the ModuleManager.getModuleDependentModules(module) method.

Note that you can also check whether a module (module1) depends on another specified module (module2) using the ModuleManager.isModuleDependent() method in the following way:

boolean isDependent = ModuleManager.getInstance(project).isModuleDependent(module1,module2);

How do I get a module to which the specified file or PSI element belongs?

To get the project module to which the specified file belongs, use the ModuleUtil.findModuleForFile() static method.
To clarify, consider the following code snippet:

String pathToFile = "C:\\users\\firstName.LastName\\plugins\\myPlugin\\src\\MyAction.java";
VirtualFile virtualFile = LocalFileSystem.getInstance().findFileByPath(pathToFile);
Module module = ModuleUtil.findModuleForFile(virtualFile,myProject);
String moduleName = module == null ? "Module not found" : module.getName();

To get the project module to which the specified PSI element belongs, use the ModuleUtil.findModuleForPsiElement() method.

Accessing Module Roots

Information about module roots can be accessed via ModuleRootManager. For example, the following snippet shows how to access the content roots of a module:

VirtualFile[] contentRoots = ModuleRootManager.getInstance(module).getContentRoots();

Checking Belonging to a Module Source Root

To check if a virtual file or directory belongs to a module source root, use the ProjectFileIndex.getSourceRootForFile() method. This method returns null if the file or directory does not belong to any source root of modules in the project.

VirtualFile moduleSourceRoot = ProjectRootManager.getInstance(project).getFileIndex().getSourceRootForFile(virtualFileOrDirectory);

Java: Compiler Output Properties

Obtain CompilerModuleExtension for given Module instance to access Compiler Output path related properties.

Receiving Notifications About Module Changes

To receive notifications about module changes (modules being added, removed or renamed), use the message bus and the ProjectTopics.MODULES topic:

project.getMessageBus().connect().subscribe(ProjectTopics.MODULES, new ModuleListener() {
  @Override
  public void moduleAdded(@NotNull Project project, @NotNull Module module) {

  }
});

If targeting 2019.3 or later, declarative registration is available as well.

Last modified: 29 九月 2022