Progetto multi-modulo con Maven

1. Panoramica

In questo tutorial, mostreremo come creare un progetto multimodulo con Maven.

Per prima cosa, discuteremo cos'è un progetto multimodulo e daremo uno sguardo ai vantaggi di seguire questo approccio. Quindi imposteremo il nostro progetto di esempio. Per una buona introduzione a Maven, dai un'occhiata a questo tutorial.

2. Il progetto multi-modulo di Maven

Un progetto multi-modulo è costruito da un aggregatore POM che gestisce un gruppo di sottomoduli. Nella maggior parte dei casi, l'aggregatore si trova nella directory principale del progetto e deve avere un pacchetto di tipo pom .

Ora, i sottomoduli sono normali progetti Maven e possono essere costruiti separatamente o tramite l'aggregatore POM.

Costruendo il progetto tramite l'aggregatore POM, ogni progetto che ha un tipo di packaging diverso da pom risulterà in un file di archivio costruito.

3. Vantaggi dell'utilizzo di più moduli

Il vantaggio significativo dell'utilizzo di questo approccio è che possiamo ridurre la duplicazione.

Diciamo che abbiamo un'applicazione che consiste di diversi moduli, lascia che sia un modulo front-end e un modulo back-end. Ora lavoriamo su entrambi e cambiamo la funzionalità che influenza i due. In tal caso, senza uno strumento di compilazione specializzato, dovremo costruire entrambi i componenti separatamente o scrivere uno script che compilerà il codice, eseguirà test e mostrerà i risultati. Quindi, dopo che avremo ancora più moduli nel progetto, diventerà più difficile da gestire e mantenere.

Inoltre, nel mondo reale, i progetti potrebbero richiedere alcuni plugin Maven per eseguire varie operazioni durante il ciclo di vita della build, condividere dipendenze e profili o includere altri progetti BOM.

Pertanto, quando sfruttiamo più moduli, possiamo costruire i moduli della nostra applicazione in un unico comando e se l'ordine è importante, Maven lo capirà per noi. Inoltre, possiamo condividere una grande quantità di configurazione con altri moduli .

4. POM genitore

Maven supporta l'ereditarietà in modo che ogni file pom.xml abbia il POM genitore implicito, si chiama Super POM e può essere posizionato nei binari di Maven. Questi due file vengono uniti da Maven e formano il POM effettivo.

Quindi, possiamo creare il nostro file pom.xml che ci servirà come progetto principale . Quindi, possiamo includere tutta la configurazione con le dipendenze e impostarlo come genitore dei nostri moduli figlio, in modo che erediteranno da esso.

Oltre all'eredità, Maven fornisce la nozione di aggregazione. Il POM principale che sfrutta questa funzionalità è chiamato POM aggregato . Fondamentalmente, questo tipo di POM dichiara esplicitamente i suoi moduli nel suo file pom.xml.

5. Sottomoduli

I sottomoduli o sottoprogetti sono normali progetti Maven che ereditano dal POM padre. Come già sappiamo, l'ereditarietà ci consente di condividere la configurazione e le dipendenze con i sottomoduli. Tuttavia, se vogliamo creare o rilasciare il nostro progetto in un colpo solo, dobbiamo dichiarare esplicitamente i nostri sottomoduli nel POM genitore. In definitiva, il nostro POM genitore sarà il genitore così come il POM aggregato.

6. Creazione dell'applicazione

Ora che comprendiamo i sottomoduli e la gerarchia di Maven, creiamo un'applicazione di esempio per dimostrarli. Useremo l'interfaccia della riga di comando di Maven per generare i nostri progetti.

Questa app sarà composta da tre moduli, che rappresenteranno:

  • La parte centrale del nostro dominio
  • Un servizio web che fornisce alcune API REST
  • Una webapp contenente risorse web rivolte agli utenti di qualche tipo

Poiché ci concentreremo su Maven, l'implementazione di questi servizi rimarrà indefinita.

6.1. Generazione POM genitore

Per prima cosa, creiamo un progetto padre :

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

Una volta generato il genitore, dobbiamo aprire il file pom.xml che si trova nella directory del genitore e cambiare la confezione in pom.

pom

Impostando il packaging sul tipo pom, stiamo dichiarando che il progetto fungerà da genitore o aggregatore - non produrrà ulteriori artefatti.

Ora, una volta terminato il nostro aggregatore, possiamo generare i nostri sottomoduli.

Tuttavia, dobbiamo notare, questo è il luogo in cui si trova tutta la configurazione da condividere e alla fine riutilizzata nei moduli figli. Tra le altre cose, possiamo fare uso di dependencyManagement o pluginManagement qui.

6.2. Creazione di sottomoduli

Poiché il nostro POM genitore è stato chiamato progetto-genitore , dobbiamo assicurarci di essere nella directory del genitore ed eseguire i comandi di generazione :

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

Notare il comando utilizzato. È lo stesso che abbiamo usato per il genitore. Il fatto è che questi moduli sono normali progetti Maven, ma Maven ha riconosciuto che sono nidificati. Quando abbiamo cambiato la directory nel progetto genitore , abbiamo scoperto che il genitore ha un pacchetto di tipo pom e ha modificato entrambi i file pom.xml di conseguenza.

Dopodiché, Maven genererà tre sottomoduli e modificherà per noi il file pom.xml del genitore aggiungendo alcuni tag:

 core service webapp 

Ora, il nostro genitore dichiara esplicitamente i moduli aggregati.

Successivamente, quando si esegue il comando del pacchetto mvn nella directory del progetto padre, Maven creerà e testerà tutti e tre i moduli.

Moreover, Maven Reactor will analyze our project and build it in proper order. So, if our webapp module depends on the service module, Maven will build first the service, then the webapp.

After all, if we wish to share all the configuration with our submodules, in their pom.xml files, we'll have to declare the parent:

 org.baeldung parent-project 1.0-SNAPSHOT 

We need to note, that submodules can have only one parent. However, we can import many BOMs. More details about the BOM files can be found in this article.

6.3. Building the Project

Now we can build all three modules at once. In the parent's project directory, run:

mvn package

This will build all the modules, we should see the following output of the command:

[INFO] Scanning for projects... [INFO] ------------------------------------------------------------------------ [INFO] Reactor Build Order: [INFO] parent-project [INFO] core [INFO] service [INFO] webapp ... [INFO] Reactor Summary: [INFO] parent-project ..................................... SUCCESS [ 0.140 s] [INFO] core ............................................... SUCCESS [ 2.195 s] [INFO] service ............................................ SUCCESS [ 0.767 s] [INFO] webapp ............................................. SUCCESS [ 0.572 s] [INFO] ------------------------------------------------------------------------ [INFO] BUILD SUCCESS [INFO] ------------------------------------------------------------------------

The Reactor lists the parent-project, but as it's pom type it's excluded and the build results in three separate .jar files for all other modules. In that case, build occurs in three of them.

7. Conclusion

In this tutorial, we discussed the benefits of using Maven multi-modules. Also, we distinguished between regular Maven's parent POM and aggregate POM. In the end, we showed how to set up a simple multi-module to start to play with.

Maven is a great tool but it is complex on its own. If you'd like to find more details about Maven, have a look at the Sonatype Maven reference or Apache Maven guides. If you seek advanced usages of Maven multi-modules set up, have a look how Spring Boot project leverages the usage of it.

Tutti gli esempi di codice su Baeldung sono creati utilizzando Maven, quindi puoi facilmente controllare il nostro sito Web del progetto GitHub per vedere varie configurazioni di Maven.