להכיר את גריידל (Gradle)

Gradle (מקור השם: עריסה, Cradle - כאשר האות הראשונה שונתה ל G עבור Groovy) הוא כלי Build נפוץ בעולם הג'אווה, וכלי ברירת-המחדל לפיתוח באנדרואיד.

Gradle הוא כלי Build מודרני, מלא פיצ'רים ואופטימיזציות - שנמצא דור או שניים לפנים מהחלופה העיקרית שלו: Maven. גריידל יודע לבצע Caching ו Incremental Build ברמות הפשטה שונות - ומסוגל לשפר מאוד את זמני ה Build של פרויקטים גדולים.

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

בניגוד למייבן המשתמש ב XML להגדיר את ה buildscript - בגריידל משתמשים ב DSL מבוסס שפת-תכנות. גרדייל תומכת ב Groovy-DSL ו Kotlin-DSL, כאשר בשנתיים האחרונות היא עושה מעבר לכיוון קוטלין, מכיוון שזו הולכת והופכת לנפוצה יותר ויותר (בניגוד ל Groovy - שקצת "נתקעה" במקום).

לו היו נותנים שם היום לפרויקט, נראה ש Gradle היה נקרא Kradle.

לגריידל אין מערכת Repositories משלה, והיא משתמשת בזו של מייבן, של ivy, או פשוט בתיקיה של מערכת הקבצים המקומית. זה יתרון גדול, מכיוון שכך אין תחרות בין "Maven Repositories" ל "Gradle Repositories".

מה גריידל יכולה להציע מול מייבן?

הבדלי ביצועים בין מייבן, גריידל, ובאזל. מקור: האתר של גריידל.

הדבר הראשון, וכנראה החשוב ביותר הוא ביצועים:

• בהרצה ראשונה, גריידל ומייבן יהיו דיי דומים. אולי גריידל תרוץ טיפה יותר מהר.
• בהרצה השנייה והלאה, ייכנסו לשימוש מנגנונים ייחודיים ל Gradle:
• Incremental Build - גריידל עוקבת אחר מערכת הקבצים ומקמפלת רק קבצים שהשתנו, או קבצים שתלויים בהם. 
• Config Cache ו Build Cache - שימוש חוזר בתוצרים (ברמות שונות) מהפעולות בילד קודמות. 
• תאורטית גם מייבן עושה זאת - אך בצורה משמעותית פחות יעילה.
• Gradle Daemon - גרדייל מחזיקה תהליך (process) של מערכת ההפעלה שממשיך לחיות ברקע, להחזיק caches מיידיים בזכרון ולהנות מאופטימיזציות של Java JIT compilation.

גריידל מספקת יותר גמישות:

• למייבן יש מחזור-חיים קבוע וקשיח, validate > compile > test > package > install, שלא ניתן לסטות ממנו, אלא ב"תרגילים". בגרדייל יש עץ של Tasks (כמו Compile או Test) שניתן לקנפג וקל הרבה יותר להתאים את שלבי הריצה לצרכים שלכם.
• למשל: בכדי לדלג על שלב הבדיקות או הקומפילציה ב Maven יש לעשות "תרגילים" שלא תמיד מצליחים. בגרדייל דילוג על שלבים זו אופציה מובנית.
• קל להגדיר Custom Tasks בגריידל - וזו גמישות רבת-עוצמה. המקבילה במייבן היא למצוא Plugin שמתאים בדיוק לצרכים, או לכתוב Plugin בעצמכם - שזה הרבה יותר מסובך
• גריידל מספקת ניהול תלויות עשיר וחכם הרבה יותר ממייבן - מה שמשמעותי בפרויקטים גדולים ו/או מורכבים.
• למשל: במייבן תלות במודול יגרור קבלת כל התלויות של אותה ספריה (propograted dependencies, שלעתים נקרא בטעות transitive dependencies). הדבר לא מאפשר לעקוב ולנהל במדויק תלויות של מודולים. 
  בגריידל אפשר לבחור או בגישה זהה למייבן, או בגישה מדויקת ונשלטת יותר.
• גריידל מממשת את העיקרון של Conventions over Configuration, ואין צורך באמת להשתמש בכל הכלים המתקדמים יותר שלה. קושי נפוץ של newcomers הוא להבחין אלו מנגנונים הם פשוטים ו straightforward, ואלו מנגנונים הם רבי-עוצמה, אך דורשים גם הבנה מעמיקה יותר.

גריידל היא מודרנית יותר:

• גריידל זוכה לתמיכה טובה יותר, ועדכונים תכופים יותר. למשל: כבר שנה וחצי כשיש בעיה בהרצה של JUnit 5 ב Failsafe של מייבן בצורה מקבילית - אך בגריידל הכל עובד כשורה מהגרסה הראשונה של Junit 5.
• לגריידל יש כלים תומכים משמעותיים וטובים יותר:
• Build Scan עוזר לנתח ולהבין בדיוק מה קרה ב Build. האם הגדרה מסוימת שרצינו אכן פעלה? לא צריך לנחש מתוך הלוגים - אפשר לבדוק בצורה ישירה.
• גריידל מספקת Build Scan רזה יותר גם למייבן - בעיקר בכדי לתמוך במעבר ולוודא שה Build בגריידל מכסה את כל מה שקרה במייבן.
• Continuous Build - גרדייל יכול להאזין למערכת הקבצים ולקמפל את הקוד תוך כדי שאתם עובדים.
• Gradle Profiler - שעוזר למצוא bottlenecks בבילד ולשפר אותם. ניתן לגשת לתוצאות שלו בתוך ה Build Scan.
• Gradle Build Debugger - בגלל שה build Script הוא שפת תכנות - אפשר ממש לדבג את תהליך הבילד כדי לנתח תקלות קשות-להבנה.
• Gradle Enterprise - הם סט של יכולות נוספות שחברת Gradle מספקת בתשלום - כמו Central build Cache (שימוש משותף בתוצרים: מפתח אחד קימפל מודול, כל השאר יכולים להשתמש בתוצר), או כלי Diagnostic ו Analytics משופרים לבילד ולהרצת הבדיקות.
• נטפליקס, היא תורמת גדולה של Gradle Plugins. רבים מהם היו הבסיס לפיצ'רים שהיום הם סטנדרטיים בגריידל.
• Gradle Wrapper (שמירת תאימות מדויקת של גרסת גריידל בין מפתחים) הוא כלי פופולארי בגריידל, אך שווה לציין שהוא קיים גם במייבן (אם כי שם הוא פחות נפוץ בשימוש).

התייחסות מהירה לבאזל

ב 2015 שחררה גוגל, את כלי ה Build שלה כפרויקט קוד פתוח, ולאחרונה הוא הפך ל GA.

• Bazel ו Gradle דומות זו לזו, יותר משהן דומות ל Maven או Ant.
• גריידל מספקת גמישות רבה יותר, באזל היא יותר מובנה.
• באזל בנויה יותר מסביב לניהול מרכזי (למשל: ניהול גרסאות של תלויות) בעוד גריידל לא לוקחת הנחות כאלו, ותומכת טוב יותר במציאות מבוזרת של שליטה.
• לגרדייל יש קהילה גדולה יותר, ובגרות גדולה יותר - במיוחד בעולם ה JVM. סיכוי טוב שקהילות כמו Go ו ++C יזכו לתמיכה טובה יותר בבאזל.
• היכולת להשתמש ב Cache מרכזי ומשותף היא יכולת ליבה של Bazel (שעליה מתבססים במידה הביצועים הטובים של הספריה) בעוד ב Gradle זו יכולת פרמיום בתשלום (Gradle Enterprise).
• בסה"כ באופן דיי עקבי (מסקירת מאמרים ומבחנים) Gradle מהירה יותר מ Bazel - גם כאשר משתמשים ב Build Cache מרכזי.
• מבחני ביצועים לא מעטים משווים את שתי התצורות בגרסה החינמית שלהן - ואז ל Bazel יש יתרון משמעותי על יכולת שב Gradle היא בתשלום (Central Build Cache).
• הנה מאמר מ 2015 של יוצרי גריידל שמנתחים את באזל.

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

הפוסט שלי נכתב על גריידל, שנראה שתמשיך להיות בטווח הנראה לעין הסביבה המתקדמת והמקובלת בעולם ה JVM. בעולמות הללו לגריידל יש עדיין יתרון משמעותי - וקהילות לא מתחלפות כ"כ מהר. חשוב לציין שבאזל היא רענון חשוב בעולם כלי ה Build, ובוודאי היא מעניינת יותר בעולמות ה Go וה ++C כבר עכשיו.

תכל'ס

כשמתחילים לקרוא על גריידל, מגיעים מהר מאוד לחומר על כתיבה של Custom Tasks או Dependency Management - שני נושאים יחסית מתקדמים ומלאי-אפשרויות.

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

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

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

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

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

Maven	Gradle
Pom.xml, Where:   Properties section   Modules section        DependencyManagement section   Most other sections	build.gradle.kts Mapping to:   gradle.properties file   settings.gradle.kts file   dependencies.kts file (a convention)   java-conventions.gradle.kts (file per language being compiled)
pom.xml file (what happens when we build)	build script (that comprised of multiple files)
Plugin	Task
-  (there is one fixed build flow)	Plugin (describes build flow)
Goal	Lifecycle Task
Module	(sub) project
Dependency scope	Dependency configuration
Profile	Custom Task or Custom Properties.gradle file (depends what the profile does).
“Install” (to maven repo)	“publication” (to whatever repo)
"package”	“assemble”

בואו נראה מבנה של קובץ בילד מינימלי (שם הקובץ הוא: build.gradle.kts. הסיומת kts מציינת שזה kotlin script, ולא Groovy - שמגיע ללא סיומת):

1. אנו מייבאים את הפלאגין של Java. 
1. בגריידל, Plugin מביא איתו שורה של Tasks ו Lifecycle Tasks (ועוד הגדרות רבות) - ובעצם קובע את השלבים השונים ב build והסדר ביניהם. במייבן ניסו לבנות תהליך אחד גנרי לכל שפות-התכנות, למרות שלשפות שונות (JavaScript, ++C) - יש צרכים שונים. בגריידל לרוב יהיה לנו בפרויקט Plugin אחד שיגדיר את ליבת התהליך ויספק גם את ה Tasks הנדרשים (Compile, Test, Jar, וכו' - המתאימים לשפה / תהליך)
   בנוסף אולי נרצה להשתמש ב Plugins נוספים כמו: למשל War, PMD, או Reports - ולהרחיב את התהליך.
2. ה default scope שלנו ברמה הגבוהה ביותר היא אובייקט הפרויקט, וכך אנו קובעים properties מסוימים על הפרויקט.
3. כאן אנו קובעים באלו Repositories לחפש את ה dependencies שלנו. כמו במייבן, אפשר ומומלץ לקבוע כמה repositories בכדי שיהיה גיבוי (לא עשינו את זה בדוגמה) - והחיפוש יעשה ע"פ הסדר בו נרשמו.
1. במקום לספק את ה URL ל jCenter, אנו יכולים להשתמש בפונקציה שמסופקת ע"י גריידל ומחזירה אובייקט Repository עם ה URL הנכון (קיימים כאלו ל repositories נפוצים). פחות מקום לטעויות.
4. כאן אנו נכנסים ל scope של ה Java Plugin (שהגדרנו בתחילת הקובץ) - ומוסיפים לו הגדרות.
1. כברירת מחדל, גריידל תשתמש ב build בגרסת הג'אווה שמריצה אותה. זה יכול ליצור חוסר עקביות אם במחשבים שונים מריצים את הבילד בגרסאות ג'אווה שונות.
2. בכדי "ליישר" את תהליך הבילד בצורה מדויקת יותר, אנו יכולים להגדיר לגריידל באזו גרסת ג'אווה להשתמש בתהליך הבילד. ה toolchain עוזר בקלות רבה לקנפג ולטפל בהגדרה של הגרסה שבחרנו. אם לא מצליחים למצוא מקומית את הגרסה המתאימה - ה toolchain יוריד לצורך ה build עותק מקומי של גרסת הגא'ווה שנבחרה.
3. גם אם אתם מתכנתים בג'אווה 8 (ממגבלות מוכרות), הרצה של תהליך הבילד בגרסה מתקדמת יותר - יכולה להאיץ אותו מעט.
5. כאן אנו נכנסים ל scope של ה tasks בפרויקט. אמנם אנו רוצים להתייחס ל Tasks שהגיעו מה Java Plugin, אך מרגע שהוספנו את ה Java Plugin והוא רשם את ה Tasks שלו - הם כבר לא משויכים אליו, אלא פשוט רשמים בפרויקט.
1. ספציפית יש כאן כתיבה מקוצרת בשורה אחת להכנס גם ל scope של ה test plugin.
2. ה Test Plugin תומך גם ב Junit וגם ב TestNG - ועלינו לציין לו במי להשתמש. הכל עטוף בפונקציות פשוטות ובטוחות לשימוש.
3. בניגוד ל Maven בו יש שני Plugins: גם Surefire (לבדיקות יחידה) ו Failsafe (לבדיקות אינטגרציה) - בגריידל ה Java Test Tasks מספק את שני הצרכים, וניתן פשוט לקבוע בהגדרות אם לעצור בכשלון ראשון - או לא. אם אחנו רוצים להגדיר שלב של "בדיקות יחידה איטיות" - קל לעשות זאת ע"י שימוש חוזר ב Test Task.
6. אנו צריכים להגדיר את התלויות לגרסה הספציפית של Junit שבה אנו רוצים להשתמש. לא פינקו אותנו ב wrapper לקונפיגורציה הזו. כמו במייבן - הגדרה של dependency בקובץ הראשי תשפיע על כל תתי-הפרויקטים (במייבן: מודולים) שלו.
1. ההגדרה הזו מקבילה במייבן לתחביר הבא:
   
   
   
   
   אני מניח שלא היה לכם קשה לעשות את המיפוי הבסיסי.
2. מהן הפונקציות הללו,()testImplenentation ו ()testRuntimeOnly?
   נסביר עליהן בהמשך.

The Java Plugin

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

• Tasks - בהם נוכל להשתמש.
• LifeCycle Tasks (במייבן: "Goals") - אליהם Plugins שונים יוכלו להתחבר, ולחבר Tasks שונים.
• מבנה התיקיות של קוד המקור (במקרה זה ה Java Plugin שומר על הקונבנציה המורכת לנו ממייבן)
• Dependency Management (כללים)  - כללים כיצד תלויות מנוהלות. מכיוון שלסביבות פיתוח שונות (Go, ++C, JVM) יש צרכים שונים - נתנו בגריידל ל Plugin להגדיר את הכללים המדויקים לניהול התלויות. 
  גריידל מספקת תשתית/כלים עליהם כל Plugin יכול לבנות את המודל שהוא זקוק לו.

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

ל Java Plugin יש כמה הרחבות סטנדרטיות:

• Java Library Plugin - עבור build script של ספריה המופצת לקהל רחב כספריה.
• Java Application Plugin - עבור build script של אפליקציה. מוסיף Tasks כגון start או install. הוא מתאים הן לכתיבת שרת או אפליקציה שולחנית.
• Java Platform Plugin - לכתיבה של סט ספריות קשורות (למשל: Junit 5 מורכב מכמה תתי-פרויקטים, הקשורים זה לזה)
• גרסאות ספציפיות ל Groovy ו Scala - המרחיבות

ייתכן והיה נכון יותר לקרוא לו "JVM Plugin".

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

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

מחזור החיים של בילד ב Java Plugin בגריידל

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

בניגוד ל make, ant, וכלים אחרים שהיו מקובלים קודם לכן והיו חסרי-מבנה סטנדרטי - מייבן הגדירה מבנה סטנדרטי - שעזר להשריש best practices בתהליכי build, ולהפוך אותם לסטנדרטיים ומאורגנים יותר.

מייבן הגדירה שלושה Lifecycles (נקרא להם build, clean, site), שבכל Lifecycle יש שורה של צעדים קבועים (להלן: "Goals"). כל Plugin (המספקים יכולות) מגדיר באלו צעדים הוא יכול להשתתף (למשל: Fail-Safe יכול להתחבר ל verify או integration-test) ואז המפתח ראשי לחבר אותו לאחד או יותר מהצעדים הנתמכים.

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

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

למשל, כאשר אנו מריצים את המשימה classes (המקבילה ל compile במייבן), המשימה תגרום להרצה של המשימות compileJava ו processsResources - ורק אז תרוץ בעצמה.

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

כפי שאתם יכולים לראות בתרשים, משימות בגריידל מסווגות למשימות רגילות (עושות משהו ; בכתום) ומשימות Lifecycle (באדום), הנועדו לשמש כעוגן / מבנה לתהליך ה build.

למשל, המשימות assemble, clean, build ו check (באדום מודגש) הן משימות Lifecycle של ה base plugin בגריידל. כלומר: הן צפויות להיות נוכחות בכל מחזור חיים כלשהו. כמפתח Task אני יכול להסתמך על כך שהן יהיו נוכחות - ולבקש שהן ירשמו ל Task שלי כתלות.

לדוגמה, ה CheckStyle Plugin (כלי לבדיקות קוד סטטיות בג'אווה) רושם למשימה Check תלות בכל ה Tasks של ה Plugin - כך שהרצה של המשימה Check תפעיל אותו. אם לפני הרישום המשימות Check ו Test עשו אותו הדבר, לאחר הרישום - יש ביניהן הבדל.

משימות ה Lifecycle מייצרות סטנדרטיזציה ומבנה כדי שה Builds יהיו פשוטים ומובנים יותר.

כאשר מדובר ב Multi-project build (המקבילה של modules במייבן), כל הרצה של משימה על הפרויקט הראשי - תריץ את אותה המשימה על כל ה sub-projects (כמו במייבן).

Dependency Configurations

זוכרים את התלויות שהגדרנו ל JUnit5 ב build script שהצגנו למעלה?

השתמשנו בפונקציות ()testImplenentation ו ()testRuntimeOnly - על מנת להגדיר תלויות.

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

אנו רוצים למשל שקבצים וספריות מסוימות (למשל: ספריות Mocking) יהיו זמינות רק כאשר מריצים בדיקות, בעוד אנו לא מעוניינים שהקוד בפרודקשיין יהיה תלוי בהן, או יארוז אותן.

היכולת להפריד בין קוד "לבדיקות" לקוד "פרודקטיבי" מתבטאת בגריידל בשני גרפי תלויות:

גרף התלויות של הבדיקות ("testImplementation") יורש את כל התלויות שהוגדרו בגרף של הקוד הפרודקטיבי ("implementation") - ויכול להוסיף עליהן תלויות נוספות.

הפונקציות ()testImplenentation ו ()testRuntimeOnly - פשוט רושמות תלות בגרף תלויות. עדיין לא הצגנו את גרף התלויות של testRuntimeOnly.

בגריידל התלות ברירת-המחדל / המומלצת היא "implementation". יש תלות בסיסי נוספת לקוד פרודקטיבי הנקראת "api" - והיא מדמה את ההתנהגות ברירת-המחדל של מייבן (מה שנקרא במייבן "compile scope"):

נניח שאני כותב ספריה (להלן "My Library") שאפליקציה מסויימת משתמשת בה.

כאשר אני יוצר תלות מסוג "api" בספרייה Jackson, משמע שאני הופך אותה לחלק מה API שלי, ובעצם מעביר (propogate) לאפליקציה את התלות כאילו היא שלה. מעכשיו קוד באפליקציה יכולה להשתמש ב Jackson כאילו ייבאה אותה בעצמה.

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

לשימוש ב api יש תופעה שלילית שנקראת Dependency Pollution:

• קוד האפליקציה יכול להשתמש בקוד מספריות שלא הייתה כוונה להשתמש בהן.
• המקרה הזה בעייתי במיוחד בקוד פנימי שלנו, שאנו רוצים במפורש להימנע מהשימוש בו - אך מפתחים עשויים לא לשים לב (כי ה package name תואמים).
• בשל האופי הטרנזיטיבי של התלויות, מרחב הקוד שאני שחשוף לשימוש ע"י קוד האפליקציה עשוי להיות גדול מאוד: האפליקציה תלויה ישירות ב 3 ספריות, אך ב 50 ספריות בצורה טרנזיטיבית - הוא תסריט נפוץ.
• יש עבודה מיותרת לתהליך ה build - בהבאת כל הספריות, טרנזיטיבית, ל classpath בזמן קומפילציה.
• יש עבודה מיותרת לתהליך ה build - בכך שכל שינוי קוד בספריה שהובאה טרנזיבית, מעלה ספק אולי צריך לקמפל את הספריות שתלויות בו (טרנזיטיבית) - וכך קשה לבסס build cache יעיל.

בקיצור: ההעדפה בתלות מסוג "implementation" חשובה הן מבחינת הנדסת-תוכנה, והן משיקולי ביצועים של ה build. 

אם אתם רגילים לעבוד במייבן "הסלחנית" במובן של תלויות - תתחילו להתרגל.

בטווח הבינוני - ארוך, בהחלט משתלם להתרגל להגדרות המדויקות יותר של התלויות כ "implementation". בבאזל, למשל, הגדרת התלויות דורשות דיוק רב אף יותר.

--

בגריידל יש מנגנון נוסף, המתבטא ב Dependency Configuration בשם "runtimeOnly" ו "compileOnly" הקבילים ל scopes במייבן בשם runtime ו provided - בהתאמה.

התלויות הללו מאפשרות לנו להיות תלויים בזמן הקומפילציה ב API בלבד (לא לבלבל עם ה "api dependency configuration"), ובזמן ריצה להביא מימוש ספציפי של אותו ה API - תוך כדי שאנו מבטיחים שאנו לא יוצרים תלות במימוש הספציפי.

 

למשל: ספריית SLF4J, מספקת API לקומפילציה בלבד וגם מימושים הכוללים את ה API + יישום ספציפי (למשל LogBack או log4J12).

בכדי להבטיח חוסר תלות ביישום ספציפי - אנו רוצים לא לכלול את המימוש הנוכחי שבחרנו בזמן הקומפיציה - אלא רק בזמן ריצה. אם כך עלינו להוסיף את ה SLF4J API ב "compileOnly" ואת המימוש העכשוי - ב "runtimeOnly".

--

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

ספריית JUnit5 הפרידה את ה API לספריה אחת (להלן "testImplementation", אנו רוצים אותו זמין רק לבדיקות) ואת מנוע הבדיקות - שיהיה זמין רק בעת הרצת הבדיקות ("testRuntimeOnly"). 

כלומר: המקרה של JUnit 5 מעט שונה מזה של SLF4J - אבל קיימות גם וריאציות נוספות.

יצרתי סיכום של ה Dependencies Configurations הזמינים לנו בגריידל + Java Plugin:

הורשה משמע שכל תלות שהוספנו לאב - זמינה גם לבן. הקוביות הצבעוניות מתארות מה עושים עם כל גרף תלויות בפועל. אציין שוב ש "api" הן התלויות הכלליות ביותר - ושמומלץ להימנע משימוש בה עד כמה שאפשר.

סיכום

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

שיהיה בהצלחה!

-----

קישורים רלוונטיים:

השוואת ה Dependency Configuration בגריידל ל Dependency Scopes במייבן.