streamalism.org

1. סקירה כללית

מערכת ה- Java Platform Module (JPMS) מוסיפה אמינות רבה יותר, הפרדה טובה יותר בין דאגות, וקפסולציה חזקה יותר ליישומי Java. עם זאת, זה לא כלי לבנות, לפיכך זה חסר את היכולת לנהל אוטומטית תלות בפרויקט.

כמובן, אנו עשויים לתהות אם אנו יכולים השתמש בכלי בנייה מבוססים, כמו Maven או Gradle, ביישומים מודולריים.

למעשה, אנחנו יכולים! במדריך זה, נלמד כיצד ליצור יישום Maven רב-מודולי באמצעות מודולי Java.

2. הקפדה על מודולי Maven במודולי Java

מאז ניהול מודולריות ותלות אינם מושגים בלעדיים זה בזה ב- Java, אנו יכולים לשלב בצורה חלקה את JPMS, למשל, עם Maven, ובכך למנף את הטוב משני העולמות.

בפרויקט Maven רגיל עם מספר מודולים, אנו מוסיפים מודול Maven ילד אחד או יותר על ידי הצבתם תחת תיקיית הבסיס של הפרויקט והכרזה עליהם ב- POM האב, בתוך סָעִיף.

בתורו, אנו עורכים את ה- POM של כל מודול ילד ומציינים את התלות שלו באמצעות התקן <groupId>, <artifactId> ו <גרסה> קואורדינטות.

ה כור מנגנון ב- Maven - אחראי על טיפול בפרויקטים מרובי-מודולים - דואג לבנות את הפרויקט כולו בסדר הנכון.

במקרה זה, בעצם נשתמש באותה מתודולוגיית תכנון, אך עם גרסה אחת עדינה אך בסיסית: נעטוף כל מודול Maven למודול Java על ידי הוספת אליו את קובץ מתאר המודולים, module-info.java.

3. מודול Maven Maven

כדי להדגים כיצד מודולריות וניהול תלות עובדים נהדר יחד, אנו בונים פרויקט בסיסי רב-מודולי של Maven, שהפונקציונליות שלהם תצטמצם רק לאחזור של כמה אובייקטים מתחום משכבת ​​התמדה.

כדי לשמור על פשטות הקוד, נשתמש בתכנית רגילה מַפָּה כמבנה הנתונים הבסיסי לאחסון אובייקטי התחום. כמובן, אנו יכולים לעבור בהמשך הדרך בקלות למאגר יחסים מלא.

נתחיל בהגדרת מודול Maven האב. כדי להשיג זאת, בואו ליצור ספריית פרויקט שורש שנקראת, למשל, פרויקט רב-מודולי (אבל זה יכול להיות כל דבר אחר), ולהוסיף לזה את ההורה pom.xml קוֹבֶץ:

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

יש כמה פרטים שכדאי לשים לב בהגדרת ה- POM ההורה.

ראשית, מכיוון שאנחנו משתמשים ב- Java 11, נצטרך לפחות Maven 3.5.0 במערכת שלנו, שכן Maven תומך ב- Java 9 ומעלה מגרסה זו ואילך.

וגם נצטרך לפחות גרסה 3.8.0 של תוסף המהדר Maven. לכן, בואו נדאג לבדוק את הגרסה האחרונה של התוסף ב- Maven Central.

4. מודולי ה- Maven של הילד

שימו לב שעד לנקודה זו, ה- POM ההורה אינו מכריז על מודולים של ילדים.

מכיוון שפרויקט ההדגמה שלנו יביא כמה אובייקטים מתחום משכבת ​​ההתמדה, ניצור ארבעה מודולי Maven ילדים:

1. מודול ישויות: יכיל מחלקת תחומים פשוטה
2. daomodule: ישמור על הממשק הנדרש לגישה לשכבת ההתמדה (חוזה DAO בסיסי)
3. userdaomodule: יכלול יישום של daomoduleהממשק
4. mainappmodule: נקודת הכניסה לפרויקט

4.1. ה מודול ישויות מודול Maven

עכשיו, בואו נוסיף את מודול Maven הילד הראשון, שכולל רק מחלקת תחום בסיסית.

תחת ספריית הבסיס של הפרויקט, בואו ניצור את ה- entitymodule / src / main / java / com / baeldung / entity מבנה ספריות והוסף א מִשׁתַמֵשׁ מעמד:

משתמש בכיתה ציבורית {private final שם מחרוזת; // קונסטרוקטור סטנדרטי / גטר / toString}

לאחר מכן, בואו נכלול את המודולים pom.xml קוֹבֶץ:

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

כפי שאנו רואים, יֵשׁוּת למודול אין תלות במודולים אחרים, ואינו דורש חפצים נוספים של Maven, מכיוון שהוא כולל רק את מִשׁתַמֵשׁ מעמד.

עכשיו, אנחנו צריכים אנקפס את מודול Maven למודול Java. כדי להשיג זאת, פשוט נניח את קובץ מתאר המודולים הבא (module-info.java) תחת entitymodule / src / main / java מַדרִיך:

מודול com.baeldung.entitymodule {ייצוא com.baeldung.entitymodule; }

לבסוף, בואו נוסיף את מודול Maven הילד ל- POM ההורה:

 מודול ישויות 

4.2. ה daomodule מודול Maven

בואו ניצור מודול Maven חדש שיכיל ממשק פשוט. זה נוח להגדרת חוזה מופשט לאחזור סוגים גנריים משכבת ​​ההתמדה.

למען האמת, יש סיבה משכנעת מאוד להציב את הממשק הזה במודול Java נפרד. על ידי כך, יש לנו חוזה מופשט ומנותק מאוד, וקל לשימוש חוזר בהקשרים שונים. בבסיסה, זהו יישום חלופי של עקרון היפוך התלות, שמניב עיצוב גמיש יותר.

לכן, בואו ניצור את daomodule / src / main / java / com / baeldung / dao מבנה ספריות תחת ספריית הבסיס של הפרויקט, והוסף אליו את דאו מִמְשָׁק:

ממשק ציבורי Dao {findById (Option id) אופציונלי; רשימה findAll (); }

עכשיו, בואו נגדיר את המודול pom.xml קוֹבֶץ:

 // קואורדינטות האב com.baeldung.daomodule daomodule 1.0 jar daomodule

גם המודול החדש אינו דורש מודולים או חפצים אחרים, אז פשוט נעטוף אותו למודול ג'אווה. בואו ניצור את מתאר המודולים תחת ה- daomodule / src / main / java מַדרִיך:

מודול com.baeldung.daomodule {ייצוא com.baeldung.daomodule; }

לבסוף, בואו נוסיף את המודול ל- POM האב:

 מודול ישות מודול 

4.3. ה userdaomodule מודול Maven

לאחר מכן, בואו נגדיר את מודול Maven המכיל יישום של ה- דאו מִמְשָׁק.

תחת ספריית הבסיס של הפרויקט, בואו ניצור את ה- userdaomodule / src / main / java / com / baeldung / userdao מבנה הספריה, והוסף אליו את הדברים הבאים UserDao מעמד:

מחלקת ציבור UserDao מיישמת את Dao {משתמשי Map final final; // קונסטרוקטור סטנדרטי @ Override public אופציונלי findById (int id) {return Optional.ofNullable (users.get (id)); } @ רישום ציבורי @ FindAll () {החזר ArrayList חדש (users.values ​​()); }}

במילים פשוטות, ה UserDao class מספק ממשק API בסיסי המאפשר אחזור מִשׁתַמֵשׁ אובייקטים משכבת ​​ההתמדה.

כדי לשמור על דברים פשוטים, השתמשנו ב- מַפָּה כמבנה נתוני הגיבוי להתמדה של אובייקטי התחום. כמובן שניתן לספק יישום יסודי יותר המשתמש למשל במנהל היישויות של Hibernate.

עכשיו, בואו נגדיר את ה- POM של מודול Maven:

 // קואורדינטות האב com.baeldung.userdaomodule userdaomodule 1.0 jar userdaomodule com.baeldung.entitymodule entitymodule 1.0 com.baeldung.daomodule daomodule 1.0 

במקרה זה, הדברים שונים במקצת, כמו userdaomodule מודול דורש את entitymodule ו daomodule מודולים. זו הסיבה שהוספנו אותם כתלות בתמונות pom.xml קוֹבֶץ.

אנחנו עדיין צריכים להכיל את מודול ה- Maven הזה למודול Java. אז בואו נוסיף את מתאר המודולים הבא תחת ה- userdaomodule / src / main / java מַדרִיך:

מודול com.baeldung.userdaomodule {דורש com.baeldung.entitymodule; דורש com.baeldung.daomodule; מספק com.baeldung.daomodule.Dao עם com.baeldung.userdaomodule.UserDao; יצוא com.baeldung.userdaomodule; } 

לבסוף, עלינו להוסיף מודול חדש זה ל- POM האב:

 מודול ישות מודול משתמש 

בראייה ברמה גבוהה, קל לראות זאת ה pom.xml הקובץ ומתאר המודולים ממלאים תפקידים שונים. למרות זאת, הם משלימים זה את זה יפה.

בואו נגיד שעלינו לעדכן את הגרסאות של ה- entitymodule ו daomodule ממצאים של Maven. אנו יכולים לעשות זאת בקלות מבלי שנצטרך לשנות את התלות במתאר המודול. Maven ידאג לכלול את החפצים המתאימים לנו.

באופן דומה, אנו יכולים לשנות את הטמעת השירות שהמודול מספק על ידי שינוי ה- "מספק..עם" הנחיה במתאר המודולים.

אנו מרוויחים הרבה כאשר אנו משתמשים במודולי Maven ו- Java יחד. הראשון מביא לפונקציונליות של ניהול תלות מרכזי אוטומטי, ואילו האחרון מספק את היתרונות המהותיים של המודולריות.

4.4. ה mainappmodule מודול Maven

בנוסף, עלינו להגדיר את מודול Maven המכיל את המחלקה הראשית של הפרויקט.

כמו שעשינו קודם, בואו ניצור את mainappmodule / src / main / java / mainapp מבנה ספריות תחת ספריית הבסיס, והוסף אליו את הדברים הבאים יישום מעמד:

מחלקה ציבורית יישום {public static void main (String [] args) {Map users = HashMap new (); users.put (1, משתמש חדש ("ג'ולי")); users.put (2, משתמש חדש ("דוד")); Dao userDao = UserDao חדש (משתמשים); userDao.findAll (). forEach (System.out :: println); }}

ה יישום כיתות רָאשִׁי() השיטה היא די פשוטה. ראשית, הוא מאכלס א מפת גיבוב עם כמה מִשׁתַמֵשׁ חפצים. לאחר מכן, הוא משתמש ב- UserDao למשל להביא אותם מה- מַפָּה, ואז הוא מציג אותם למסוף.

בנוסף, עלינו גם להגדיר את המודולים pom.xml קוֹבֶץ:

 // קואורדינטות האב 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 

התלות של המודול מסבירה למדי. אז אנחנו רק צריכים למקם את המודול בתוך מודול Java. לכן, תחת mainappmodule / src / main / java מבנה ספריות, בואו נכלול את מתאר המודולים:

מודול com.baeldung.mainappmodule {דורש com.baeldung.entitypmodule; דורש com.baeldung.userdaopmodule; דורש com.baeldung.daopmodule; משתמש ב- com.baeldung.daopmodule.Dao; } 

לבסוף, בואו נוסיף מודול זה ל- POM ההורה:

 מודול ישות מודול משתמש ראשי מודול מודול 

עם כל מודולי ה- Maven של הילד שכבר קיימים, ומעטורים במודולים של Java, כך נראה מבנה הפרויקט:

multimodulemavenproject (ספריית השורש) pom.xml | - entitymodule | - src | - main | - java module-info.java | - com | - baeldung | - ישות 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. הפעלת האפליקציה

לבסוף, בואו נפעיל את היישום, מתוך IDE שלנו או מקונסולה.

כפי שניתן היה לצפות, עלינו לראות כמה מִשׁתַמֵשׁ אובייקטים שהודפסו למסוף בעת הפעלת היישום:

משתמש {name = Julie} משתמש {name = David} 

6. מסקנה

במדריך זה למדנו בצורה פרגמטית כיצד להכניס את Maven ו- JPMS לעבודה זו לצד זו, בפיתוח פרויקט בסיסי רב-מודולי של Maven המשתמש במודולי Java.

כרגיל, כל דגימות הקוד המוצגות במדריך זה זמינות ב- GitHub.