streamalism.org

1. הקדמה

במדריך זה נבחן כיצד לבנות פרויקט Spring Boot לקובץ JAR דק, באמצעות קפיץ-מגף-משגר דק פּרוֹיֶקט.

Spring Boot ידוע בפריסת ה- JAR ה"שמנה "שלו, שם חפץ הפעלה יחיד מכיל את קוד היישום וגם את כל התלות שלו.

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

2. תנאים מוקדמים

קודם כל, אנחנו צריכים פרויקט Spring Boot, כמובן. במאמר זה נבחן את Maven builds ואת Gradle build בתצורות הנפוצות ביותר שלהם.

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

2.1. פרויקטים של Maven

בפרויקט Boot שנבנה עם Maven, עלינו להגדיר את התוסף Spring Boot Maven בפרויקט שלנו pom.xml הקובץ, האב, או אחד מאבותיו:

 org.springframework.boot spring-boot-maven-plugin 

הגירסה של תלויות Spring Boot נקבעת בדרך כלל על ידי שימוש ב- BOM או בירושה מ- POM הורה כמו בפרויקט ההתייחסות שלנו:

 org.springframework.boot spring-boot-starter-parent 2.2.2.RELEASE 

2.2. פרויקטים של Gradle

בפרויקט אתחול שנבנה עם Gradle, יהיה לנו את התוסף Boot Gradle:

buildscript {ext {springBootPlugin = 'org.springframework.boot: spring-boot-gradle-plugin' springBootVersion = '2.2.2.RELEASE'} מאגרים {mavenCentral ()} תלות {classpath ("$ {springBootPlugin}: $ {springBootVersion } ")}} // elided להחיל תוסף: 'org.springframework.boot' להחיל תוסף: 'io.spring.dependency-management' springBoot {mainClassName = 'com.baeldung.DemoApplication'}

שים לב שבמאמר זה נשקול רק פרויקטים של Boot 2.x ואילך. משגר הדק תומך גם בגרסאות קודמות, אך הוא דורש תצורת Gradle שונה במקצת אותה אנו משמיטים לפשטות. אנא עיין בדף הבית של הפרויקט לפרטים נוספים.

3. כיצד ליצור JAR דק?

משגר ה- Spring Boot Thin Launch הוא ספרייה קטנה הקוראת את תלות החפץ מקובץ המאוגד בארכיון עצמו, מורידה אותם ממאגר Maven ולבסוף משיקה את המחלקה הראשית של היישום.

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

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

4. שימוש בסיסי

בואו נראה כעת כיצד לבנות JAR "דק" מיישום Spring Boot הרגיל שלנו.

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

4.1. פרויקטים של Maven

בפרויקט Maven עלינו לשנות את הצהרת תוסף האתחול (ראה סעיף 2.1) כך שיכלול תלות בפריסה ה"דקה "המותאמת אישית:

 org.springframework.boot spring-boot-maven-plugin org.springframework.boot.experimental spring-boot-thin-layout 1.0.11. שחרור 

המשגר ​​יקרא תלות מה- pom.xml קובץ ש- Maven מאחסן ב- JAR שנוצר ב- META-INF / maven מַדרִיך.

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

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

4.2. Maven ותלות: דק. נכסים

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

המוג'ו (תוסף) לכך הוא spring-boot-thin-maven-plugin: מאפיינים, וכברירת מחדל, הוא מוציא את דק. נכסים קובץ src / main / resources / META-INF, אך אנו יכולים לציין את מיקומו באמצעות ה- פלט דק תכונה:

$ mvn org.springframework.boot.experimental: spring-boot-thin-maven-plugin: מאפיינים -Dthin.output =.

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

4.3. פרויקטים של Gradle

בפרויקט Gradle במקום זאת אנו מוסיפים תוסף ייעודי:

buildscript {ext {// ... thinPlugin = 'org.springframework.boot.experimental: spring-boot-thin-gradle-plugin' thinVersion = '1.0.11. RELEASE'} // ... תלות {//. .. classpath ("$ {thinPlugin}: $ {thinVersion}")}} // elided להחיל תוסף: 'maven' להחיל תוסף: 'org.springframework.boot.experimental.thin-launcher'

כדי להשיג מבנה דק, נגיד ל- Gradle לבצע את ה- thinJar מְשִׁימָה:

~ / projects / baeldung / spring-boot-gradle $ ./gradlew thinJar

4.4. דרגה ותלות: pom.xml

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

הסיבה לכך היא, שכמו במקרה של Maven שראינו קודם, החפץ יכיל ויעשה שימוש ב- pom.xml קובץ המונה את תלות היישום. ה pom.xml קובץ נוצר על ידי משימה שנקראת thinPom, שהיא תלות מרומזת של כל משימה בצנצנת.

אנו יכולים להתאים אישית את הנוצר pom.xml קובץ עם משימה ייעודית. כאן פשוט נשכפל את מה שהתוסף הדק כבר עושה באופן אוטומטי:

משימה createPom {def basePath = 'build / resources / main / META-INF / maven' doLast {pom {withXml (dependencyManagement.pomConfigurer)} .writeTo ("$ {basePath} / $ {project.group} / $ {project. שם} /pom.xml ")}}

כדי להשתמש במנהג שלנו pom.xml קובץ, אנו מוסיפים את המשימה לעיל לתלות של משימת הצנצנת:

bootJar.dependsOn = [createPom]

4.5. דרגה ותלות: דק.קניינים

אנחנו יכולים גם ש- Gradle ייצור a דק. נכסים קובץ ולא pom.xml, כפי שעשינו קודם עם מייבן.

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

bootJar.dependsOn = [thinProperties]

5. אחסון תלות

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

בפרט, ה- Thin Launcher משתמש בתשתית Maven כדי לפתור תלות, כך:

1. הוא בודק את המאגר המקומי של Maven, אשר כברירת מחדל נמצא בו ~ / .m2 / מאגר אך ניתן להעבירו למקום אחר;
2. לאחר מכן, הוא מוריד תלות חסרה מ Maven Central (או מכל מאגר מוגדר אחר);
3. לבסוף, הוא שומר אותם במאגר המקומי, כך שהוא לא יצטרך להוריד אותם שוב בפעם הבאה שנפעיל את היישום.

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

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

5.1. הפעלת האפליקציה לחימום

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

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

$ java -Dthin.dryrun = true -jar my-app-1.0.jar

שים לב, בהתאם למוסכמות Spring Boot, אנו יכולים להגדיר את ה- -דין.dריון נכס גם עם –רזה.dריון טיעון שורת פקודה ליישום או עם THIN_DRYRUN נכס מערכת. כל ערך למעט שֶׁקֶר יורה למשגר הדק לבצע ריצה יבשה.

5.2. אריזת התלות במהלך הבנייה

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

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

הפורמט שבו התוסף Thin for Maven ו- Gradle מחליף את התלות במהלך בנייה זהה למאגר מקומי של Maven:

שורש / מאגר / com / net / org / ...

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

$ java -jar my-app-1.0.jar --thin.root = my-app / deps

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

5.3. אריזת התלות עם Maven

כדי ש- Maven יארז לנו את התלות, אנו משתמשים ב- לִפְתוֹר המטרה של spring-boot-thin-maven-plugin. אנו יכולים להפעיל אותו באופן ידני או אוטומטי pom.xml:

 org.springframework.boot.experimental spring-boot-thin-maven-plugin $ {thin.version} לפתור פסק שקר 

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

5.4. אריזת התלות עם Gradle

אם אנו משתמשים ב- Gradle עם ה- משגר דק תוסף, במקום זאת, יש לנו רזה פתרון המשימה זמינה. המשימה תשמור את היישום ואת התלות שלו ב- לבנות / דק / שורש / מדריך, בדומה לתוסף Maven של הסעיף הקודם:

$ gradlew thin פתרון

לידיעתך, בעת כתיבת שורות אלה, משגר דק לתוסף יש באג שמונע לשמור את התלות אם דק.קניינים משמש: //github.com/dsyer/spring-boot-thin-launcher/issues/53.

6. מסקנות וקריאה נוספת

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

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

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

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