Segala sesuatu yang ingin Anda ketahui tentang Maven - "Proyek Java dari A hingga Z"

Halo semuanya, teman-teman terkasih. Saya ingin segera meminta maaf: Saya ingat saya berjanji akan menulis artikel seminggu sekali. Tidak berhasil. Aku hanya belum sempat duduk dan menulis dengan benar, tapi aku tidak ingin melakukannya dengan cara ini atau itu. Saya tidak akan mengeluh tentang alasannya, karena saya tidak membutuhkannya, dan Anda pasti tidak tertarik. Proyek ini tidak mati, masih dalam keadaan statis :) Kami melanjutkan! Dan materi hari ini didedikasikan untuk Maven.

Mari kita bicara tentang Maven

Pertama, Anda perlu menginstalnya. Tentu saja, karena saya memiliki Mac, saya hanya dapat menampilkan instalasi untuk Mac. Itu hanya nasib buruk. Saya sudah menginstalnya sejak lama, jadi Anda harus melakukannya sendiri :)

Mengapa kita membutuhkan Maven?

Maven adalah alat pembangunan proyek, bersama dengan Gradle dan Ant. Hanya karena saya akan menggunakannya di JRTB (JavaRush Telegram Bot), saya ingin memberi Anda informasi terkini. Saat ini, tidak ada satu proyek pun yang dibuat tanpa sistem perakitan, karena sistem ini sangat menyederhanakan hidup kita. Hal ini memungkinkan:

• • menyediakan semua perpustakaan yang diperlukan (dalam hal alat untuk perakitan - dependensi (yaitu, ketergantungan));
• • menentukan dengan tepat bagaimana proyek perlu dirakit dan menjadi apa (misalnya, apakah kita ingin mengumpulkannya dalam WAR atau JAR atau JAR yang dapat dieksekusi);
• • mengatur versi proyek di satu tempat sehingga dapat ditunjukkan pada saat perakitan;
• • menjelaskan proyek dan siklus hidupnya;
• • menambahkan apa yang disebut plugin (versi tradisional dari kata bahasa Inggris Plugin);
• • mempublikasikan perpustakaan di repositori bersama sehingga proyek lain dapat menggunakannya sebagai dependensi.

Secara umum, dia melakukan banyak hal, dan semuanya berguna. Saya akan mengatakan ini: bagi insinyur pemula, tidak perlu mengetahui semua fungsi dari sampul ke sampul. Di sini, seperti halnya git, penting untuk memahami dasar-dasar dan konsep umum. Inilah yang akan kami lakukan. Bagi kami, Maven dimulai dengan file XML di root proyek kami yang disebut pom.xml . Kami akan melakukan semuanya dalam praktik, jadi pertama-tama kami akan membuat proyek pertama kami di Komunitas JavaRush. Untuk melakukan semuanya dengan bijak, saya akan menggunakan templat untuk repositori , di mana hal-hal dasar yang saya jelaskan di JR sudah dikonfigurasi . Untuk membuat, buka repositori dengan templat dan klik tombol Gunakan templat ini : Hasilnya, kami memiliki repositori pertama di komunitas kami :) Kami mengunduh proyek secara lokal. Untuk melakukan ini, melalui ide tersebut, buka File -> New -> Project from Version Control . Di jendela yang muncul, masukkan tautan ke proyek di Github (hasilnya akan lebih baik jika semua orang membuat proyek yang sama secara terpisah dan melakukan semua langkah bersama saya): Klik Klon , dan proyek dikloning .

pom.xml adalah kepala dari segalanya

Semua yang Anda butuhkan ada di pom.xml. Semua informasi tentang proyek, pengembangnya, dan di repositori jarak jauh mana proyek tersebut disimpan. Pada awalnya, kami tertarik pada blok berikut: <project/> - ini adalah blok utama, yang berisi semua informasi tentang proyek. Semua orang lain akan secara eksplisit atau transitif di dalamnya. Di dalam tag pembuka tertulis 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 yang terpenting, baris berikutnya juga ditulis di semua pomnik (bahasa gaulnya diduga dari pom.xml :)).

<modelVersion>4.0.0</modelVersion>

Namun kemudian menjadi lebih menarik: kami akan menjelaskan bagaimana kami mengidentifikasi proyek yang dideskripsikan oleh memorial kami. Dengan menggunakan perpustakaan saya sebagai contoh, saya akan menjelaskannya, dan kemudian kita akan menambahkannya ke memori kita, ke proyek 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>

Hal utama di sini:

• • groupId adalah pengidentifikasi organisasi pengembangan atau insinyur individu. Ini biasanya domain dalam urutan terbalik. Sebagai contoh, akun romankh3 di Github dijelaskan di sini. Ini sangat penting. Katakanlah untuk ekosistem Spring adalah com.springframework . Dengan cara ini Anda dapat membedakan proyek asli dari garpu orang lain atau hanya dengan kebetulan nama proyeknya.
• • artifaceId sudah menjadi nama proyek spesifik yang dijelaskan dalam memori ini.
• • version —versi proyek ini. Segala sesuatu di sini jelas: menambahkan fungsionalitas baru, memperbaiki yang lama, memfaktorkan ulang atau membuat beberapa perubahan lain - meningkatkan versi.
• • pengemasan - di sini kami menjelaskan bagaimana Maven harus merakit proyek kami. Baik di Jar, atau di War, atau yang lainnya .
• • nama - ini adalah nama yang lebih sesuai untuk proyek tersebut.

Masih ada beberapa hal yang tidak perlu diisi sama sekali - Maven akan berfungsi tanpanya - tetapi jika Anda perlu menerbitkan perpustakaan untuk kepentingan umum, ada baiknya menambahkannya. Benda apa ini?

• • jalur ke repositori proyek, dari mana proyek dapat diunduh

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

• • izin distribusi proyek ini. Selain itu, mungkin ada lebih dari satu, oleh karena itu Anda perlu mengaturnya seperti 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>

• • informasi tentang pengembang yang membuat/sedang membuat proyek:

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

• • blok scm, yang menjelaskan bagaimana proyek dapat 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>

Setelah kami menjelaskan informasi umum, kami dapat menambahkan blok dengan dependensi:

<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 menambahkan dua perpustakaan untuk pengujian: mereka selalu dibutuhkan. Seperti yang mungkin sudah Anda ketahui, dependensi memiliki Cakupan - cakupan. Dalam kasus kami , test ditentukan , yang berarti kami tidak akan melihat ketergantungan ini pada kode utama. Selanjutnya, untuk membuat semuanya terlihat cantik, Anda dapat menggunakan tag terpisah untuk menampilkan 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 ketergantungan dapat diperbarui menggunakan konstruksi ${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>

Berikutnya adalah blok <build/> besar , yang berisi blok <plugins/> penting , yang dengannya Anda dapat menyesuaikan proses pembangunan. Anda dapat menambahkan satu atau lebih plugin 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 dapat melihat bahwa saya telah menambahkan dua plugin - maven-source-plugin dan maven-javadoc-plugin . Masing-masing plugin memiliki pengaturan, atribut (parameter) yang dapat diatur, sehingga plugin dapat disesuaikan. Ini akan menarik bagi kami di masa depan. Untuk saat ini, mari kita ingat dan lanjutkan. Dengan cara yang sama seperti untuk dependensi, kita akan meletakkan versi plugin di <properties/> . Berdasarkan hal ini, Anda dapat membuat 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>

Siklus hidup Maven

Maven memiliki yang namanya siklus hidup maven. Patut dikatakan bahwa ini adalah serangkaian tugas yang dapat dilakukan oleh seorang pakar. Mungkin ada tugas lain selain siklus hidup maven. Tentang apa ini? Ada serangkaian perintah yang dapat digunakan untuk merakit sebuah proyek ( build ... sekali lagi, tentu saja, kertas kalkir dari bahasa Inggris, tetapi tanpa ini tidak ada tempat), hapus build yang dikumpulkan Maven, instal di Maven lokal sehingga Anda bisa secara lokal menarik proyek sebagai ketergantungan, dan seterusnya. Sekarang mari kita bicarakan semuanya lebih detail. Sebelum menulis pendapat saya tentang tim-tim ini, saya memutuskan untuk membaca apa yang mereka tulis di Internet tentang masalah ini... dan menyadari bahwa hal itu sangat sulit untuk dijelaskan. Untuk pekerjaan, untuk pekerjaan awal kita memerlukan beberapa perintah . Mari kita gambarkan:

• • kompilasi — kompilasi proyek. Ini adalah tahap pertama: selama tahap ini Anda dapat melihat apakah ada kesalahan kompilasi dalam proyek. Terkadang ada berbagai lompatan dalam bekerja di IDEA, itulah sebabnya masalah kompilasi muncul di tempat yang seharusnya tidak ada. Jadi perintah ini akan menandai semua huruf i.
• • test - menjalankan semua pengujian yang berjalan di JUnit dan berlokasi di tempat yang diharapkan Maven ( src/test/java adalah kapten Anda).
• • paket adalah perintah berikutnya, yang mencakup dua perintah sebelumnya: yaitu, perintah kompilasi diluncurkan terlebih dahulu di dalamnya, kemudian perintah pengujian dikirim ke proyek yang dikompilasi , dan jika semuanya baik-baik saja di sini, pembuatan arsip dimulai (arsip yang kita pilih di <packaging/>))
• • install - ketika kita menginstal Maven pada mesin, kita memiliki repositori Git lokal yang menyimpan perpustakaan yang kita download untuk proyek. Namun kelebihan dari Maven adalah kita dapat menggunakan perintah install untuk menambahkan proyek kita ke repositori Git lokal dan menggunakan proyek kita secara lokal sebagai ketergantungan. Tidak percaya padaku? Cobalah :) Dengan cara ini Anda dapat dengan cepat melihat bagaimana proyek Anda akan terlihat seperti ketergantungan pada proyek lain.
• • Penerapan adalah puncak dari segala sesuatu yang terjadi sebelumnya. Sebuah perintah yang memberikan kemampuan untuk menambahkan proyek tidak hanya ke repositori lokal sebagai instalasi, tetapi juga ke repositori jarak jauh, di mana setiap orang yang memiliki akses dapat menggunakannya sebagai ketergantungan.
• • verifikasi - perintah yang akan memeriksa semuanya dan mengetahui apakah proyek siap untuk diterapkan.
• • bersih - tentu saja, file dan arsip yang dikompilasi harus disimpan di suatu tempat. Maven memiliki folder target untuk ini . Ini adalah data yang tidak diperlukan oleh proyek. Dan sebelum menyusun kembali proyek tersebut, alangkah baiknya menghapus semua yang ada sebelumnya. Inilah gunanya perintah clean .

Plugin Maven

Saya ingin berbicara lebih banyak tentang plugin, tetapi artikelnya sudah panjang. Ini akan menjadi pekerjaan rumah Anda. Pahami apa itu dan bagaimana menggunakannya. Dalam kelanjutan artikel ini, kita akan membahas Maven dalam praktiknya.

Daftar semua materi dalam seri ini ada di awal artikel ini.