Java 9 introduces module system (JPMS) to improve the code organization and dependency management of large-scale projects. The module declares export packages and dependencies through the module-info.java file. The core concepts include exports (exposed packages), requirements (declare dependencies), and opens (allow reflective access). Its advantages are reflected in stronger encapsulation, clearer dependency management and faster startup speed. The steps to use include creating module-info.java, explicit export and dependencies, and running the program with --module-path. Notes include module names that are unique, non-reliable, and support for gradual migration. Mastering the module system can help improve project maintainability and stability.

Java 9 introduces an important new feature: the module system (JPMS, Java Platform Module System). It emerged to better organize and manage code dependencies in large projects. Simply put, the module system allows developers to more clearly define which classes are exposed to the outside and which are used internally.

This is especially useful when building large applications or platforms. For example, the JDK that comes with Java is a good example - it is split into multiple modules, such as java.base, java.logging, etc., each module has a clear functional boundary.

What is a module?

A module is a collection of packages containing code and resources, and declares its content and dependencies through a file named module-info.java .

For example, a simplest module declaration is as follows:

 module com.example.mymodule {
    exports com.example.mymodule.utils;
}

This module exposes the com.example.mymodule.utils package, and other modules can only use these classes if they explicitly refer to it.

The module has the following core concepts:

• exports : Specifies which packages can be accessed externally.
• requires : Declare other modules that the current module depends on.
• opens : Allows runtime reflection to access certain packages (but does not force compile-time checks).

Several key advantages of module systems

The benefits of module systems are mainly reflected in the following aspects:

• Stronger encapsulation
  By default, classes within packages can only be accessed inside the module, unless you explicitly declare open using exports . This mechanism prevents the problem of "sneaking" access to non-public classes.

• Clearer dependency management
  Use requires to clarify the dependencies between modules and avoid the "Classpath Hell" problem. The compiler will check whether the dependency is satisfied during the compilation stage.

• Faster boot and lower memory footprint
  After modularization, the JVM can load only the modules that are really needed, rather than the entire rt.jar (Java 8 and before), which is especially friendly for small device or container deployments.

How to get started with a module system?

If you are already familiar with the traditional Java project structure, then moving to a module system is not complicated. Here are a few key steps:

• Create module-info.java file as module descriptor.
• Identify which packages should be exported and which classes should remain private.
• If your project relies on third-party libraries, make sure they also support modularity (or can be handled through an automatic module mechanism).
• Use --module-path instead of --classpath to run a modular program.

For example, suppose you have a module project structure as follows:

 src/
└── com.example.mymodule/
    ├── module-info.java
    └── com/
        └── example/
            └── mymodule/
                └── utils/
                    MyUtil.java

You can compile and run it with the following command:

 javac -d out src/com.example.mymodule/module-info.java src/com.example.mymodule/com/example/mymodule/utils/MyUtil.java

java --module-path out -m com.example.mymodule/com.example.mymodule.utils.MyUtil

A few small details that are easy to ignore

• The module name must be unique , and it is recommended to use a method similar to domain name inversion, such as com.companyname.projectname.modulename .
• Modules cannot be cyclic dependencies , that is, A requires B, so B can no longer require A.
• Old projects can be gradually migrated without changing them all into modular structures at once. Automatic modules can be used to compatible with jar packages.

Basically that's it. Although the module system seems a bit complicated, it solves many long-standing problems in Java, especially in large project management and dependency control. Mastering it is very helpful for improving the maintainability and stability of your project.

The above is the detailed content of Introduction to the Java Module System (JPMS). For more information, please follow other related articles on the PHP Chinese website!