Lahat ng gusto mong malaman tungkol sa Maven - "Java project from A to Z"

Kumusta sa lahat, mahal na mga kaibigan. Gusto kong humingi kaagad ng paumanhin: Naalala ko na nangako ako na susulat ako ng artikulo minsan sa isang linggo. Hindi nag work out. Hindi pa lang ako nakakaupo at magsulat ng maayos, ngunit hindi ko nais na gawin ito sa ganitong paraan o iyon. Hindi ako mangungulit tungkol sa mga dahilan, dahil hindi ko ito kailangan, at tiyak na hindi ka interesado. Ang proyekto ay hindi patay, ito ay nasa stasis :) Nagpapatuloy kami! At ang materyal ngayon ay nakatuon kay Maven.

Pag-usapan natin si Maven

Una kailangan mong i-install ito. Siyempre, dahil mayroon akong Mac, maaari ko lamang ipakita ang pag-install para sa isang Mac. Malas lang. Matagal ko na itong na-install, kaya kailangan mong gawin ito mismo :)

Bakit kailangan natin si Maven?

Ang Maven ay isang tool sa pagbuo ng proyekto, kasama sina Gradle at Ant. Dahil lang sa gagamitin ko ito sa JRTB (JavaRush Telegram Bot), gusto kong i-up to date ka. Sa ngayon, wala ni isang proyekto ang nalilikha nang walang sistema ng pagpupulong, dahil pinapasimple nito ang ating buhay nang maraming beses. Pinapayagan nito ang:

• • hilahin pataas ang lahat ng kinakailangang aklatan (sa mga tuntunin ng mga tool para sa pagpupulong - mga dependency (iyon ay, dependency));
• • tukuyin nang eksakto kung paano kailangang tipunin ang proyekto at sa kung ano (halimbawa, gusto ba natin itong kolektahin sa WAR o JAR o executable JAR);
• • itakda ang bersyon ng proyekto sa isang lugar upang ito ay ipahiwatig sa panahon ng pagpupulong;
• • ilarawan ang proyekto at ang ikot ng buhay nito;
• • magdagdag ng tinatawag na mga plugin (tradisyonal na bersyon ng salitang English na Plugin);
• • mag-publish ng mga aklatan sa isang shared repository upang makuha ng ibang mga proyekto ang mga ito bilang mga dependency.

Sa pangkalahatan, marami siyang ginagawa, at lahat sila ay kapaki-pakinabang. Sasabihin ko ito: para sa mga baguhang inhinyero ay hindi kinakailangang malaman ang lahat ng pag-andar mula sa pabalat hanggang sa pabalat. Dito, tulad ng sa git, mahalagang maunawaan ang mga pangunahing kaalaman at pangkalahatang konsepto. Ito ang gagawin natin. Para sa amin, ang Maven ay nagsisimula sa isang XML file sa ugat ng aming proyekto na tinatawag na pom.xml . Gagawin namin ang lahat sa pagsasanay, kaya gagawa muna kami ng aming unang proyekto sa JavaRush Community. Para magawa ang lahat nang matalino, gagamit ako ng template para sa repository , kung saan ang mga pangunahing bagay na inilarawan ko minsan sa JR ay na-configure na . Para gumawa, pumunta sa repository na may template at i-click ang Use this template button : Bilang resulta, mayroon kaming unang repository sa aming komunidad :) Lokal naming dina-download ang proyekto. Upang gawin ito, sa pamamagitan ng ideya, pumunta sa File -> New -> Project from Version Control . Sa lalabas na window, maglagay ng link sa proyekto sa Github (magiging mas maganda ang resulta kung hiwalay na gagawa ang lahat ng parehong proyekto at dadaan ang lahat ng hakbang kasama ko): I-click ang I-clone , at mai- clone ang proyekto .

pom.xml ang pinuno ng lahat

Lahat ng kailangan mo ay nasa pom.xml. Lahat ng impormasyon tungkol sa proyekto, developer nito at kung saan naka-imbak ang remote na imbakan ng proyekto. Sa simula, interesado kami sa mga sumusunod na bloke: <project/> - ito ang pangunahing bloke, na naglalaman ng lahat ng impormasyon tungkol sa proyekto. Lahat ng iba ay tahasan o palipat-lipat dito. Sa loob ng pambungad na tag ay ganito ang sinasabi:

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

At sa ibabaw ng lahat ng iba pa, ang susunod na linya ay nakasulat din sa lahat ng mga pomnik (ang slang ay dapat na mula sa pom.xml :)).

<modelVersion>4.0.0</modelVersion>

Ngunit pagkatapos ay nagiging mas kawili-wili ito: ilalarawan namin kung paano namin tinutukoy ang proyekto na inilalarawan ng aming alaala. Gamit ang aking library bilang isang halimbawa, ilalarawan ko ito, at pagkatapos ay idaragdag namin ito sa aming memorya, sa bagong likhang proyekto:

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

<name>Image Comparison</name>

Ang pangunahing bagay dito:

• • Ang groupId ay ang identifier ng development organization o indibidwal na engineer. Ito ang karaniwang domain sa reverse order. Bilang halimbawa, ang romankh3 account sa Github ay inilalarawan dito. Napakahalaga nito. Sabihin nating para sa Spring ecosystem ito ay com.springframework . Sa ganitong paraan maaari mong makilala ang orihinal na proyekto mula sa tinidor ng ibang tao o sa pamamagitan lamang ng pagkakataon ng pangalan ng proyekto.
• • artifaceId ay ang pangalan na ng isang partikular na proyekto na inilalarawan sa memoryang ito.
• • bersyon —ang bersyon ng proyektong ito. Ang lahat dito ay malinaw sa araw: nagdagdag ng bagong functionality, naayos ang mga luma, refactored o gumawa ng ilang iba pang mga pagbabago - pinataas ang bersyon.
• • packaging - dito namin inilalarawan kung paano dapat tipunin ni Maven ang aming proyekto. Alinman sa Jar, o sa Digmaan, o iba pa .
• • pangalan - narito ang isang mas kasiya-siyang pangalan para sa proyekto.

Mayroon pa ring ilang bagay na hindi kinakailangang punan - gagana si Maven nang wala ang mga ito - ngunit kung kailangan mong i-publish ang library para sa pampublikong paggamit, tiyak na sulit itong idagdag. Ano ang mga ito?

• • landas patungo sa repositoryo ng proyekto, kung saan ito mada-download

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

• • ang lisensya kung saan ipinamamahagi ang proyektong ito. Bukod dito, maaaring mayroong higit sa isa, at samakatuwid kailangan mong itakda ito sa ganitong paraan:

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

• • impormasyon tungkol sa mga developer na gumawa/gumawa ng proyekto:

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

• • scm block, na naglalarawan kung paano ma-access ang proyekto:

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

Pagkatapos naming ilarawan ang pangkalahatang impormasyon, maaari kaming magdagdag ng isang bloke na may mga dependency:

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

Dito nagdagdag ako ng dalawang aklatan para sa pagsubok: palagi silang kailangan. Tulad ng maaaring napansin mo na, ang mga dependency ay may Saklaw - saklaw. Sa aming kaso , ang pagsubok ay tinukoy , na nangangahulugan na hindi namin makikita ang dependency na ito sa pangunahing code. Susunod, para maging maganda ang lahat, maaari kang gumamit ng hiwalay na tag para ipakita ang mga bersyon ng <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>

Kaya ang dependency block ay maaaring ma-update gamit ang ${PROPERTY_NAME} construct :

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

Susunod ang isang malaking <build/> block , na naglalaman ng mahalagang <plugins/> block , kung saan maaari mong i-customize ang proseso ng build. Maaari kang magdagdag ng isa o higit pang mga plugin sa loob ng <plugins/> block , tulad nito:

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

Dito makikita mo na nagdagdag ako ng dalawang plugin - maven-source-plugin at maven-javadoc-plugin . Ang bawat isa sa mga plugin ay may mga setting, mga katangian (parameter) na maaaring itakda, sa gayon ay na-customize ang mga plugin. Ito ay magiging kawili-wili para sa atin sa hinaharap. Sa ngayon, tandaan natin at magpatuloy. Sa parehong paraan tulad ng para sa mga dependency, ilalagay namin ang mga bersyon ng plugin sa <properties/> . Batay dito, maaari kang lumikha ng sumusunod na memorya:

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

Siklo ng buhay ni Maven

Si Maven ay may isang bagay bilang maven lifecycle. Ito ay nagkakahalaga na sabihin na ito ay isang hanay ng mga gawain na maaaring gawin ng isang maven. Maaaring may iba pang mga gawain bukod sa maven lifecycle. Tungkol Saan iyan? Mayroong isang hanay ng mga utos kung saan maaari kang mag-ipon ng isang proyekto ( bumuo ... muli, siyempre, isang tracing paper mula sa Ingles, ngunit kung wala ito ay wala kahit saan), tanggalin ang mga build na nakolekta ni Maven, i-install sa lokal na Maven upang maaari mong lokal na hilahin ang proyekto bilang isang dependency, at iba pa. Ngayon pag-usapan natin ang lahat nang mas detalyado. Bago isulat ang aking opinyon tungkol sa mga pangkat na ito, nagpasya akong basahin kung ano ang kanilang isinusulat sa Internet tungkol sa bagay na ito... at napagtanto na napakahirap ilarawan. Para sa trabaho, para sa paunang trabaho, kailangan namin ng ilang mga utos . Ilarawan natin sila:

• • compile — ipunin ang proyekto. Ito ang unang yugto: sa panahon nito makikita mo kung mayroong anumang mga error sa compilation sa proyekto. Minsan may iba't ibang leapfrog na nagtatrabaho sa IDEA, kaya naman lumalabas ang mga problema sa compilation kung saan hindi dapat umiral. Kaya ang utos na ito ay maglalagay ng tuldok sa lahat ng i.
• • pagsubok - pinapatakbo ang lahat ng mga pagsubok na tumatakbo sa JUnit at matatagpuan kung saan inaasahan sila ni Maven ( src/test/java ang iyong kapitan).
• • package ay ang susunod na command, na kinabibilangan ng dalawang nauna: iyon ay, ang compile command ay unang inilunsad sa loob nito, pagkatapos ay ang test command ay ipinadala sa compiled project , at kung ang lahat ay ok dito, ang paglikha ng isang archive ay magsisimula (ang archive na pipiliin namin sa < packaging/>))
• • i-install - kapag nag-install kami ng Maven sa isang makina, mayroon kaming lokal na Git repository na nag-iimbak ng mga library na dina-download namin para sa mga proyekto. Ngunit ang kagandahan ng Maven ay magagamit natin ang install command upang idagdag ang ating proyekto sa lokal na Git repository at gamitin ang ating proyekto nang lokal bilang dependency. Huwag maniwala sa akin? Subukan ito :) Sa ganitong paraan mabilis mong makikita kung paano magmumukhang dependency ang iyong proyekto sa isa pa.
• • ang deploy ay ang korona ng lahat ng nauna. Isang utos na nagbibigay ng kakayahang magdagdag ng isang proyekto hindi lamang sa isang lokal na imbakan bilang pag-install, kundi pati na rin sa isang malayuan, kung saan magagamit ito ng lahat ng may access bilang isang dependency.
• • verify - isang command na susuriin ang lahat at sasabihin kung ang proyekto ay handa na para sa pag-deploy.
• • malinis - siyempre, ang pinagsama-samang mga file at archive ay dapat na naka-imbak sa isang lugar. May target na folder si Maven para dito . Ito ay data na hindi kailangan ng proyekto. At bago muling buuin ang proyekto, makabubuting tanggalin ang lahat ng nauna. Ito ay para sa malinis na utos .

Maven Plugin

Gusto kong makipag-usap nang higit pa tungkol sa mga plugin, ngunit ang artikulo ay mahaba na. Ito ang magiging takdang-aralin mo. Unawain kung ano ito at kung paano ito gamitin. Sa pagpapatuloy ng artikulo, haharapin natin si Maven sa pagsasanay.

Ang isang listahan ng lahat ng mga materyales sa serye ay nasa simula ng artikulong ito.