כל מה שרציתם לדעת על מייבן - "פרויקט ג'אווה מא' עד ת'"

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

בוא נדבר על מייבן

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

למה אנחנו צריכים את מייבן?

Maven הוא כלי לבניית פרויקטים, יחד עם Gradle ו-Ant. רק בגלל שאשתמש בו ב-JRTB (JavaRush Telegram Bot), אני רוצה לעדכן אתכם. כיום לא נוצר ולו פרויקט אחד ללא מערכת הרכבה, כי היא מפשטת את חיינו פי כמה. זה מאפשר:

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

באופן כללי, הוא עושה הרבה דברים, וכולם מועילים. אני אגיד את זה: למהנדסים מתחילים אין צורך לדעת את כל הפונקציונליות מכסה לכריכה. כאן, כמו ב-git, חשוב להבין את היסודות והמושגים הכלליים. זה מה שנעשה. עבורנו, Maven מתחיל עם קובץ XML בשורש הפרויקט שלנו בשם pom.xml . נעשה הכל בפועל, אז קודם כל ניצור את הפרויקט הראשון שלנו ב-JavaRush Community. כדי לעשות הכל בחוכמה, אשתמש בתבנית עבור המאגר , שם הדברים הבסיסיים שתיארתי פעם ב-JR כבר מוגדרים . כדי ליצור, עבור אל המאגר עם התבנית ולחץ על כפתור השתמש בתבנית זו : כתוצאה מכך, יש לנו את המאגר הראשון בקהילה שלנו :) אנו מורידים את הפרויקט באופן מקומי. כדי לעשות זאת, דרך הרעיון, עבור אל קובץ -> חדש -> פרויקט מבקרת גרסה . בחלון שמופיע הכניסו קישור לפרוייקט ב-Github (התוצאה תהיה טובה יותר אם כולם ייצרו את אותו הפרוייקט בנפרד ויעברו איתי את כל השלבים): לחצו על Clone , והפרוייקט משוכפל .

pom.xml הוא הראש של הכל

כל מה שאתה צריך נמצא ב-pom.xml. כל המידע על הפרויקט, היזם שלו ועל איזה מאגר מרוחק הפרויקט מאוחסן. בהתחלה, אנו מעוניינים בבלוקים הבאים: <project/> - זהו הבלוק הראשי, המכיל את כל המידע על הפרויקט. כל השאר יהיו בו באופן מפורש או טרנזיטיבי. בתוך תג הפתיחה כתוב משהו כזה:

<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://maven.apache.org/POM/4.0.0"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                     http://maven.apache.org/xsd/maven-4.0.0.xsd">

ובנוסף לכל השאר גם השורה הבאה כתובה בכל הפומניקים (הסלנג כביכול מ-pom.xml :)).

<modelVersion>4.0.0</modelVersion>

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

<groupId>com.github.romankh3</groupId>
<artifactId>image-comparison</artifactId>
<version>4.4.0-SNAPSHOT</version>
<packaging>jar</packaging>

<name>Image Comparison</name>

העיקר כאן:

• • groupId הוא המזהה של ארגון הפיתוח או המהנדס האישי. זה בדרך כלל התחום בסדר הפוך. כדוגמה, חשבון romankh3 ב-Github מתואר כאן. זה מאוד חשוב. נניח עבור המערכת האקולוגית של אביב זה com.springframework . כך תוכלו להבחין בין הפרויקט המקורי למזלג של מישהו אחר או פשוט בצירוף מקרים של שם הפרויקט.
• • artifaceId הוא כבר שם של פרוייקט ספציפי שמתואר בזיכרון זה.
• • גרסה — הגרסה של פרויקט זה. הכל כאן ברור כשמש: הוסיפו פונקציונליות חדשה, תיקנו ישנות, שחזרו או ביצעו שינויים אחרים - הגדילו את הגרסה.
• • אריזה - כאן אנו מתארים כיצד מייבן צריכה להרכיב את הפרויקט שלנו. או בג'אר, או במלחמה, או בכמה אחרים .
• • שם - הנה שם יותר נעים לפרויקט.

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

• • נתיב למאגר הפרויקט, ממנו ניתן להוריד אותו

  <url>https://romankh3.github.io/image-comparison/</url>

• • הרישיון לפיו מופץ פרויקט זה. יתר על כן, ייתכן שיש יותר מאחד, ולכן עליך להגדיר זאת כך:

  <licenses>
   <license>
     <name>The Apache Software License, Version 2.0</name>
     <url>http://www.apache.org/licenses/LICENSE-2.0.txt</url>
   </license>
  </licenses>

• • מידע על המפתחים שיצרו/יוצרים את הפרויקט:

  <developers>
   <developer>
     <id>romankh3</id>
     <name>Roman Beskrovnyi</name>
     <email>roman.beskrovnyy@gmail.com</email>
   </developer>
  </developers>

• • בלוק scm, המתאר כיצד ניתן לגשת לפרויקט:

  <scm>
  <connection>git@github.com:romankh3/image-comparison.git</connection>
  <developerConnection>git@github.com:romankh3/image-comparison.git</developerConnection>
   <url>https://github.com/romankh3/image-comparison</url>
  </scm>

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

<dependencies>
   <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
       <version>2.26.0</version>
       <scope>test</scope>
   </dependency>
   <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-api</artifactId>
       <version>5.5.2</version>
       <scope>test</scope>
   </dependency>
<dependency>
   	<groupId>com.github.romankh3</groupId>
   	<artifactId>image-comparison</artifactId>
   	<version>4.3.0</version>
<scope>test</scope>
</dependency>
</dependencies>

כאן הוספתי שתי ספריות לבדיקה: הן תמיד נחוצות. כפי שאולי כבר שמתם לב, לתלות יש היקף - היקף. במקרה שלנו , test is specificed , מה שאומר שפשוט לא נראה את התלות הזו בקוד הראשי. לאחר מכן, כדי שהכל ייראה יפה, אתה יכול להשתמש בתג נפרד כדי להציג את גרסאות <properties/> :

<properties>
   <mockito.version>2.26.0</mockito.version>
   <junit.version>5.5.2</junit.version>
   <image.comparison.version>4.3.0</image.comparison.version>
</properties>

אז ניתן לעדכן את בלוק התלות באמצעות המבנה ${PROPERTY_NAME} :

<dependencies>
   <dependency>
       <groupId>org.mockito</groupId>
       <artifactId>mockito-core</artifactId>
       <version>${mockito.version}</version>
       <scope>test</scope>
   </dependency>
   <dependency>
       <groupId>org.junit.jupiter</groupId>
       <artifactId>junit-jupiter-api</artifactId>
       <version>${junit.version}</version>
       <scope>test</scope>
   </dependency>
   <dependency>
       <groupId>com.github.romankh3</groupId>
       <artifactId>image-comparison</artifactId>
       <version>${image.comparison.version}</version>
       <scope>test</scope>
   </dependency>
</dependencies>

לאחר מכן מגיע בלוק <build/> גדול , המכיל בלוק <plugins/> חשוב , שבאמצעותו ניתן להתאים אישית את תהליך הבנייה. אתה יכול להוסיף תוסף אחד או יותר בתוך בלוק <plugins/> , כך:

<build>
   <plugins>
       <plugin>
           <groupId>org.apache.maven.plugins</groupId>
           <artifactId>maven-source-plugin</artifactId>
           <version>3.2.0</version>
           <executions>
               <execution>
                   <id>attach-sources</id>
                   <goals>
                       <goal>jar</goal>
                   </goals>
               </execution>
           </executions>
       </plugin>
   </plugins>
</build>

כאן תוכלו לראות שהוספתי שני תוספים - maven-source-plugin ו- maven-javadoc-plugin . לכל אחד מהפלאגינים יש הגדרות, תכונות (פרמטרים) שניתן להגדיר, ובכך להתאים אישית את התוספים. זה יהיה מעניין עבורנו בעתיד. לעת עתה, בואו נזכור ונמשיך הלאה. באותו אופן כמו עבור תלות, נשים את גרסאות הפלאגין ב- <properties/> . בהתבסס על זה, אתה יכול ליצור את הזיכרון הבא:

<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
        xmlns="http://maven.apache.org/POM/4.0.0"
        xsi:schemaLocation="http://maven.apache.org/POM/4.0.0
                     http://maven.apache.org/xsd/maven-4.0.0.xsd">
   <modelVersion>4.0.0</modelVersion>

   <groupId>com.github.javarushcommunity</groupId>
   <artifactId>maven-demo</artifactId>
   <version>1.0-SNAPSHOT</version>
   <packaging>jar</packaging>

   <name>Maven Demo Project</name>

   <url>https://github.com/javarushcommunity/maven-demo/</url>

   <properties>
       <mockito.version>2.26.0</mockito.version>
       <junit.version>5.5.2</junit.version>
       <maven.compiler.source>1.8</maven.compiler.source>
       <maven.compiler.target>1.8</maven.compiler.target>
       <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
       <source.plugin.version>3.2.0</source.plugin.version>
   </properties>

   <dependencies>
       <dependency>
           <groupId>org.mockito</groupId>
           <artifactId>mockito-core</artifactId>
           <version>${mockito.version}</version>
           <scope>test</scope>
       </dependency>
       <dependency>
           <groupId>org.junit.jupiter</groupId>
           <artifactId>junit-jupiter-api</artifactId>
           <version>${junit.version}</version>
           <scope>test</scope>
       </dependency>
   </dependencies>

   <build>
       <plugins>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-source-plugin</artifactId>
               <version>${source.plugin.version}</version>
               <executions>
                   <execution>
                       <id>attach-sources</id>
                       <goals>
                           <goal>jar</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
           <plugin>
               <groupId>org.apache.maven.plugins</groupId>
               <artifactId>maven-javadoc-plugin</artifactId>
               <version>${javadoc.plugin.version}</version>
               <executions>
                   <execution>
                       <id>attach-javadocs</id>
                       <goals>
                           <goal>jar</goal>
                       </goals>
                   </execution>
               </executions>
           </plugin>
       </plugins>
   </build>
</project>

מחזור החיים של מייבן

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

• • קומפיל — קומפל את הפרויקט. זה השלב הראשון: במהלכו ניתן לראות אם ישנן שגיאות קומפילציה בפרויקט. לפעמים ישנן קפיצות שונות בעבודה ב-IDEA, וזו הסיבה שבעיות קומפילציה מופיעות במקום שהן לא אמורות להתקיים. אז הפקודה הזו תנקד את כל ה-i.
• • מבחן - מריץ את כל הבדיקות שרצות על JUnit וממוקמות במקום שבו Maven מצפה להן ( src/test/java הוא הקפטן שלך).
• • package היא הפקודה הבאה, הכוללת את שתי הקודמות: כלומר, תחילה מופעלת בתוכה פקודת ה-compil , לאחר מכן נשלחת פקודת הבדיקה לפרוייקט הקומפילציה , ואם הכל בסדר כאן, מתחילה יצירת ארכיון (הארכיון שאנו בוחרים ב< packaging/>))
• • install - כאשר אנו מתקינים את Maven על מכונה, יש לנו מאגר Git מקומי המאחסן את הספריות שאנו מורידים עבור פרויקטים. אבל היופי של Maven הוא שאנחנו יכולים להשתמש בפקודה install כדי להוסיף את הפרויקט שלנו למאגר Git המקומי ולהשתמש בפרויקט שלנו באופן מקומי כתלות. לא מאמין לי? נסה את זה :) כך תוכל לראות במהירות כיצד הפרויקט שלך ייראה כמו תלות באחר.
• • פריסה היא הכתר של כל מה שבא לפני. פקודה שנותנת את היכולת להוסיף פרויקט לא רק למאגר מקומי כהתקנה, אלא גם למאגר מרוחק, שממנו כל מי שיש לו גישה יכול להשתמש בו כתלות.
• • verify - פקודה שתבדוק הכל ותספר האם הפרוייקט מוכן לפריסה.
• • נקי - כמובן, הקבצים והארכיון שהורכבו חייבים להיות מאוחסנים במקום כלשהו. ל-Maven יש תיקיית יעד עבור זה . אלו נתונים שהפרויקט לא צריך. ולפני הרכבה מחדש של הפרויקט, יהיה טוב למחוק את כל מה שהיה קודם. לשם כך מיועדת הפקודה נקייה .

תוספים של מייבן

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

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