Több modulos Maven alkalmazás Java modulokkal

1. Áttekintés

A Java Platform Module System (JPMS) nagyobb megbízhatóságot, az aggodalmak jobb elkülönítését és erősebb beágyazást ad a Java alkalmazásokhoz. Ez azonban nem építési eszköz hiányzik a projektfüggőségek automatikus kezelésének képessége.

Természetesen elgondolkodhatunk azon, hogy ha tudunk használjon jól bevált építőeszközöket, mint például a Maven vagy a Gradle, moduláris alkalmazásokban.

Valójában tehetjük! Ebben az oktatóanyagban megtanuljuk, hogyan lehet több modulos Maven alkalmazást létrehozni Java modulok segítségével.

2. Maven modulok beágyazása Java modulokba

Mivel a modularitás és a függőségkezelés nem zárják ki egymást a Java-ban, zökkenőmentesen integrálhatjuk a JPMS-t például Mavenbe, így kihasználva mindkét világ legjobbjait.

Egy szokásos, több modulból álló Maven projektben hozzáadunk egy vagy több gyermek Maven modult úgy, hogy a projekt gyökérmappája alá helyezzük, és deklaráljuk őket a szülő POM-ban, a szakasz.

Viszont szerkesztjük az egyes gyermekmodulok POM-ját, és a <szabvány segítségével adjuk meg függőségeitgroupId>, <artifactId> és <verzió> koordináták.

A reaktor mechanizmus Mavenben - a több modulos projektek kezeléséért felelős - gondoskodik az egész projekt megfelelő sorrendben történő felépítéséről.

Ebben az esetben alapvetően ugyanazt a tervezési módszertant fogjuk használni, de egyetlen finom, mégis alapvető változattal: minden Maven modult egy Java modulba csomagolunk, hozzáadva a modul leíró fájlt, module-info.java.

3. A szülő Maven modul

Annak bemutatására, hogy a modularitás és a függőségkezelés mennyire működik együtt, felépítünk egy alapvető demo több modulos Maven projektet, amelynek funkcionalitása lesz szűkítve, hogy csak egy tartományi objektumot lehívjon egy perzisztencia rétegből.

A kód egyszerűségének érdekében egy sima szót fogunk használni Térkép mint a tartományi objektumok tárolásának alapjául szolgáló adatstruktúra. Természetesen könnyen átkapcsolhatunk egy teljes értékű relációs adatbázisra.

Kezdjük a szülő Maven modul definiálásával. Ennek megvalósításához hozzunk létre egy root projekt könyvtárat, például: multimodulemavenproject (de lehet bármi más), és adja hozzá a szülőt pom.xml fájl:

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

Van néhány részlet, amelyet érdemes figyelembe venni a szülő POM definíciójában.

Először is, mivel a Java 11-et használjuk, legalább a Maven 3.5.0-ra lesz szükségünk a rendszerünkön, mivel a Maven ettől a verziótól kezdve támogatja a Java 9 és újabb verziókat.

És szükségünk lesz legalább a Maven fordító plugin 3.8.0 verziójára is. Ezért mindenképpen ellenőrizzük a plugin legújabb verzióját a Maven Central-on.

4. A Child Maven modulok

Figyelje meg, hogy idáig, a szülő POM nem deklarál gyermekmodulokat.

Mivel a bemutató projektünk néhány tartományi objektumot fog lekérni a perzisztencia rétegből, négy gyermek Maven modult hozunk létre:

  1. entitásmodul: egy egyszerű tartományosztályt fog tartalmazni
  2. daomodule: birtokolja a perzisztencia réteg eléréséhez szükséges interfészt (alap DAO szerződés)
  3. userdaomodule: magában foglalja a daomoduleKezelőfelülete
  4. mainappmodule: a projekt belépési pontja

4.1. A entitásmodul Maven modul

Most tegyük hozzá az első gyermek Maven modult, amely csak egy alapvető tartományi osztályt tartalmaz.

A projekt gyökérkönyvtárában hozzuk létre a entitásmodul / src / main / java / com / baeldung / entitás könyvtárstruktúrát, és adjunk hozzá egy Felhasználó osztály:

public class Felhasználó {private final String name; // standard konstruktor / getter / toString}

Ezután tegyük bele a modulokat pom.xml fájl:

 com.baeldung.multimodulemavenproject multimodulemavenproject 1.0 com.baeldung.entitymodule entitásmodul 1.0 jar entitásmodul

Mint láthatjuk, a Entitás A modul nem függ más moduloktól, és nem igényel további Maven-műtárgyakat, mivel csak a Felhasználó osztály.

Most meg kell a Maven modult Java-modulba foglalja. Ennek eléréséhez egyszerűen helyezzük el a következő modulleíró fájlt (module-info.java) alatt entitásmodul / src / main / java Könyvtár:

modul com.baeldung.entitymodule {export com.baeldung.entitymodule; }

Végül adjuk hozzá a gyermek Maven modult a szülő POM-hoz:

 entitásmodul 

4.2. A daomodule Maven modul

Hozzunk létre egy új Maven modult, amely egy egyszerű felületet tartalmaz. Ez kényelmes absztrakt szerződés meghatározásához az általános típusok lekérésére a perzisztencia rétegből.

Ami azt illeti, nagyon meggyőző oka van ennek az interfésznek egy külön Java modulba történő elhelyezésére. Ezzel elvont, erősen szétválasztott szerződést kötünk, amelyet különböző körülmények között könnyű újrafelhasználni. Lényegében ez a függőségi inverzió elvének alternatív megvalósítása, amely rugalmasabb kialakítást eredményez.

Ezért hozzuk létre a daomodule / src / main / java / com / baeldung / dao könyvtárstruktúrát a projekt gyökérkönyvtárában, és adja hozzá a Dao felület:

nyilvános felület Dao {Opcionális findById (int id); List findAll (); }

Most definiáljuk a modulokat pom.xml fájl:

 // szülő koordinátái com.baeldung.daomodule daomodule 1.0 jar daomodule

Az új modulhoz nincs szükség más modulokra vagy műtermékekre sem, ezért csak egy Java modulba csomagoljuk. Hozzuk létre a modulleírót a daomodule / src / main / java Könyvtár:

modul com.baeldung.daomodule {export com.baeldung.daomodule; }

Végül adjuk hozzá a modult a szülő POM-hoz:

 entitásmodul daomodule 

4.3. A userdaomodule Maven modul

Ezután határozzuk meg a Maven modult, amely a Dao felület.

A projekt gyökérkönyvtárában hozzuk létre a userdaomodule / src / main / java / com / baeldung / userdao könyvtárstruktúrát, és adja hozzá a következőket UserDao osztály:

public class UserDao végrehajtja Dao {privát végső Map felhasználók; // szabványos konstruktor @Override public Opcionális findById (int id) {return Optional.ofNullable (users.get (id)); } @Orride public List findAll () {return new ArrayList (users.values ​​()); }}

Egyszerűen fogalmazva: UserDao osztály biztosít egy alapvető API-t, amely lehetővé teszi számunkra a letöltést Felhasználó objektumok a perzisztencia rétegből.

A dolgok egyszerűsége érdekében a Térkép mint a tartományi objektumok fennmaradásának támogató adatstruktúrája. Természetesen lehetséges egy alaposabb megvalósítás, amely például a Hibernate entitás menedzserét használja.

Most definiáljuk a Maven modul POM-ját:

 // szülői koordináták com.baeldung.userdaomodule userdaomodule 1.0 jar felhasználódaomodule com.baeldung.entitymodule entitymodule 1.0 com.baeldung.daomodule daomodule 1.0 

Ebben az esetben a dolgok kissé eltérnek, mivel a userdaomodule modul megköveteli az entitymodul és daomodule modulok. Ezért adtuk hozzá őket függőségként a pom.xml fájl.

Ezt a Maven modult még mindig be kell tömítenünk egy Java modulba. Tehát tegyük hozzá a következő modulleírót a userdaomodule / src / main / java Könyvtár:

modul com.baeldung.userdaomodule {com.baeldung.entitymodule szükséges; com.baeldung.daomodule szükséges; biztosítja a com.baeldung.daomodule.Dao szolgáltatást a com.baeldung.userdaomodule.UserDao; exportja com.baeldung.userdaomodule; } 

Végül hozzá kell adnunk ezt az új modult a szülő POM-hoz:

 entitásmodul daomodule userdaomodule 

Magas szintű nézetből ezt könnyű belátni a pom.xml fájl és a modulleíró különböző szerepet játszik. Ennek ellenére szépen kiegészítik egymást.

Tegyük fel, hogy frissítenünk kell az e verzióitntitymodul és daomodule Maven-leletek. Könnyen megtehetjük ezt anélkül, hogy meg kellene változtatnunk a modulleíró függőségeit. Maven gondoskodik a számunkra megfelelő tárgyak beépítéséről.

Hasonlóképpen megváltoztathatjuk a modul által nyújtott szolgáltatás megvalósítását a „Biztosítja..val” irányelv a modulleíróban.

Sokat nyerünk, ha a Maven és a Java modulokat együtt használjuk. Az előbbi hozza az automatikus, centralizált függőségkezelés funkcionalitását, míg az utóbbi a modularitás belső előnyeit nyújtja.

4.4. A mainappmodule Maven modul

Ezenkívül meg kell határoznunk a Maven modult, amely tartalmazza a projekt fő osztályát.

Ahogy korábban tettük, hozzuk létre a mainappmodule / src / main / java / mainapp könyvtárstruktúrát a gyökérkönyvtár alatt, és adja hozzá a következőket Alkalmazás osztály:

public class Alkalmazás {public static void main (String [] args) {Map users = new HashMap (); users.put (1, új Felhasználó ("Julie")); users.put (2, új Felhasználó ("David")); Dao userDao = új UserDao (felhasználók); userDao.findAll (). forEach (System.out :: println); }}

A Alkalmazás osztályé fő() módszer meglehetősen egyszerű. Először népesíti be a HashMap párral Felhasználó tárgyakat. Ezután a UserDao például a Térkép, majd megjeleníti őket a konzolon.

Ezen kívül meg kell határoznunk a modulokat is pom.xml fájl:

 // szülőkoordináták com.baeldung.mainappmodule mainappmodule 1.0 jar mainappmodule com.baeldung.entitymodule entitásmodul 1.0 com.baeldung.daomodule daomodule 1.0 com.baeldung.userdaomodule userdaomodule 1.0 

A modul függőségei eléggé magától értetődőek. Tehát csak be kell helyeznünk a modult egy Java modulba. Ezért a mainappmodule / src / main / java könyvtárstruktúra, tegyük bele a modulleírót:

modul com.baeldung.mainappmodule {com.baeldung.entitypmodule szükséges; com.baeldung.userdaopmodule szükséges; com.baeldung.daopmodule szükséges; használja a com.baeldung.daopmodule.Dao; } 

Végül adjuk hozzá ezt a modult a szülő POM-hoz:

 entitásmodul daomodule felhasználódaomodule mainappmodule 

Az összes gyermek Maven modul már van a helyén, és szépen be van zárva a Java modulokba, így néz ki a projekt szerkezete:

multimodulemavenproject (a gyökérkönyvtár) pom.xml | - entitásmodul | - src | - main | - java module-info.java | - com | - baeldung | - entitás 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. Az alkalmazás futtatása

Végül futtassuk az alkalmazást, akár az IDE-nkből, akár egy konzolról.

Ahogy számíthatunk rá, látnunk kellene párat Felhasználó az alkalmazás indításakor a konzolra kinyomtatott objektumok:

Felhasználó: {name = Julie} Felhasználó: {name = David} 

6. Következtetés

Ebben az oktatóanyagban pragmatikus módon tanultunk hogyan lehet Mavenet és a JPMS-t egymás mellett működtetni, egy alapvető modulos Maven projekt fejlesztésében, amely Java modulokat használ.

Szokás szerint az ebben az oktatóanyagban bemutatott összes kódminta elérhető a GitHubon.