Tutorial Apache Maven

Pengaturcaraan

1. Pengenalan

Membangun projek perisian biasanya terdiri daripada tugas-tugas seperti memuat turun dependensi, meletakkan balang tambahan pada classpath, menyusun kod sumber ke dalam kod binari, menjalankan ujian, mengemas kod yang disusun ke dalam artifak yang dapat digunakan seperti fail JAR, WAR, dan ZIP, dan menyebarkan artifak ini. ke pelayan aplikasi atau repositori.

Apache Maven mengotomatisasi tugas-tugas ini, meminimumkan risiko manusia membuat kesalahan semasa membina perisian secara manual dan memisahkan kerja menyusun dan mengemas kod kami dari pembinaan kod.

Dalam tutorial ini, kita akan meneroka alat yang hebat ini untuk menerangkan, membangun, dan mengurus projek perisian Java menggunakan maklumat pusat - Model Objek Projek (POM) - yang ditulis dalam XML.

2. Mengapa Menggunakan Maven?

Ciri-ciri utama Maven adalah:

  • penyediaan projek mudah yang mengikuti amalan terbaik: Maven cuba mengelakkan konfigurasi sebanyak mungkin, dengan menyediakan templat projek (dinamakan arketipe )
  • pengurusan kebergantungan: ia termasuk mengemas kini secara automatik, memuat turun dan mengesahkan keserasian, serta melaporkan penutupan pergantungan (juga dikenali sebagai pergantungan transitif)
  • pengasingan antara kebergantungan projek dan pemalam: dengan Maven, kebergantungan projek diambil dari repositori kebergantungan sementara sebarang kebergantungan plugin diambil dari repositori pemalam, mengakibatkan konflik lebih sedikit apabila pemalam mula memuat turun pergantungan tambahan
  • sistem repositori pusat: kebergantungan projek boleh dimuat dari sistem fail tempatan atau repositori awam, seperti Maven Central
Untuk mengetahui cara memasang Maven pada sistem anda, sila baca tutorial ini di Baeldung.

3. Model Objek Projek

Konfigurasi projek Maven dilakukan melalui Model Objek Objek (POM) , yang diwakili oleh fail pom.xml . The POM menerangkan projek, menguruskan kebergantungan, dan mengkonfigurasi plugin untuk membina perisian.

The POM juga mentakrifkan hubungan antara modul projek multi-modul. Mari lihat struktur asas fail POM khas :

 4.0.0 org.baeldung org.baeldung jar 1.0-SNAPSHOT org.baeldung //maven.apache.org   junit junit 4.12 test      //...

Mari kita perhatikan lebih dekat konstruk ini.

3.1. Pengecam Projek

Maven menggunakan sekumpulan pengecam, juga disebut koordinat, untuk mengenal pasti projek secara unik dan menentukan bagaimana artifak projek harus dikemas:

  • groupId - nama asas unik syarikat atau kumpulan yang membuat projek
  • artifactId - nama unik projek
  • versi - versi projek
  • pembungkusan - kaedah pembungkusan (mis. WAR / JAR / ZIP )

Tiga yang pertama ( groupId: artifactId: version ) bergabung untuk membentuk pengecam unik dan merupakan mekanisme yang anda tentukan versi perpustakaan luaran (contohnya JAR) yang akan digunakan oleh projek anda.

3.2. Kebergantungan

Perpustakaan luaran yang digunakan oleh projek dipanggil dependensi. Ciri pengurusan kebergantungan di Maven memastikan muat turun automatik perpustakaan tersebut dari repositori pusat, jadi anda tidak perlu menyimpannya secara tempatan.

Ini adalah ciri utama Maven dan memberikan faedah berikut:

  • menggunakan simpanan yang lebih sedikit dengan mengurangkan jumlah muat turun dari repositori jauh
  • membuat pemeriksaan projek lebih cepat
  • menyediakan platform yang berkesan untuk menukar artifak binari dalam organisasi anda dan seterusnya tanpa perlu membina artifak dari sumber setiap masa

Untuk menyatakan kebergantungan pada perpustakaan luaran, anda perlu menyediakan kumpulan pustaka, artifactId , dan versi perpustakaan. Mari kita lihat contohnya:

 org.springframework spring-core 4.3.5.RELEASE

Semasa Maven memproses kebergantungan, ia akan memuat turun perpustakaan Spring Core ke repositori Maven tempatan anda.

3.3. Repositori

Sebuah repositori di Maven digunakan untuk menyimpan artifak dan pergantungan pelbagai jenis. Repositori tempatan lalai terletak di folder .m2 / repositori di bawah direktori utama pengguna.

Sekiranya artifak atau pemalam tersedia di repositori tempatan, Maven menggunakannya. Jika tidak, ia dimuat turun dari repositori pusat dan disimpan di repositori tempatan. Repositori pusat lalai adalah Maven Central.

Beberapa perpustakaan, seperti pelayan JBoss, tidak tersedia di repositori pusat tetapi tersedia di repositori alternatif. Untuk perpustakaan tersebut, anda perlu memberikan URL ke repositori alternatif di dalam fail pom.xml :

  JBoss repository //repository.jboss.org/nexus/content/groups/public/

Harap maklum bahawa anda boleh menggunakan beberapa repositori dalam projek anda.

3.4. Hartanah

Sifat tersuai dapat membantu menjadikan fail pom.xml anda lebih mudah dibaca dan dijaga. Dalam kes penggunaan klasik, anda akan menggunakan sifat khusus untuk menentukan versi untuk kebergantungan projek anda.

Properti Maven adalah placeholder bernilai dan dapat diakses di mana saja dalam pom.xml dengan menggunakan notasi $ {name} , di mana nama adalah harta.

Mari lihat contoh:

 4.3.5.RELEASE    org.springframework spring-core ${spring.version}   org.springframework spring-context ${spring.version}

Sekarang jika anda ingin menaikkan versi Spring ke versi yang lebih baru, anda hanya perlu menukar nilai di dalamtag harta dan semua kebergantungan menggunakan harta itu di dalamnya tag akan dikemas kini.

Properties juga sering digunakan untuk menentukan pemboleh ubah path build:

 ${project.build.directory}/tmp/   //... ${project.resources.build.folder} //...

3.5. Membina

The build section is also a very important section of the Maven POM. It provides information about the default Maven goal, the directory for the compiled project, and the final name of the application. The default build section looks like this:

 install ${basedir}/target ${artifactId}-${version}  filters/filter1.properties  //...

The default output folder for compiled artifacts is named target, and the final name of the packaged artifact consists of the artifactId and version, but you can change it at any time.

3.6. Using Profiles

Another important feature of Maven is its support for profiles. A profile is basically a set of configuration values. By using profiles, you can customize the build for different environments such as Production/Test/Development:

  production    //...      development  true     //...

As you can see in the example above, the default profile is set to development. If you want to run the production profile, you can use the following Maven command:

mvn clean install -Pproduction

4. Maven Build Lifecycles

Every Maven build follows a specified lifecycle. You can execute several build lifecyclegoals, including the ones to compile the project’s code, create a package, and install the archive file in the local Maven dependency repository.

4.1. Lifecycle Phases

The following list shows the most important Maven lifecycle phases:

  • validate – checks the correctness of the project
  • compile – compiles the provided source code into binary artifacts
  • test – executes unit tests
  • package – packages compiled code into an archive file
  • integration-test – executes additional tests, which require the packaging
  • verify – checks if the package is valid
  • install – installs the package file into the local Maven repository
  • deploy – deploys the package file to a remote server or repository

4.2. Plugins and Goals

A Maven plugin is a collection of one or more goals. Goals are executed in phases, which helps to determine the order in which the goals are executed.

The rich list of plugins that are officially supported by Maven is available here. There is also an interesting article how to build an executable JAR on Baeldung using various plugins.

To gain a better understanding of which goals are run in which phases by default, take a look at the default Maven lifecycle bindings.

To go through any one of the above phases, we just have to call one command:

mvn

For example, mvn clean install will remove the previously created jar/war/zip files and compiled classes (clean) and execute all the phases necessary to install new archive (install).

Please note that goals provided by plugins can be associated with different phases of the lifecycle.

5. Your First Maven Project

In this section, we will use the command line functionality of Maven to create a Java project.

5.1. Generating a Simple Java Project

In order to build a simple Java project, let's run the following command:

mvn archetype:generate -DgroupId=org.baeldung -DartifactId=org.baeldung.java -DarchetypeArtifactId=maven-archetype-quickstart -DinteractiveMode=false

The groupId is a parameter indicating the group or individual that created a project, which is often a reversed company domain name. The artifactId is the base package name used in the project, and we use the standard archetype.

Since we didn't specify the version and the packaging type, these will be set to default values — the version will be set to 1.0-SNAPSHOT, and the packaging will be set to jar.

If you don't know which parameters to provide, you can always specify interactiveMode=true, so that Maven asks for all the required parameters.

After the command completes, we have a Java project containing an App.java class, which is just a simple “Hello World” program, in the src/main/java folder.

We also have an example test class in src/test/java. The pom.xml of this project will look similar to this:

 4.0.0 org.baeldung org.baeldung.java jar 1.0-SNAPSHOT org.baeldung.java //maven.apache.org   junit junit 4.1.2 test

As you can see, the junit dependency is provided by default.

5.2. Compiling and Packaging a Project

The next step is to compile the project:

mvn compile

Maven will run through all lifecycle phases needed by the compile phase to build the project's sources. If you want to run only the test phase, you can use:

mvn test

Now let's invoke the package phase, which will produce the compiled archive jar file:

mvn package

5.3. Executing an Application

Finally, we are going to execute our Java project with the exec-maven-plugin. Let's configure the necessary plugins in the pom.xml:

 src   maven-compiler-plugin 3.6.1  1.8 1.8    org.codehaus.mojo exec-maven-plugin 1.5.0  org.baeldung.java.App

The first plugin, maven-compiler-plugin, is responsible for compiling the source code using Java version 1.8. The exec-maven-plugin searches for the mainClass in our project.

To execute the application, we run the following command:

mvn exec:java

6. Multi-Module Projects

The mechanism in Maven that handles multi-module projects (also called aggregator projects) is called Reactor.

The Reactor collects all available modules to build, then sorts projects into the correct build order, and finally, builds them one by one.

Let's see how to create a multi-module parent project.

6.1. Create Parent Project

First of all, we need to create a parent project. In order to create a new project with the name parent-project, we use the following command:

mvn archetype:generate -DgroupId=org.baeldung -DartifactId=parent-project

Next, we update the packaging type inside the pom.xml file to indicate that this is a parent module:

pom

6.2. Create Submodule Projects

In the next step, we create submodule projects from the directory of parent-project:

cd parent-project mvn archetype:generate -DgroupId=org.baeldung -DartifactId=core mvn archetype:generate -DgroupId=org.baeldung -DartifactId=service mvn archetype:generate -DgroupId=org.baeldung -DartifactId=webapp

To verify if we created the submodules correctly, we look in the parent-project pom.xml file, where we should see three modules:

 core service webapp

Moreover, a parent section will be added in each submodule’s pom.xml:

 org.baeldung parent-project 1.0-SNAPSHOT

6.3. Enable Dependency Management in Parent Project

Dependency management is a mechanism for centralizing the dependency information for a muti-module parent project and its children.

When you have a set of projects or modules that inherit a common parent, you can put all the required information about the dependencies in the common pom.xml file. This will simplify the references to the artifacts in the child POMs.

Let's take a look at a sample parent's pom.xml:

   org.springframework spring-core 4.3.5.RELEASE  //...

By declaring the spring-core version in the parent, all submodules that depend on spring-core can declare the dependency using only the groupId and artifactId, and the version will be inherited:

  org.springframework spring-core  //...

Moreover, you can provide exclusions for dependency management in parent's pom.xml, so that specific libraries will not be inherited by child modules:

  org.springframework spring-context

Finally, if a child module needs to use a different version of a managed dependency, you can override the managed version in child's pom.xml file:

 org.springframework spring-core 4.2.1.RELEASE

Please note that while child modules inherit from their parent project, a parent project does not necessarily have any modules that it aggregates. On the other hand, a parent project may also aggregate projects that do not inherit from it.

For more information on inheritance and aggregation please refer to this documentation.

6.4. Updating the Submodules and Building a Project

We can change the packaging type of each submodule. For example, let's change the packaging of the webapp module to WAR by updating the pom.xml file:

war

Now we can test the build of our project by using the mvn clean install command. The output of the Maven logs should be similar to this:

[INFO] Scanning for projects... [INFO] Reactor build order: [INFO] parent-project [INFO] core [INFO] service [INFO] webapp //............. [INFO] ----------------------------------------- [INFO] Reactor Summary: [INFO] ----------------------------------------- [INFO] parent-project .................. SUCCESS [2.041s] [INFO] core ............................ SUCCESS [4.802s] [INFO] service ......................... SUCCESS [3.065s] [INFO] webapp .......................... SUCCESS [6.125s] [INFO] -----------------------------------------

7. Conclusion

Dalam artikel ini, kami membincangkan beberapa ciri alat binaan Apache Maven yang lebih popular.

Semua contoh kod di Baeldung dibina menggunakan Maven, jadi anda boleh dengan mudah memeriksa laman web projek GitHub kami untuk melihat pelbagai konfigurasi Maven.