Hogyan kezdhetem el Maven-t

A Maven-et nagyon gyakran használják az iparban, és úgy éreztem, hogy jó lenne áttekinteni a cikk alapjait, hogy hatékonyan lehessen használni.

Ez a cikk olyan dolgokkal foglalkozik, mint a maven alapjai, a maven pluginjei, a maven függőségei és a maven build életciklusa.

Mi az a Maven

A Maven-t azért hozták létre, hogy szabványos módon biztosítsa a Projektek felépítését. Az egyik legfontosabb jellemzője a függőségkezelés.

A Maven-t általában a függőség kezelésére használják, de nem csak erre képes.

Ha nem tudja, mit jelent a függőségkezelés, ne aggódjon? Erre a cikkben is kitérek.

A Maven telepítése

A Maven telepítése a //maven.apache.org/ webhelyről lehetséges.

Győződjön meg arról is, hogy Maven be van-e állítva a PATH-ban, hogy a mvnparancsok működjenek.

A paranccsal ellenőrizheti, hogy telepítve van-e és elérhető-e

mvn -v

Győződjön meg arról is, hogy a JAVA_HOME be van-e állítva.

Alapértelmezés szerint Maven a JAVA_HOME-ban megadott jdk-t fogja használni. Ez felülírható, de ehhez a cikkhez a JAVA_HOME-ban megadott jdk-t fogjuk használni.

Készítse el Maven projektjét

Általában egy IDE-hez hasonló napfogyatkozás használható könnyedén elkészített projektek létrehozására. De ebben az articusban a parancsokat a parancssorból fogom futtatni, hogy a lépések egyértelműen érthetők legyenek.

Futtassa a következő parancsot a projekt létrehozásához.

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

A fenti parancs archetípusa nem más, mint egy minta projekt sablon. A groupdId megmondja, hogy a projekt melyik csoportba tartozik, az artifactId pedig a projekt neve.

A fenti parancs futtatása után a szükséges pluginek letöltése és a projekt létrehozása eltarthat egy percig.

Most létrejön az első maven-app nevű mappa. Nyissa meg a mappát, és meglátja a pom.xml nevű fájlt

pom.xml

A POM a Project Object Model rövidítést jelenti. A pom.xml tartalmazza a projekt minden részletét, és itt fogja megmondani Mavennek, hogy mit kell tennie.

A fájl tartalma az alábbiakban látható:

  4.0.0 com.first.app first-maven-app jar 1.0-SNAPSHOT first-maven-app //maven.apache.org   junit junit 3.8.1 test   

A groupdId és az artifactId ugyanazok az értékek, amelyeket a parancssorban adtunk meg.

a csomagolás a mű csomagjának formátuma. Alapértelmezett értéke jar . Lehetnek más értékei is, például fül, háború, kátrány és így tovább.

version jelzi a műtárgy verziószámát. Ha az SNAPSHOT jelen van, akkor ez azt jelzi, hogy a verzió még mindig devben van, és lehet, hogy nem stabil. Ha a verziószámban nincs SNAPSHOT, akkor ez a tényleges kiadási verzió.

név a projekt neve.

Az alábbiakban elmagyarázom a Maven függőségeit és bővítményeit.

Szuper POM

A pom.xml, amint láthatja, elég kicsi. Ennek az az oka, hogy a konfiguráció nagy része benne van a Super POM nevűben, amelyet Maven belsőleg karbantart.

A pom.xml kiterjeszti a Super Pom-ot, hogy az összes konfiguráció jelen legyen a super Pom-ban.

A Super Pom egyik jelen lévő konfigurációja a következőket jelzi:

  • Az összes java forráskód az src / main / java fájlban található
  • Minden java tesztkód megtalálható az src / test / java belsejében

Itt csak ezt a konfigurációt említem, mivel ebben a cikkben mind a forráskóddal, mind a tesztkóddal foglalkozunk.

Kód

Az itt tárgyalt teljes kód ebben a repóban érhető el: //github.com/aditya-sridhar/first-maven-app

Adjunk hozzá néhány egyszerű Java-kódot. Hozza létre a következő mappastruktúrát:

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

Az App.java az a Java-kód, amelyet hozzáadunk.

Másolja a következő kódot az App.java fájlba:

package com.first.app; import java.util.List; import java.util.ArrayList; public class App { public static void main( String[] args ) { List items = new ArrayList(); items.add(1); items.add(2); items.add(3); printVals(items); System.out.println("Sum: "+getSum(items)); } public static void printVals(List items){ items.forEach( item ->{ System.out.println(item); }); } public static int getSum(List items){ int sum = 0; for(int item:items){ sum += item; } return sum; } } 

Ez egy egyszerű kód, amely 2 funkcióval rendelkezik.

De egy dolgot meg kell figyelni, hogy a kód lambda kifejezéseket használ a printVals függvény forEach ciklusán belül .

A Lambda kifejezések futtatásához legalább Java 8 szükséges. De alapértelmezés szerint a Maven 3.8.0 a Java 1.6 verzióval fut.

Tehát meg kell mondanunk a mavennek, hogy ehelyett Java 1.8-at használjon. Ehhez a Maven Plugins alkalmazást fogjuk használni.

Maven Plugins

A Maven Compiler beépülő modullal jelezzük, melyik Java verziót kell használni. Adja hozzá a következő sorokat a pom.xml fájlhoz:

 ...    org.apache.maven.plugins maven-compiler-plugin 3.8.0  1.8 1.8     ... 

Láthatja, hogy a Java forrás- és célverziói 1,8-ra vannak állítva .

A beépülő modulok alapvetően mavenben hajtanak végre valamilyen műveletet. A fordító plugin fordítja a forrásfájlokat.

A teljes pom.xml itt érhető el.

Nagyon sok maven plugin érhető el. A Maven jól tudja használni a bővítményeket, és elképesztő dolgokra képes. ?

Maven-függőségek

Általában a kód írása során sok meglévő könyvtárat fogunk használni. Ezek a meglévő könyvtárak nem mások, mint függőségek. A Maven segítségével könnyen kezelhetők a függőségek.

In the pom.xml of our project you can see the following dependency:

   junit junit 3.8.1 test  

This dependency is telling that we will be needing junit. Junit is used to write Unit Tests for Java code. Similarly a lot of other dependencies can be added.

Let’s say you want to handle JSON in the code. Then you can add the gson dependency as shown below:

 com.google.code.gson gson 2.8.5 

You can search for Maven artifacts in //search.maven.org

Transitive Dependencies

Let’s say you add a dependency A to the Project. Now A depends on a dependency called B. B depends on a dependency called C.

Since you are using A in the project, you will also need B and C.

But fortunately, it is enough if you add only A in pom.xml. Because Maven can figure out that A depends on B and that B depends on C. So internally Maven will automatically download B and C.

Here B and C are transitive dependencies.

Custom Maven Repository

All these dependencies are available in a Public Maven Central Repository //repo.maven.apache.org/maven2

It is possible that there are some artifacts which are private to your company. In this case, you can maintain a private maven repository within your organization. I won’t be covering this portion in this tutorial.

Adding the test class

Since the junit dependency is present in the project, we can add test Classes.

Create the following folder structure:

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

AppTest.java is the Test Class.

Copy the following code into 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 items = new ArrayList(); items.add(1); items.add(2); items.add(3); assertEquals( 6, App.getSum(items) ); } }

This class tests the getSum() function present in the App Class.

Maven Build Lifecycle and Phases

Maven follows a build lifecycle to build and distribute artifacts. There are three main lifecycles:

  1. Default lifecycle: This deals with building and deploying the artifact.
  2. Clean lifecycle: This deals with project cleaning
  3. Site lifecycle: This deals with Site documentation. Will cover this in a different article.

A Lifecycle is made up of phases. Here are some of the important phases in the default lifecycle:

  • validate: Checks if all necessary information is available for the project
  • compile: Used to compile the source files. Run the following command to compile:
mvn compile
  • After running this command, a folder called target is created with all the compiled files.
  • test: Used to run all the unit tests present in the project. This is why the Junit dependency was needed. Using Junit, unit tests can be written. Test classes can be run using the command
mvn test
  • package: This will run all the above phases and then package the artifact. Here it will package it into a jar file since pom indicates a jar is needed. Run the following command for this:
mvn package
  • The jar file is created inside the target folder
  • verify: This will ensure that quality criteria is met in the project
  • install: This will install the package in a local repository. The local repository location is usually ${user.home}/.m2/repository. Use the following command for this:
mvn install
  • deploy: This is used to deploy the package to a remote repository

One more command which is commonly used is the clean command which is given below:

mvn clean

This command cleans up everything inside the target folder

References

Maven’s Offical Guide: //maven.apache.org/guides/getting-started/

More about POM : //maven.apache.org/guides/introduction/introduction-to-the-pom.html

More about Build Lifecycle : //maven.apache.org/guides/introduction/introduction-to-the-lifecycle.html

Congrats ?

You know how to use Maven now. This article covered just the basics of pom, plugins, dependencies and build lifecycle. To know more about Maven check the links I have given above.

Happy Coding ?

About the author

I love technology and follow the advancements in the field. I also like helping others with my technology knowledge.

Feel free to connect with me on my LinkedIn account //www.linkedin.com/in/aditya1811/

You can also follow me on twitter //twitter.com/adityasridhar18

My Website: //adityasridhar.com/

Originally published at adityasridhar.com.