Project met meerdere modules met Maven

1. Overzicht

In deze zelfstudie laten we zien hoe u een project met meerdere modules kunt bouwen met Maven.

Eerst bespreken we wat een project met meerdere modules is en bekijken we de voordelen van het volgen van deze aanpak. Dan zetten we ons voorbeeldproject op. Bekijk deze tutorial voor een goede introductie tot Maven.

2. Maven's project met meerdere modules

Een multi-module project is opgebouwd uit een aggregator POM die een groep submodules beheert. In de meeste gevallen bevindt de aggregator zich in de hoofdmap van het project en moet deze een type verpakking hebben pom.

Nu zijn de submodules reguliere Maven-projecten en kunnen ze afzonderlijk of via de aggregator POM worden gebouwd.

Door het project te bouwen via de aggregator POM, kan elk project dat een verpakkingstype heeft anders zijn dan pom zal resulteren in een gebouwd archiefbestand.

3. Voordelen van het gebruik van multimodules

Het grote voordeel van het gebruik van deze benadering is dat we kunnen duplicatie verminderen.

Laten we zeggen dat we een applicatie hebben die uit meerdere modules bestaat, laat het een front-end module en een back-end module zijn. Nu werken we aan beide en veranderen de functionaliteit die van invloed is op de twee. In dat geval zullen we zonder een gespecialiseerde build-tool beide componenten afzonderlijk moeten bouwen of een script moeten schrijven dat de code compileert, tests uitvoert en de resultaten laat zien. Nadat we nog meer modules in het project hebben gekregen, wordt het moeilijker te beheren en te onderhouden.

Bovendien kunnen projecten in de echte wereld bepaalde Maven-plug-ins nodig hebben om verschillende bewerkingen uit te voeren tijdens de levenscyclus van de build, afhankelijkheden en profielen te delen of andere BOM-projecten op te nemen.

Daarom kunnen we bij het gebruik van meerdere modules bouw de modules van onze applicatie in een enkele opdracht en als de bestelling ertoe doet, zal Maven dit voor ons uitzoeken. We kunnen ook delen een enorme hoeveelheid configuratie met andere modules.

4. Ouder-POM

Maven ondersteunt overerving op een manier die elk pom.xml-bestand heeft de impliciete bovenliggende POM, deze heet Super POM en kan worden gevonden in de binaire bestanden van Maven. Deze twee bestanden worden door Maven samengevoegd en vormen de effectieve POM.

Daarom kunnen we onze eigen pom.xml-bestand dat ons als het bovenliggende project zal dienen. Vervolgens kunnen we daar alle configuratie met afhankelijkheden opnemen en dit instellen als de ouder van onze onderliggende modules, zodat ze ervan erven.

Naast de erfenis geeft Maven het begrip aggregatie. Bovenliggende POM die gebruikmaakt van deze functionaliteit, wordt een geaggregeerde POM genoemd. Kortom, dit soort POM declareert zijn modules expliciet in zijn pom.xml-bestand.

5. Submodules

Submodules of subprojecten zijn reguliere Maven-projecten die erven van de bovenliggende POM. Zoals we al weten, laat overerving ons de configuratie en afhankelijkheden delen met submodules. Als we ons project echter in één keer willen bouwen of vrijgeven, moeten we onze submodules expliciet declareren in de bovenliggende POM. Uiteindelijk zal onze ouder-POM zowel de ouder- als de geaggregeerde POM zijn.

6. Bouwen van de applicatie

Nu we de submodules en hiërarchie van Maven begrijpen, gaan we een voorbeeldtoepassing bouwen om ze te demonstreren. We gebruiken de opdrachtregelinterface van Maven om onze projecten te genereren.

Deze app zal bestaan ​​uit drie modules, die vertegenwoordigen:

  • De kern onderdeel van ons domein
  • Een web onderhoud het verstrekken van enkele REST API's
  • EEN web applicatie met gebruikersgerichte webitems van een soort

Aangezien we ons concentreren op Maven, blijft de implementatie van deze services ongedefinieerd.

6.1. Ouder-POM genereren

Laten we eerst een bovenliggend project maken:

mvn-archetype: genereer -DgroupId = org.baeldung -DartifactId = bovenliggend project

Zodra de ouder is gegenereerd, moeten we het pom.xml bestand in de map van de ouder en verander de verpakking in pom.

pom

Door de verpakking in te stellen op pom-type, verklaren we dat het project zal dienen als een ouder of een aggregator - het zal geen verdere artefacten produceren.

Nu onze aggregator klaar is, kunnen we onze submodules genereren.

We moeten echter opmerken dat dit de plaats is waar alle te delen configuratie zich bevindt en uiteindelijk hergebruikt in onderliggende modules. We kunnen er onder andere gebruik van maken afhankelijkheidsbeheer of pluginManagement hier.

6.2. Submodules maken

Zoals onze ouder POM heette ouder-project, we moeten ervoor zorgen dat we in de map van de ouder zijn en draaien genereren commando's:

cd ouder-project mvn-archetype: genereren -DgroupId = org.baeldung -DartifactId = kern mvn-archetype: genereren -DgroupId = org.baeldung -DartifactId = service mvn-archetype: genereren -DgroupId = org.baeldung -DartifactId = webapp

Let op het gebruikte commando. Het is hetzelfde als we gebruikten voor de ouder. Het punt hier is dat deze modules gewone Maven-projecten zijn, maar Maven herkende dat ze genest waren. Toen we de map veranderden in de ouder-project, ontdekte het dat de ouder een verpakking van het type heeft pom en beide gewijzigd pom.xml bestanden dienovereenkomstig.

Daarna zal Maven drie submodules genereren en voor ons de ouder aanpassen pom.xml bestand door enkele tags toe te voegen:

 kernservice webapp 

Nu declareert onze ouder expliciet geaggregeerde modules.

Vervolgens, tijdens het hardlopen mvn-pakket commando in de bovenliggende projectdirectory, zal Maven alle drie de modules bouwen en testen.

Bovendien zal Maven Reactor ons project analyseren en in de juiste volgorde bouwen. Dus als onze web applicatie module is afhankelijk van de dienst module, zal Maven eerst het onderhoud, dan de web applicatie.

Immers, als we alle configuratie willen delen met onze submodules, in hun pom.xml bestanden, moeten we de ouder aangeven:

 org.baeldung bovenliggend project 1.0-SNAPSHOT 

We moeten opmerken dat submodules slechts één ouder kunnen hebben. We kunnen echter veel stuklijsten importeren. In dit artikel vindt u meer informatie over de stuklijstbestanden.

6.3. Bouwen aan het project

Nu kunnen we alle drie de modules tegelijk bouwen. Voer in de projectdirectory van de ouder het volgende uit:

mvn-pakket

Dit zal alle modules bouwen, we zouden de volgende uitvoer van de opdracht moeten zien:

[INFO] Scannen naar projecten ... [INFO] -------------------------------------- ---------------------------------- [INFO] Reactor-bouwopdracht: [INFO] bovenliggend project [INFO] core [INFO] service [INFO] webapp ... [INFO] Reactor Samenvatting: [INFO] ouderproject .......................... ........... SUCCES [0.140 s] [INFO] kern .............................. ................. SUCCES [2.195 s] [INFO] dienst ........................ .................... SUCCES [0,767 s] [INFO] webapp ..................... ........................ SUCCES [0,572 s] [INFO] ------------------ -------------------------------------------------- ---- [INFO] SUCCES OPBOUWEN [INFO] -------------------------------------- ----------------------------------

De Reactor geeft een overzicht van de ouder-project, maar zoals het is pom typ het is uitgesloten en de build resulteert in drie afzonderlijke .pot bestanden voor alle andere modules. In dat geval komt build in drie van hen voor.

7. Conclusie

In deze zelfstudie hebben we de voordelen besproken van het gebruik van Maven-multimodules. Ook hebben we onderscheid gemaakt tussen de ouder-POM van gewone Maven en de geaggregeerde POM. Uiteindelijk hebben we laten zien hoe je een eenvoudige multimodule kunt opzetten om mee te spelen.

Maven is een geweldig hulpmiddel, maar het is op zichzelf al complex. Als je meer informatie over Maven wilt vinden, bekijk dan de Sonatype Maven-referentie of Apache Maven-handleidingen. Als u op zoek bent naar geavanceerd gebruik van Maven multi-modules die zijn ingesteld, kijk dan hoe Spring Boot-project het gebruik ervan benut.

Alle codevoorbeelden op Baeldung zijn gebouwd met behulp van Maven, dus u kunt eenvoudig onze GitHub-projectwebsite bezoeken om verschillende Maven-configuraties te zien.