Semua yang anda ingin ketahui tentang Maven - "Projek Java dari A hingga Z"

Hello semua, kawan-kawan yang dikasihi. Saya ingin memohon maaf dengan segera: Saya masih ingat bahawa saya berjanji bahawa saya akan menulis artikel sekali seminggu. Tidak berjaya. Saya hanya belum sempat duduk dan menulis dengan betul, tetapi saya tidak mahu melakukannya dengan cara ini atau itu. Saya tidak akan merengek tentang sebabnya, kerana saya tidak memerlukannya, dan anda pastinya tidak berminat. Projek itu tidak mati, ia berada dalam stasis :) Kami teruskan! Dan bahan hari ini didedikasikan untuk Maven.

Mari kita bercakap tentang Maven

Mula-mula anda perlu memasangnya. Sudah tentu, kerana saya mempunyai Mac, saya hanya boleh menunjukkan pemasangan untuk Mac. Cuma nasib malang. Saya memasangnya lama dahulu, jadi anda perlu melakukannya sendiri :)

Mengapa kita memerlukan Maven?

Maven ialah alat binaan projek, bersama-sama dengan Gradle dan Ant. Hanya kerana saya akan menggunakannya dalam JRTB (JavaRush Telegram Bot), saya ingin membawa anda maklumat terkini. Pada masa kini, tiada satu projek pun dibuat tanpa sistem pemasangan, kerana ia memudahkan kehidupan kita berkali-kali ganda. Ini membenarkan:

• • tarik semua perpustakaan yang diperlukan (dari segi alat untuk pemasangan - kebergantungan (iaitu, kebergantungan));
• • tentukan dengan tepat bagaimana projek itu perlu disusun dan menjadi apa (contohnya, adakah kita mahu membina dalam WAR atau JAR atau JAR boleh laku);
• • tetapkan versi projek di satu tempat supaya ia ditunjukkan semasa pemasangan;
• • menerangkan projek dan kitaran hayatnya;
• • menambah apa yang dipanggil pemalam (versi tradisional perkataan Inggeris Plugin);
• • menerbitkan perpustakaan dalam repositori kongsi supaya projek lain boleh menariknya sebagai kebergantungan.

Secara umum, dia melakukan banyak perkara, dan semuanya berguna. Saya akan katakan ini: untuk jurutera pemula tidak perlu mengetahui semua fungsi dari muka depan ke muka. Di sini, seperti git, adalah penting untuk memahami asas dan konsep umum. Inilah yang akan kita lakukan. Bagi kami, Maven bermula dengan fail XML dalam akar projek kami yang dipanggil pom.xml . Kami akan melakukan segala-galanya dalam amalan, jadi mula-mula kami akan mencipta projek pertama kami dalam Komuniti JavaRush. Untuk melakukan segala-galanya dengan bijak, saya akan menggunakan templat untuk repositori , di mana perkara asas yang saya terangkan sekali pada JR sudah dikonfigurasikan . Untuk mencipta, pergi ke repositori dengan templat dan klik butang Gunakan templat ini : Hasilnya, kami mempunyai repositori pertama dalam komuniti kami :) Kami memuat turun projek secara setempat. Untuk melakukan ini, melalui idea, pergi ke Fail -> Baharu -> Projek daripada Kawalan Versi . Dalam tetingkap yang muncul, masukkan pautan ke projek di Github (hasilnya akan menjadi lebih baik jika semua orang mencipta projek yang sama secara berasingan dan melalui semua langkah dengan saya): Klik Klon , dan projek diklonkan .

pom.xml ialah ketua segala-galanya

Semua yang anda perlukan ada dalam pom.xml. Semua maklumat tentang projek, pembangunnya dan repositori jauh mana projek itu disimpan. Pada permulaannya, kami berminat dengan blok berikut: <project/> - ini ialah blok utama, yang mengandungi semua maklumat tentang projek. Semua yang lain akan secara eksplisit atau transitif di dalamnya. Di dalam teg pembukaan ia mengatakan sesuatu seperti ini:

<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">

Dan di atas segala-galanya, baris seterusnya juga ditulis dalam semua pomnik (slang kononnya dari pom.xml :)).

<modelVersion>4.0.0</modelVersion>

Tetapi ia menjadi lebih menarik: kami akan menerangkan cara kami mengenal pasti projek yang diterangkan oleh memorial kami. Menggunakan perpustakaan saya sebagai contoh, saya akan menerangkannya, dan kemudian kami akan menambahkannya ke ingatan kami, ke projek yang baru dibuat:

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

<name>Image Comparison</name>

Perkara utama di sini:

• • groupId ialah pengecam organisasi pembangunan atau jurutera individu. Ini biasanya domain dalam susunan terbalik. Sebagai contoh, akaun romankh3 di Github diterangkan di sini. Ianya sangat penting. Katakan untuk ekosistem Spring ia adalah com.springframework . Dengan cara ini anda boleh membezakan projek asal daripada garpu orang lain atau hanya dengan kebetulan nama projek.
• • artifaceId sudah pun nama projek tertentu yang diterangkan dalam ingatan ini.
• • versi —versi projek ini. Segala-galanya di sini jelas seperti hari: menambah fungsi baharu, membetulkan yang lama, memfaktorkan semula atau membuat beberapa perubahan lain - meningkatkan versi.
• • pembungkusan - di sini kami menerangkan cara Maven harus memasang projek kami. Sama ada dalam Jar, atau dalam Perang, atau beberapa yang lain .
• • nama - berikut ialah nama yang lebih menggembirakan untuk projek itu.

Masih terdapat beberapa perkara yang tidak perlu diisi sama sekali - Maven akan berfungsi tanpanya - tetapi jika anda perlu menerbitkan perpustakaan untuk kegunaan awam, ia pasti bernilai menambahnya. Apakah perkara-perkara ini?

• • laluan ke repositori projek, dari mana ia boleh dimuat turun

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

• • lesen di mana projek ini diedarkan. Selain itu, mungkin terdapat lebih daripada satu, dan oleh itu anda perlu menetapkannya dengan cara ini:

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

• • maklumat tentang pembangun yang mencipta/sedang mencipta projek:

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

• • blok scm, yang menerangkan cara projek boleh diakses:

  <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>

Selepas kami menerangkan maklumat umum, kami boleh menambah blok dengan kebergantungan:

<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>

Di sini saya menambah dua perpustakaan untuk ujian: ia sentiasa diperlukan. Seperti yang anda mungkin telah perhatikan, kebergantungan mempunyai Skop - skop. Dalam kes kami , ujian ditentukan , yang bermaksud bahawa kami tidak akan melihat pergantungan ini dalam kod utama. Seterusnya, untuk menjadikan semuanya kelihatan cantik, anda boleh menggunakan teg berasingan untuk memaparkan versi <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>

Jadi blok pergantungan boleh dikemas kini menggunakan binaan ${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>

Seterusnya terdapat blok <build/> yang besar , yang mengandungi blok <plugins/> yang penting , yang dengannya anda boleh menyesuaikan proses binaan. Anda boleh menambah satu atau lebih pemalam di dalam blok <plugins/> , seperti ini:

<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>

Di sini anda boleh melihat bahawa saya telah menambah dua pemalam - maven-source-plugin dan maven-javadoc-plugin . Setiap pemalam mempunyai tetapan, atribut (parameter) yang boleh ditetapkan, dengan itu menyesuaikan pemalam. Ini akan menjadi menarik untuk kita pada masa akan datang. Buat masa ini, mari kita ingat dan teruskan. Dengan cara yang sama seperti kebergantungan, kami akan meletakkan versi pemalam dalam <properties/> . Berdasarkan ini, anda boleh mencipta memori berikut:

<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>

Kitaran hayat Maven

Maven mempunyai perkara seperti kitaran hayat maven. Perlu dikatakan bahawa ini adalah satu set tugas yang boleh dilakukan oleh pakar. Mungkin terdapat tugas lain selain kitaran hayat maven. Hal ini berkaitan dengan apa? Terdapat satu set arahan yang boleh anda gunakan untuk memasang projek ( bina ... sekali lagi, sudah tentu, kertas jejak dari bahasa Inggeris, tetapi tanpa ini tidak ada tempat), padam binaan yang Maven kumpulkan, pasang dalam Maven tempatan supaya anda boleh secara tempatan menarik projek sebagai pergantungan, dan sebagainya. Sekarang mari kita bercakap tentang segala-galanya dengan lebih terperinci. Sebelum menulis pendapat saya tentang pasukan ini, saya memutuskan untuk membaca apa yang mereka tulis di Internet tentang perkara ini... dan menyedari bahawa ia sangat sukar untuk diterangkan. Untuk kerja, untuk kerja awal, kita memerlukan beberapa arahan . Mari kita huraikan mereka:

• • menyusun — menyusun projek. Ini adalah peringkat pertama: semasa itu anda boleh melihat jika terdapat sebarang ralat kompilasi dalam projek. Kadang-kadang terdapat pelbagai lompatan dengan bekerja di IDEA, itulah sebabnya masalah kompilasi muncul di tempat yang tidak sepatutnya wujud. Jadi arahan ini akan mencatat semua i.
• • ujian - menjalankan semua ujian yang dijalankan pada JUnit dan terletak di tempat yang dijangkakan oleh Maven ( src/test/java ialah kapten anda).
• • pakej ialah arahan seterusnya, yang merangkumi dua yang sebelumnya: iaitu, arahan penyusunan mula-mula dilancarkan di dalamnya, kemudian perintah ujian dihantar ke projek yang disusun , dan jika semuanya ok di sini, penciptaan arkib bermula (arkib yang kami pilih dalam < pembungkusan/>))
• • pasang - apabila kami memasang Maven pada mesin, kami mempunyai repositori Git setempat yang menyimpan perpustakaan yang kami muat turun untuk projek. Tetapi keindahan Maven ialah kami boleh menggunakan arahan pemasangan untuk menambah projek kami ke repositori Git tempatan dan menggunakan projek kami secara tempatan sebagai pergantungan. Tidak percaya saya? Cubalah :) Dengan cara ini anda boleh melihat dengan cepat bagaimana projek anda akan kelihatan seperti bergantung kepada projek lain.
• • deploy ialah mahkota segala yang datang sebelum ini. Perintah yang memberikan keupayaan untuk menambah projek bukan sahaja pada repositori tempatan sebagai pemasangan, tetapi juga kepada yang jauh, dari mana semua orang yang mempunyai akses boleh menggunakannya sebagai pergantungan.
• • mengesahkan - arahan yang akan menyemak segala-galanya dan memberitahu sama ada projek itu sedia untuk digunakan.
• • bersih - sudah tentu, fail yang disusun dan arkib mesti disimpan di suatu tempat. Maven mempunyai folder sasaran untuk ini . Ini adalah data yang tidak diperlukan oleh projek. Dan sebelum memasang semula projek itu, adalah baik untuk memadam semua yang datang sebelum ini. Inilah gunanya perintah bersih .

Plugin Maven

Saya ingin bercakap lebih lanjut mengenai pemalam, tetapi artikel itu sudah panjang. Ini akan menjadi kerja rumah anda. Fahami apa itu dan cara menggunakannya. Dalam kesinambungan artikel, kami akan berurusan dengan Maven secara praktikal.

Senarai semua bahan dalam siri ini adalah pada permulaan artikel ini.