Maven este folosit foarte des în industrie și am simțit că ar fi bine să abordez elementele de bază din acest articol, astfel încât să poată fi utilizat în mod eficient.

Acest articol va acoperi lucruri precum elementele de bază maven, pluginurile maven, dependențele maven și ciclul de viață al construirii maven.

Ce este Maven

Maven a fost creat pentru a oferi un mod standard în care proiectele pot fi construite. Una dintre caracteristicile sale puternice este gestionarea dependenței.

Maven este utilizat în mod obișnuit pentru gestionarea dependenței, dar nu este singurul lucru pe care este capabil să îl facă.

Dacă nu știți ce înseamnă managementul dependenței, nu vă faceți griji ?. Voi acoperi asta și în acest articol.

Instalarea Maven

Puteți instala Maven de la https://maven.apache.org/

De asemenea, asigurați-vă că Maven este setat în PATH, astfel încât mvn comanda funcționează.

Puteți verifica dacă este instalat și poate fi accesat folosind comanda

mvn -v

De asemenea, asigurați-vă JAVA_HOME este setat.

În mod implicit, Maven va folosi jdk-ul pe care l-ați furnizat în JAVA_HOME. Acest lucru poate fi suprascris, dar pentru acest articol vom folosi jdk furnizat în JAVA_HOME.

Creați-vă Proiectul Maven

În mod normal, un IDE ca eclipsa poate fi folosit pentru a crea cu ușurință proiecte maven. Dar, în acest articol, voi executa comenzile din linia de comandă, astfel încât pașii să fie înțelese în mod clar.

Rulați următoarea comandă pentru a crea proiectul.

mvn -B archetype:generate -DarchetypeGroupId=org.apache.maven.archetypes -DgroupId=com.first.app -DartifactId=first-maven-app

Arhetipul din comanda de mai sus nu este altceva decât un exemplu de șablon de proiect. groupdId spune în ce grup se află proiectul dvs. și artifactId este numele proiectului.

După ce executați comanda de mai sus, poate dura aproximativ un minut pentru a descărca pluginurile necesare și a crea proiectul.

Acum este creat un dosar numit first-maven-app. Deschideți folderul și veți vedea un fișier numit pom.xml

pom.xml

POM înseamnă Project Object Model. pom.xml are toate detaliile despre proiectul dvs. și aici veți spune maven ce ar trebui să facă.

Conținutul acestui fișier este prezentat mai jos:

 <project xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0_0.xsd">
  <modelVersion>4.0.0</modelVersion>
  <groupId>com.first.app</groupId>
  <artifactId>first-maven-app</artifactId>
  <packaging>jar</packaging>
  <version>1.0-SNAPSHOT</version>
  <name>first-maven-app</name>
  <url>http://maven.apache.org</url>
  <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>
</project>

groupdId și artifactId sunt aceleași valori pe care le-am dat în linia de comandă.

ambalare este formatul pachetului artefactului. Valoarea implicită este borcan. Poate avea și alte valori precum urechea, războiul, gudronul și așa mai departe.

versiune indică numărul versiunii artefactului. Dacă INSTANTANEU este prezent, apoi indică faptul că versiunea este încă în dev și este posibil să nu fie stabilă. Dacă numărul versiunii nu are INSTANTANEU, atunci este versiunea actuală de lansare.

Nume este numele proiectului.

Voi explica mai jos despre dependențe și pluginuri în Maven.

Super POM

pom.xml, după cum puteți vedea, este destul de mic. Motivul pentru aceasta este că o mulțime de configurație este prezentă în ceva numit Super POM, care este întreținut intern de Maven.

pom.xml extinde Super Pom pentru a obține toate configurile prezente în super Pom.

Una dintre configurațiile prezente în Super Pom indică următoarele:

  • Tot codul sursă Java este prezent în interior src / main / java
  • Toate codurile de testare Java sunt prezente în interior src / test / java

Menționez doar această configurație aici, deoarece vom trata atât codul sursă, cât și codul de testare în acest articol.

Cod

Întregul cod discutat aici este disponibil în această repo: https://github.com/aditya-sridhar/first-maven-app

Să adăugăm câteva coduri Java simple. Creați următoarea structură de dosare:

src / main / java / com / test / app / App.java

App.java este codul Java pe care îl vom adăuga.

Copiați următorul cod în App.java:

package com.first.app;

import java.util.List;
import java.util.ArrayList;

public class App 
{
    public static void main( String[] args )
    {
        List<Integer> items = new ArrayList<Integer>();
        items.add(1);
        items.add(2);
        items.add(3);
        printVals(items);
        System.out.println("Sum: "+getSum(items));
    }

    public static void printVals(List<Integer> items){
        items.forEach( item ->{
            System.out.println(item);
        });
    }

    public static int getSum(List<Integer> items){
        int sum = 0;
        for(int item:items){
            sum += item;
        }
        return sum;
    }
}

Acesta este un cod simplu care are 2 funcții.

Dar un lucru de observat este că codul folosește expresii lambda în bucla forEach printVals funcţie.

Expresiile Lambda au nevoie de cel puțin Java 8 pentru a rula. Dar în mod implicit, Maven 3.8.0 rulează folosind versiunea Java 1.6.

Deci, trebuie să-i spunem lui maven să folosească în schimb Java 1.8. Pentru a face acest lucru vom folosi pluginurile Maven.

Pluginuri Maven

Vom folosi pluginul Maven Compiler pentru a indica ce versiune Java să utilizăm. Adăugați următoarele linii la pom.xml:

<project>
...
<build>
  <plugins>
     <plugin>
        <groupId>org.apache.maven.plugins</groupId>
        <artifactId>maven-compiler-plugin</artifactId>
        <version>3.8.0</version>
        <configuration>
          <source>1.8</source>
          <target>1.8</target>
        </configuration>
      </plugin>
  <plugins>
</build>
...
</project>

Puteți vedea că Java sursă și ţintă versiunile sunt setate la 1.8.

Pluginurile fac practic o acțiune în maven. Pluginul compilatorului compilează fișierele sursă.

Pom.xml complet este disponibil Aici.

Există o mulțime de plugin-uri disponibile. Știind cum să folosească bine pluginurile, Maven poate fi folosit pentru a face lucruri uimitoare. ?

Dependențe Maven

În mod normal, în timp ce scriem cod, vom folosi o mulțime de biblioteci existente. Aceste biblioteci existente nu sunt altceva decât dependențe. Maven poate fi utilizat pentru a gestiona dependențele cu ușurință.

În pom.xml al proiectului nostru puteți vedea următoarea dependență:

 <dependencies>
    <dependency>
      <groupId>junit</groupId>
      <artifactId>junit</artifactId>
      <version>3.8.1</version>
      <scope>test</scope>
    </dependency>
  </dependencies>

Această dependență ne spune că vom avea nevoie junit. Junit este folosit pentru a scrie teste unitare pentru cod Java. În mod similar, pot fi adăugate o mulțime de alte dependențe.

Să presupunem că doriți să gestionați JSON în cod. Apoi puteți adăuga fișierul gson dependență așa cum se arată mai jos:

<dependency>
    <groupId>com.google.code.gson</groupId>
    <artifactId>gson</artifactId>
    <version>2.8.5</version>
</dependency>

Puteți căuta artefacte Maven în https://search.maven.org

Dependențe tranzitive

Să presupunem că adăugați o dependență A la proiect. Acum A depinde de o dependență numită B. B depinde de o dependență numită C.

Din moment ce utilizați A în proiect, veți avea nevoie, de asemenea B și C.

Dar, din fericire, este suficient dacă adăugați numai A în pom.xml. Deoarece Maven își dă seama că A depinde de B și că B depinde de C. Deci, intern, Maven va descărca automat B și C.

Aici B și C sunt dependențe tranzitive.

Depozit personalizat Maven

Toate aceste dependențe sunt disponibile într-un depozit public central Maven http://repo.maven.apache.org/maven2

Este posibil să existe unele artefacte care sunt private pentru compania dvs. În acest caz, puteți menține un depozit privat de maven în cadrul organizației dvs. Nu voi acoperi această porțiune în acest tutorial.

Adăugarea clasei de testare

Deoarece dependența junit este prezentă în proiect, putem adăuga clase de test.

Creați următoarea structură de dosare:

src / test / java / com / test / app / AppTest.java

AppTest.java este clasa de testare.

Copiați următorul cod în AppTest.java:

package com.first.app;
import junit.framework.TestCase;
import java.util.List;
import java.util.ArrayList;

public class AppTest extends TestCase
{
    public AppTest( String testName )
    {
        super( testName );
    }

    public void testGetSum()
    {
        List<Integer> items = new ArrayList<Integer>();
        items.add(1);
        items.add(2);
        items.add(3);
        assertEquals( 6, App.getSum(items) );
    }
}

Această clasă testează funcția getSum () prezentă în clasa de aplicații.

Ciclul de viață și fazele Maven Build

Maven urmează un ciclu de viață de construcție pentru a construi și distribui artefacte. Există trei cicluri principale de viață:

  1. Ciclul de viață implicit: Aceasta se ocupă cu construirea și implementarea artefactului.
  2. Ciclul de viață curat: Aceasta se ocupă cu curățarea proiectului
  3. Ciclul de viață al site-ului: Aceasta tratează documentația site-ului. Vom acoperi acest lucru într-un articol diferit.

Un ciclu de viață este alcătuit din faze. Iată câteva dintre fazele importante din ciclul de viață implicit:

  • valida: Verifică dacă toate informațiile necesare sunt disponibile pentru proiect
  • compila: Folosit pentru a compila fișierele sursă. Rulați următoarea comandă pentru a compila:
mvn compile
  • După executarea acestei comenzi, se creează un folder numit țintă cu toate fișierele compilate.
  • Test: Folosit pentru a rula toate testele unitare prezente în proiect. Acesta este motivul pentru care dependența Junit era necesară. Folosind Junit, pot fi scrise teste unitare. Clasele de test pot fi rulate folosind comanda
mvn test
  • pachet: Aceasta va rula toate fazele de mai sus și apoi va împacheta artefactul. Aici îl va împacheta într-un fișier borcan fișier deoarece pom indică că este nevoie de un borcan. Rulați următoarea comandă pentru aceasta:
mvn package
  • borcan fișierul este creat în interiorul fișierului ţintă pliant
  • verifica: Aceasta va asigura îndeplinirea criteriilor de calitate în proiect
  • instalare: Aceasta va instala pachetul într-un depozit local. Locația depozitului local este de obicei $ {user.home} /. m2 / depozit. Folosiți următoarea comandă pentru aceasta:
mvn install
  • implementa: Acesta este utilizat pentru a implementa pachetul într-un depozit la distanță

O altă comandă care este frecvent utilizată este comanda curată care este dată mai jos:

mvn clean

Această comandă curăță tot ce se află în interiorul ţintă pliant

Referințe

Ghidul oficial al lui Maven: https://maven.apache.org/guides/getting-started/

Mai multe despre POM: https://maven.apache.org/guides/introduction/introduction-to-the-pom.html

Mai multe despre Build Lifecycle: https://maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

Felicitări ?

Știi cum să folosești Maven acum. Acest articol a acoperit doar elementele de bază ale pom, plugin-uri, dependențe și ciclul de viață al construirii. Pentru a afla mai multe despre Maven verificați linkurile pe care le-am dat mai sus.

Codificare fericită?

Despre autor

Îmi place tehnologia și urmăresc progresele în domeniu. De asemenea, îmi place să îi ajut pe ceilalți cu cunoștințele mele tehnologice.

Nu ezitați să vă conectați cu mine pe contul meu LinkedIn https://www.linkedin.com/in/aditya1811/

Poți să mă urmărești și pe twitter https://twitter.com/adityasridhar18

Site-ul meu: https://adityasridhar.com/

Publicat inițial la adityasridhar.com.