מדריך למודולריות Java 9

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

Java 9 מציג רמה חדשה של הפשטה מעל חבילות, הידועה רשמית בשם Java Platform Module System (JPMS), או בקיצור "מודולים".

במדריך זה נעבור על המערכת החדשה ונדון בהיבטים השונים שלה.

אנו גם בונים פרויקט פשוט להדגמת כל המושגים שנלמד במדריך זה.

2. מהו מודול?

ראשית כל, עלינו להבין מהו מודול לפני שנוכל להבין כיצד להשתמש בהם.

מודול הוא קבוצה של חבילות ומשאבים הקשורים זה לזה יחד עם קובץ מתאר מודולים חדש.

במילים אחרות, זוהי הפשטה של ​​"חבילה של חבילות Java" המאפשרת לנו להפוך את הקוד שלנו לשימוש חוזר עוד יותר.

2.1. חבילות

החבילות בתוך מודול זהות לחבילות Java בהן השתמשנו מאז הקמת Java.

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

מלבד ארגון הקוד שלנו, חבילות משמשות לקביעת איזה קוד נגיש לציבור מחוץ למודול. אנו נבזבז זמן רב יותר על כך בהמשך המאמר.

2.2. אֶמְצָעִי

כל מודול אחראי על המשאבים שלו, כמו קובצי מדיה או קבצי תצורה.

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

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

2.3. מתאר המודול

כשאנחנו יוצרים מודול, אנו כוללים קובץ מתאר המגדיר כמה היבטים של המודול החדש שלנו:

  • שֵׁם - שם המודול שלנו
  • תלות - רשימה של מודולים אחרים שמודול זה תלוי בהם
  • חבילות ציבוריות - רשימה של כל החבילות שאנו רוצים נגיש מחוץ למודול
  • שירותים מוצעים - אנו יכולים לספק יישומי שירות הניתנים לצריכה על ידי מודולים אחרים
  • שירותים נצרכים - מאפשר למודול הנוכחי להיות צרכן של שירות
  • אישורי השתקפות - מאפשר במפורש לכיתות אחרות להשתמש בבבואה כדי לגשת לחברים הפרטיים בחבילה

כללי שמות המודולים דומים לאופן שאנחנו קוראים לחבילות (מותרות נקודות, מקפים לא). זה מאוד נפוץ לעשות בסגנון פרוייקט (my.module) או Reverse-DNS (com.baeldung.mymodule) שמות סגנון. נשתמש בסגנון פרויקט במדריך זה.

עלינו לרשום את כל החבילות שאנו רוצים להיות פומביות מכיוון שבברירת המחדל כל החבילות הן פרטיות של המודולים.

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

בהמשך המאמר, נבחן דוגמאות לשימוש בקובץ מתאר המודולים.

2.4. סוגי מודולים

ישנם ארבעה סוגים של מודולים במערכת המודולים החדשה:

  • מודולי מערכת- אלה המודולים המפורטים כאשר אנו מריצים את רשימת-מודולים פקודה לעיל. הם כוללים את מודולי Java SE ו- JDK.
  • מודולי יישום - מודולים אלו הם מה שאנו בדרך כלל רוצים לבנות כאשר אנו מחליטים להשתמש במודולים. הם נקראים ומוגדרים בקומפילציה module-info.class קובץ הכלול ב- JAR שהורכב.
  • מודולים אוטומטיים - אנו יכולים לכלול מודולים לא רשמיים על ידי הוספת קבצי JAR קיימים לנתיב המודול. שם המודול ייגזר משם ה- JAR. למודולים אוטומטיים תהיה גישה מלאה לקריאה לכל מודול אחר הנטען על ידי הנתיב.
  • מודול ללא שם - כאשר מחלקה או JAR נטענים על שביל הכיתה, אך לא על נתיב המודול, הם מתווספים אוטומטית למודול ללא שם. זהו מודול של הכל כדי לשמור על תאימות לאחור עם קוד Java שנכתב בעבר.

2.5. הפצה

ניתן להפיץ מודולים בשתי דרכים: כקובץ JAR או כפרויקט מקומט "מפוצץ". זה, כמובן, זהה לכל פרויקט ג'אווה אחר ולכן זה לא צריך להיות מפתיע.

אנו יכולים ליצור פרויקטים מרובי-מודולים המורכבים מ"יישום ראשי "ומספר מודולי ספרייה.

עלינו להיות זהירים מכיוון שאנחנו יכולים להחזיק רק מודול אחד לכל קובץ JAR.

כאשר אנו מגדירים את קובץ ה- build שלנו, עלינו לוודא לצרף כל מודול בפרויקט שלנו כצנצנת נפרדת.

3. מודולי ברירת מחדל

כאשר אנו מתקינים את Java 9, אנו יכולים לראות כי ל- JDK יש כעת מבנה חדש.

הם לקחו את כל החבילות המקוריות והעבירו אותן למערכת המודולים החדשה.

אנו יכולים לראות מה הם המודולים הללו על ידי הקלדה בשורת הפקודה:

java --list-modules

מודולים אלה מחולקים לארבע קבוצות עיקריות: java, javafx, jdk, ו נבואה.

ג'אווה המודולים הם שיעורי ההטמעה של מפרט הליבה של שפת SE.

javafx המודולים הם ספריות ממשק המשתמש של FX.

כל מה שצריך הג'וינט עצמו נשמר ב jdk מודולים.

ולבסוף, כל מה שהוא ספציפי לאורקל נמצא ב נבואה מודולים.

4. הצהרות מודול

כדי להגדיר מודול, עלינו לשים קובץ מיוחד בשורש החבילות שלנו module-info.java.

קובץ זה ידוע כמתאר המודולים ומכיל את כל הנתונים הדרושים לבנייה ושימוש במודול החדש שלנו.

אנו בונים את המודול עם הצהרה שגופה ריק או מורכב מהוראות המודול:

מודול myModuleName {// כל ההוראות הן אופציונליות}

אנו מתחילים את הצהרת המודול עם ה- מודול מילת מפתח, ואנחנו עוקבים אחרי זה עם שם המודול.

המודול יעבוד עם הצהרה זו, אך לרוב נצטרך מידע נוסף.

שם נכנסות הוראות המודול.

4.1. דורש

ההנחיה הראשונה שלנו היא דורש. הוראת מודול זו מאפשרת לנו להכריז על תלות במודול:

מודול my.module {דורש module.name; }

עַכשָׁיו, המודול שלי יש ל גם זמן ריצה וגם תלות בזמן הידור עַל module.name.

וכל הסוגים הציבוריים המיוצאים מתלות נגישים באמצעות המודול שלנו כאשר אנו משתמשים בהנחיה זו.

4.2. דורש סטטי

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

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

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

מודול my.module {דורש module.name סטטי; }

4.3. דורש מעבר

בדרך כלל אנו עובדים עם ספריות בכדי להקל על חיינו.

אבל, עלינו לוודא שכל מודול שמביא את הקוד שלנו יביא גם את התלות הנוספת ה'טרנזיטיבית 'האלה או שהם לא יעבדו.

למרבה המזל, אנו יכולים להשתמש ב- דורש מעבר הנחיה לאלץ כל צרכנים במורד הזרם לקרוא גם את התלות הנדרשת שלנו:

מודול my.module {דורש module.name מעבר. }

עכשיו, כאשר מפתח דורש my.module, הם גם לא יצטרכו לומר דורש module.name שהמודול שלנו עדיין יעבוד.

4.4. יצוא

כברירת מחדל, מודול אינו חושף אף אחד מה- API שלו למודולים אחרים. זֶה אנקפסולציה חזקה היה אחד ממניעי המפתח ליצירת מערכת המודולים מלכתחילה.

הקוד שלנו מאובטח משמעותית, אך כעת עלינו לפתוח במפורש את ה- API שלנו בפני העולם אם אנו רוצים שהוא יהיה שמיש.

אנו משתמשים ב- יצוא הנחיה לחשיפת כל חברי הציבור בחבילה שצוינה:

מודול my.module {מייצא com.my.package.name; }

עכשיו, כשמישהו עושה זאת דורש את my.module, תהיה להם גישה לסוגי הציבור שלנו com.my.package.name חבילה, אך לא כל חבילה אחרת.

4.5. יצוא ... אל

אנחנו יכולים להשתמש יצוא ... אל לפתוח את השיעורים הציבוריים שלנו לעולם.

אבל, מה אם אנחנו לא רוצים שכל העולם ייגש ל- API שלנו?

אנו יכולים להגביל לאילו מודולים יש גישה לממשקי ה- API שלנו באמצעות ה- יצוא ... אל הוֹרָאָה.

דומה ל יצוא הנחיה, אנו מכריזים על חבילה כמיוצאת. אבל, אנו גם מציגים אילו מודולים אנו מאפשרים לייבא חבילה זו כ- דורש. בואו נראה איך זה נראה:

מודול my.module {ייצוא com.my.package.name ל- com.specific.package; }

4.6. שימושים

א שֵׁרוּת הוא יישום של ממשק ספציפי או מחלקה מופשטת שיכולה להיות מְאוּכָּל על ידי שיעורים אחרים.

אנו מייעדים את השירותים שהמודול שלנו צורך עם שימושים הוֹרָאָה.

ציין זאת את שם הכיתה אנחנו להשתמש הוא הממשק או המחלקה המופשטת של השירות, ולא מחלקת ההטמעה:

מודול my.module {משתמש class.name; }

עלינו לציין כאן שיש הבדל בין דורש הנחיה ו שימושים הוֹרָאָה.

אנו עשויים לִדרוֹשׁ מודול המספק שירות שאנחנו רוצים לצרוך, אך השירות מיישם ממשק מאחת התלות המעבר שלו.

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

4.7. מספק ... עם

מודול יכול להיות גם ספק שירות שמודולים אחרים יכולים לצרוך.

החלק הראשון של ההנחיה הוא מספק מילת מפתח. כאן אנו שמים את הממשק או את שם הכיתה המופשט.

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

הנה איך זה נראה ביחד:

מודול my.module {מספק ל- MyInterface MyInterfaceImpl; }

4.8. לִפְתוֹחַ

הזכרנו קודם כי אנקפסולציה הייתה מניע מניע לתכנון מערכת מודולים זו.

לפני Java 9, ניתן היה להשתמש בבבואה כדי לבחון כל סוג וחבר בחבילה, אפילו את ה- פְּרָטִי יחידות. שום דבר לא נסתם באמת, מה שיכול לפתוח כל מיני בעיות עבור מפתחי הספריות.

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

אם אנו רוצים להמשיך לאפשר השתקפות מלאה כפי שעשו גרסאות ישנות יותר של Java, נוכל פשוט לִפְתוֹחַ את כל המודול למעלה:

פתח את המודול my.module {}

4.9. נפתח

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

אבל זכרו, זה יפתח את החבילה בפני כל העולם, אז וודאו שזה מה שאתם רוצים:

מודול my.module {פותח com.my.package; }

4.10. נפתח ... ל

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

מודול my.module {פותח com.my.package ל- moduleOne, moduleTwo וכו '; }

5. אפשרויות שורת פקודה

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

אנו נשתמש בשורת הפקודה עבור הדוגמה המלאה שלנו למטה כדי לעזור לחזק את האופן שבו המערכת פועלת במוחנו.

  • נתיב-מודולאנו משתמשים ב- –מודול-נתיב אפשרות לציין את נתיב המודול. זו רשימה של ספריות אחת או יותר המכילות את המודולים שלך.
  • תוספות קריאות במקום להסתמך על קובץ הצהרת המודול, נוכל להשתמש בשורת הפקודה המקבילה ל- דורש הוֹרָאָה; –מוסיף קריאות.
  • תוספות יצואהחלפת שורת פקודה עבור יצוא הוֹרָאָה.
  • תוספות נפתחותהחלף את ה לִפְתוֹחַ סעיף בקובץ הצהרת המודול.
  • תוספותמוסיף את רשימת המודולים לקבוצת ברירת המחדל של המודולים
  • רשימת-מודוליםמדפיס רשימה של כל המודולים ומחרוזות הגרסה שלהם
  • מודול תיקון - הוסף או עקף שיעורים במודולים
  • גישה בלתי חוקית = היתר | להזהיר | להכחיש - או הרגע את האקפסולציה החזקה על ידי הצגת אזהרה גלובלית אחת, מראה כל אזהרה או נכשל עם שגיאות. ברירת המחדל היא לְהַתִיר.

6. נראות

עלינו להשקיע מעט זמן בדיבורים על נראות הקוד שלנו.

הרבה ספריות תלויות בהשתקפות כדי לחולל את הקסם שלהן (JUnit ו- Spring עולים בראשנו).

כברירת מחדל ב- Java 9, נעשה זאת רק יש גישה לשיעורים ציבוריים, שיטות ושדות בחבילות המיוצאות שלנו. גם אם אנו משתמשים בבבואה כדי לקבל גישה לחברים שאינם ציבוריים ולהתקשר setAccessible (נכון), לא נוכל לגשת לחברים אלה.

אנחנו יכולים להשתמש ב- לִפְתוֹחַ, נפתח, ו נפתח ... עד אפשרויות להעניק גישה לזמן ריצה בלבד לצורך השתקפות. הערה, זה זמן ריצה בלבד!

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

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

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

7. לשים את הכל ביחד

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

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

7.1. הגדרת הפרויקט שלנו

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

התחל ביצירת תיקיית הפרויקט:

mkdir module-project cd-module-project

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

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

לאחר מכן, אנו יוצרים ספריית מודולים:

mkdir מודולים פשוטים

הנה איך ייראה מבנה הפרויקט שלנו:

פרויקט מודול | - // src אם אנו משתמשים בחבילת ברירת המחדל | - // קבצי build עוברים גם ברמה זו | - מודולים פשוטים | - hello.modules | - com | - baeldung | - מודולים | - שלום | - ראשי .app | - com | - baeldung | - מודולים | - ראשי

7.2. המודול הראשון שלנו

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

תחת פשוט-מודולים ספריה, צור ספריה חדשה בשם שלום. מודולים.

אנו יכולים למנות זאת בכל מה שנרצה, אך לעקוב אחר כללי שמות החבילה (כלומר, תקופות להפרדת מילים וכו '). אנו יכולים אפילו להשתמש בשם החבילה הראשית שלנו כשם המודול אם אנו רוצים, אך בדרך כלל אנו רוצים להיצמד לאותו שם בו נשתמש כדי ליצור JAR של מודול זה.

תחת המודול החדש שלנו, אנו יכולים ליצור את החבילות שאנחנו רוצים. במקרה שלנו, אנו הולכים ליצור מבנה חבילה אחד:

com.baeldung.modules.hello

לאחר מכן, צור מחלקה חדשה בשם HelloModules.java בחבילה זו. אנו נשמור על קוד פשוט:

חבילה com.baeldung.modules.hello; מחלקה ציבורית HelloModules {ריק סטטי ציבורי doSomething () {System.out.println ("שלום, מודולים!"); }}

ולבסוף, ב שלום. מודולים ספריית שורשים, הוסף במתאר המודולים שלנו; module-info.java:

module hello.modules {יצוא com.baeldung.modules.hello; }

כדי לשמור על הדוגמה הזו פשוטה, כל מה שאנחנו עושים זה לייצא את כל חברי הציבור של com.baeldung.modules.hello חֲבִילָה.

7.3. המודול השני שלנו

המודול הראשון שלנו נהדר, אבל הוא לא עושה כלום.

אנו יכולים ליצור מודול שני המשתמש בו כעת.

תחת שלנו פשוט-מודולים ספריה, צור ספריית מודולים אחרת הנקראת main.app. נתחיל הפעם עם מתאר המודולים:

מודול main.app {דורש hello.modules; }

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

כעת אנו יכולים ליצור יישום המשתמש בו.

צור מבנה חבילה חדש: com.baeldung.modules.main.

כעת, צור קובץ מחלקה חדש בשם MainApp.java.

חבילה com.baeldung.modules.main; יבוא com.baeldung.modules.hello.HelloModules; class class MainApp {public static void main (String [] args) {HelloModules.doSomething (); }}

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

7.4. בניית המודולים שלנו

כדי לבנות את הפרויקט שלנו, אנו יכולים ליצור סקריפט bash פשוט ולהציב אותו בבסיס הפרויקט שלנו.

צור קובץ שנקרא compile-simple-modules.sh:

#! / usr / bin / env bash javac -d outDir - מודול-מקור-נתיב פשוט-מודולים $ (מצא פשוט-מודולים-שם "*. java")

ישנם שני חלקים לפקודה זו, ה- ג'אוואק ו למצוא פקודות.

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

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

ברגע שנפעיל פקודה זו, יהיה לנו outDir תיקייה עם שני מודולים מהודרים בפנים.

7.5. הפעלת הקוד שלנו

ועכשיו נוכל סוף סוף להריץ את הקוד שלנו כדי לוודא שמודולים עובדים כראוי.

צור קובץ נוסף בשורש הפרויקט: run-simple-module-app.sh.

#! / usr / bin / env bash java - module-path outDir -m main.app/com.baeldung.modules.main.MainApp

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

> $ ./run-simple-module-app.sh שלום, מודולים!

7.6. הוספת שירות

עכשיו שיש לנו הבנה בסיסית כיצד לבנות מודול, בואו נעשה את זה קצת יותר מסובך.

אנו הולכים לראות כיצד להשתמש ב- מספק ... עם ו שימושים הוראות.

התחל בהגדרת קובץ חדש ב- שלום. מודולים מודול בשם HelloInterface.java:

ממשק ציבורי HelloInterface {void sayHello (); }

כדי להקל על העניינים, אנו הולכים ליישם את הממשק הזה עם הקיים שלנו HelloModules.java מעמד:

מחלקה ציבורית HelloModules מיישמת את HelloInterface {public static void doSomething () {System.out.println ("שלום, מודולים!"); } חלל ציבורי sayHello () {System.out.println ("שלום!"); }}

זה כל מה שאנחנו צריכים לעשות כדי ליצור שֵׁרוּת.

כעת עלינו לומר לעולם שהמודול שלנו מספק שירות זה.

הוסף את הדברים הבאים שלנו module-info.java:

מספק com.baeldung.modules.hello.HelloInterface עם com.baeldung.modules.hello.HelloModules;

כפי שאנו רואים, אנו מצהירים על הממשק ואיזה מחלקה מיישמת אותו.

לאחר מכן, עלינו לצרוך זאת שֵׁרוּת. בשלנו main.app מודול, בואו נוסיף את הדברים הבאים שלנו module-info.java:

משתמש com.baeldung.modules.hello.HelloInterface;

לבסוף, בשיטה העיקרית שלנו אנו יכולים להשתמש בשירות זה באמצעות ServiceLoader:

שירותי Iterable = ServiceLoader.load (HelloInterface.class); שירות HelloInterface = services.iterator (). הבא (); service.sayHello ();

הידור והפעל:

#> ./run-simple-module-app.sh שלום, מודולים! שלום!

אנו משתמשים בהוראות אלה כדי להיות הרבה יותר מפורשות לגבי אופן השימוש בקוד שלנו.

נוכל להכניס את היישום לחבילה פרטית תוך חשיפת הממשק בחבילה ציבורית.

זה הופך את הקוד שלנו להרבה יותר מאובטח עם מעט מאוד תקורה נוספת.

קדימה ונסה כמה מההוראות האחרות כדי ללמוד עוד על מודולים וכיצד הם עובדים.

8. הוספת מודולים למודול ללא שם

תפיסת המודול ללא שם דומה לחבילת ברירת המחדל. לכן זה לא נחשב למודול אמיתי, אך ניתן לראות אותו כמודול ברירת המחדל.

אם כיתה אינה חברה במודול בעל שם, היא תחשב אוטומטית כחלק ממודול ללא שם זה.

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

בכללי, האפשרות להוסיף את המודולים שצוינו לערכת ברירת המחדל של מודולי השורש היא - להוסיף מודולים (,)* איפה הוא שם מודול.

לדוגמא, כדי לספק גישה לכולם java.xml.bind מודולים התחביר יהיה:

- להוסיף מודולים java.xml.bind

כדי להשתמש בזה ב- Maven, נוכל להטמיע את אותו הדבר ל- תוסף maven-compiler:

 org.apache.maven.plugins maven-compiler-plugin 3.8.0 9 9 --add-modules java.xml.bind 

9. מסקנה

במדריך נרחב זה התמקדנו וכיסינו את היסודות של מערכת Java 9 Module החדשה.

התחלנו לדבר על מה זה מודול.

לאחר מכן, דיברנו כיצד לגלות אילו מודולים כלולים ב- JDK.

כיסינו בפירוט את קובץ הצהרת המודול.

ריכזנו את התיאוריה על ידי דיבורים על טיעוני שורת הפקודה השונים שנצטרך לבניית המודולים שלנו.

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

כדי לראות קוד זה ועוד, הקפד לבדוק אותו ב- Github.