Aplikasi Maven Berbilang Modul dengan Modul Java

Pengaturcaraan

1. Gambaran keseluruhan

Sistem Modul Platform Java (JPMS) menambah kebolehpercayaan, pemisahan masalah yang lebih baik, dan enkapsulasi yang lebih kuat ke aplikasi Java. Namun, ini bukan alat bina, oleh itu ia tidak memiliki kemampuan untuk menguruskan kebergantungan projek secara automatik.

Sudah tentu, kita mungkin tertanya-tanya sama ada jika kita dapat menggunakan alat binaan yang mapan, seperti Maven atau Gradle , dalam aplikasi modularisasi.

Sebenarnya, kita boleh! Dalam tutorial ini, kita akan belajar bagaimana membuat aplikasi Maven multi-modul menggunakan modul Java .

2. Membungkus Modul Maven di Modul Java

Oleh kerana pengurusan modulariti dan ketergantungan bukanlah konsep yang saling eksklusif di Java, kami dapat menggabungkan JPMS dengan lancar, misalnya, dengan Maven, sehingga memanfaatkan yang terbaik dari kedua dunia.

Dalam projek Maven multi-modul standard, kami menambahkan satu atau lebih modul Maven anak dengan meletakkannya di bawah folder root projek dan menyatakannya dalam POM induk, dalam bahagian.

Sebagai gantinya , kami mengedit POM setiap modul anak dan menentukan kebergantungannya melalui koordinat < groupId> , < artifactId > dan < version> standard .

The reaktor mekanisme Maven - bertanggungjawab untuk mengendalikan projek-projek multi-modul - menjaga membina keseluruhan projek dalam susunan yang betul.

Dalam kes ini, pada dasarnya kami akan menggunakan metodologi reka bentuk yang sama, tetapi dengan satu varian yang halus tetapi mendasar: kami akan membungkus setiap modul Maven ke dalam modul Java dengan menambahkannya fail deskriptor modul , modul-info.java .

3. Modul Parent Maven

Untuk menunjukkan bagaimana pengurusan modulariti dan ketergantungan berfungsi dengan baik, kami akan membina projek Maven multi-modul demo asas, yang fungsinya akan disempitkan untuk hanya mengambil beberapa objek domain dari lapisan kegigihan .

Untuk memastikan kodnya mudah, kami akan menggunakan Peta biasa sebagai struktur data yang mendasari untuk menyimpan objek domain. Sudah tentu, kita boleh beralih lebih jauh ke pangkalan data perhubungan yang lengkap.

Mari mulakan dengan menentukan modul Maven induk. Untuk mencapainya, mari buat direktori projek root yang disebut, misalnya, multimodulemavenproject (tetapi boleh jadi perkara lain), dan tambahkan padanya fail pom.xml induk :

com.baeldung.multimodulemavenproject multimodulemavenproject 1.0 pom multimodulemavenproject     org.apache.maven.plugins maven-compiler-plugin 3.8.0  11 11       UTF-8

Terdapat beberapa perincian yang perlu diperhatikan dalam definisi POM induk.

Pertama, kerana kita menggunakan Java 11, kita memerlukan sekurang-kurangnya Maven 3.5.0 pada sistem kita , kerana Maven menyokong Java 9 dan lebih tinggi dari versi itu dan seterusnya .

Dan, kami juga memerlukan sekurang-kurangnya versi 3.8.0 pemalam penyusun Maven. Oleh itu, mari pastikan untuk memeriksa versi terkini pemalam di Maven Central.

4. Modul Child Maven

Perhatikan bahawa sehingga tahap ini, POM induk tidak menyatakan modul anak .

Oleh kerana projek demo kami akan mengambil beberapa objek domain dari lapisan ketekunan, kami akan membuat empat modul Maven anak:

  1. entitimodul : akan mengandungi kelas domain sederhana
  2. daomodule : akan menyimpan antara muka yang diperlukan untuk mengakses lapisan ketekunan (kontrak DAO asas)
  3. userdaomodule : akan merangkumi pelaksanaan antara muka daomodule
  4. mainappmodule : titik masuk projek

4.1. The entitymodule Modul Maven

Sekarang, mari tambahkan modul Maven anak pertama, yang hanya merangkumi kelas domain asas.

Di bawah direktori root projek, mari kita buat struktur direktori entitimodule / src / main / java / com / baeldung / entiti dan tambahkan kelas Pengguna :

public class User { private final String name; // standard constructor / getter / toString }

Seterusnya, mari sertakan fail pom.xml modul :

 com.baeldung.multimodulemavenproject multimodulemavenproject 1.0  com.baeldung.entitymodule entitymodule 1.0 jar entitymodule

Seperti yang kita lihat, modul Entity tidak mempunyai kebergantungan kepada modul lain, dan juga tidak memerlukan artifak Maven tambahan, kerana ia hanya termasuk kelas Pengguna .

Sekarang, kita perlu merangkum modul Maven ke dalam modul Java . Untuk mencapainya, mari letakkan fail deskriptor modul berikut ( module-info.java ) di bawah direktori entitimodule / src / main / java :

module com.baeldung.entitymodule { exports com.baeldung.entitymodule; }

Akhir sekali, mari tambah modul anak Maven ke POM ibu bapa:

 entitymodule

4.2. The daomodule Modul Maven

Mari buat modul Maven baru yang akan mengandungi antara muka yang mudah. Ini sesuai untuk menentukan kontrak abstrak untuk mengambil jenis generik dari lapisan ketekunan.

Sebenarnya, ada alasan yang sangat menarik untuk meletakkan antara muka ini dalam modul Java yang terpisah. Dengan berbuat demikian, kami mempunyai kontrak abstrak dan sangat dipisahkan, yang mudah digunakan semula dalam konteks yang berbeza. Pada intinya, ini adalah implementasi alternatif dari Dependency Inversion Principle, yang menghasilkan reka bentuk yang lebih fleksibel.

Oleh itu, mari buat struktur direktori daomodule / src / main / java / com / baeldung / dao di bawah direktori root projek, dan tambahkan padanya antara muka Dao :

public interface Dao { Optional findById(int id); List findAll(); }

Sekarang, mari tentukan fail pom.xml modul :

 // parent coordinates  com.baeldung.daomodule daomodule 1.0 jar daomodule

Modul baru tidak memerlukan modul atau artifak lain, jadi kami akan membungkusnya menjadi modul Java. Mari buat deskriptor modul di bawah direktori daomodule / src / main / java :

module com.baeldung.daomodule { exports com.baeldung.daomodule; }

Akhirnya, mari tambah modul ke POM induk:

 entitymodule daomodule

4.3. The userdaomodule Modul Maven

Seterusnya, mari tentukan modul Maven yang memegang pelaksanaan antara muka Dao .

Under the project's root directory, let's create the userdaomodule/src/main/java/com/baeldung/userdao directory structure, and add to it the following UserDao class:

public class UserDao implements Dao { private final Map users; // standard constructor @Override public Optional findById(int id) { return Optional.ofNullable(users.get(id)); } @Override public List findAll() { return new ArrayList(users.values()); } }

Simply put, the UserDao class provides a basic API that allows us to fetch User objects from the persistence layer.

To keep things simple, we used a Map as the backing data structure for persisting the domain objects. Of course, it's possible to provide a more thorough implementation that uses, for instance, Hibernate's entity manager.

Now, let's define the Maven module's POM:

 // parent coordinates  com.baeldung.userdaomodule userdaomodule 1.0 jar userdaomodule   com.baeldung.entitymodule entitymodule 1.0   com.baeldung.daomodule daomodule 1.0

In this case, things are slightly different, as the userdaomodule module requires the entitymodule and daomodule modules. That's why we added them as dependencies in the pom.xml file.

We still need to encapsulate this Maven module into a Java module. So, let's add the following module descriptor under the userdaomodule/src/main/java directory:

module com.baeldung.userdaomodule { requires com.baeldung.entitymodule; requires com.baeldung.daomodule; provides com.baeldung.daomodule.Dao with com.baeldung.userdaomodule.UserDao; exports com.baeldung.userdaomodule; }

Finally, we need to add this new module to the parent POM:

 entitymodule daomodule userdaomodule

From a high-level view, it's easy to see that the pom.xml file and the module descriptor play different roles. Even so, they complement each other nicely.

Let's say that we need to update the versions of the entitymodule and daomodule Maven artifacts. We can easily do this without having to change the dependencies in the module descriptor. Maven will take care of including the right artifacts for us.

Similarly, we can change the service implementation that the module provides by modifying the “provides..with” directive in the module descriptor.

We gain a lot when we use Maven and Java modules together. The former brings the functionality of automatic, centralized dependency management, while the latter provides the intrinsic benefits of modularity.

4.4. The mainappmodule Maven Module

Additionally, we need to define the Maven module that contains the project's main class.

As we did before, let's create the mainappmodule/src/main/java/mainapp directory structure under the root directory, and add to it the following Application class:

public class Application { public static void main(String[] args) { Map users = new HashMap(); users.put(1, new User("Julie")); users.put(2, new User("David")); Dao userDao = new UserDao(users); userDao.findAll().forEach(System.out::println); } }

The Application class's main() method is quite simple. First, it populates a HashMap with a couple of User objects. Next, it uses a UserDao instance for fetching them from the Map, and then it displays them to the console.

In addition, we also need to define the module's pom.xml file:

 // parent coordinates  com.baeldung.mainappmodule mainappmodule 1.0 jar mainappmodule   com.baeldung.entitymodule entitymodule 1.0   com.baeldung.daomodule daomodule 1.0   com.baeldung.userdaomodule userdaomodule 1.0

The module's dependencies are pretty self-explanatory. So, we just need to place the module inside a Java module. Therefore, under the mainappmodule/src/main/java directory structure, let's include the module descriptor:

module com.baeldung.mainappmodule { requires com.baeldung.entitypmodule; requires com.baeldung.userdaopmodule; requires com.baeldung.daopmodule; uses com.baeldung.daopmodule.Dao; }

Finally, let's add this module to the parent POM:

 entitymodule daomodule userdaomodule mainappmodule

With all the child Maven modules already in place, and neatly encapsulated in Java modules, here's how the project's structure looks:

multimodulemavenproject (the root directory) pom.xml |-- entitymodule |-- src |-- main | -- java module-info.java |-- com |-- baeldung |-- entity User.class pom.xml |-- daomodule |-- src |-- main | -- java module-info.java |-- com |-- baeldung |-- dao Dao.class pom.xml |-- userdaomodule |-- src |-- main | -- java module-info.java |-- com |-- baeldung |-- userdao UserDao.class pom.xml |-- mainappmodule |-- src |-- main | -- java module-info.java |-- com |-- baeldung |-- mainapp Application.class pom.xml

5. Running the Application

Finally, let's run the application, either from within our IDE or from a console.

As we might expect, we should see a couple of User objects printed out to the console when the application starts up:

User{name=Julie} User{name=David}

6. Conclusion

Dalam tutorial ini, kita belajar secara pragmatik bagaimana menempatkan Maven dan JPMS bekerja berdampingan, dalam pengembangan projek Maven multi-modul asas yang menggunakan modul Java .

Seperti biasa, semua contoh kod yang ditunjukkan dalam tutorial ini terdapat di GitHub.