Cómo empezar con Maven

Maven se usa con mucha frecuencia en la industria y sentí que sería bueno cubrir los conceptos básicos en este artículo para que pueda usarse de manera eficiente.

Este artículo cubrirá aspectos como conceptos básicos de maven, complementos de maven, dependencias de maven y ciclo de vida de compilación de maven.

Que es Maven

Maven se creó para proporcionar una forma estándar en la que se pueden construir proyectos. Una de sus poderosas funciones es la gestión de dependencias.

Maven se usa comúnmente para la gestión de dependencias, pero no es lo único que es capaz de hacer.

Si no sabes lo que significa la gestión de dependencias, no te preocupes ?. Cubriré eso en este artículo también.

Instalación de Maven

Puede instalar Maven desde //maven.apache.org/

También asegúrese de que Maven esté configurado en la RUTA para que los mvncomandos funcionen.

Puede verificar si está instalado y se puede acceder usando el comando

mvn -v

También asegúrese de que JAVA_HOME esté configurado.

De forma predeterminada, Maven usará el jdk que proporcionó en JAVA_HOME. Esto se puede anular, pero para este artículo usaremos el jdk proporcionado en JAVA_HOME.

Crea tu proyecto Maven

Normalmente, un IDE como eclipse se puede utilizar para crear fácilmente proyectos maven. Pero en este artículo ejecutaré los comandos desde la línea de comandos para que los pasos se entiendan claramente.

Ejecute el siguiente comando para crear el proyecto.

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

El arquetipo en el comando anterior no es más que una plantilla de proyecto de muestra. groupdId indica a qué grupo pertenece su proyecto y artifactId es el nombre del proyecto.

Una vez que ejecute el comando anterior, maven puede tardar un minuto más o menos en descargar los complementos necesarios y crear el proyecto.

Ahora se crea una carpeta llamada first-maven-app. Abra la carpeta y verá un archivo llamado pom.xml

pom.xml

POM son las siglas de Project Object Model. pom.xml tiene todos los detalles sobre su proyecto, y aquí es donde le dirá a Maven lo que debe hacer.

El contenido de este archivo se muestra a continuación:

  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   

groupdId y artifactId son los mismos valores que le dimos en la línea de comando.

packaging es el formato de paquete del artefacto. El valor predeterminado es jar . Puede tener otros valores, así como ear, war, tar, etc.

versión indica el número de versión del artefacto. Si SNAPSHOT está presente, indica que la versión todavía está en desarrollo y puede que no sea estable. Si el número de versión no tiene SNAPSHOT, entonces es la versión de lanzamiento real.

name es el nombre del proyecto.

Explicaré sobre las dependencias y los complementos en Maven a continuación.

Super POM

pom.xml, como puede ver, es bastante pequeño. La razón de esto es que gran parte de la configuración está presente en algo llamado Super POM que Maven mantiene internamente.

pom.xml extiende Super Pom para obtener todas las configuraciones presentes en super Pom.

Una de las configuraciones presentes en Super Pom indica lo siguiente:

  • Todo el código fuente de Java está presente dentro de src / main / java
  • Todo el código de prueba de Java está presente dentro de src / test / java

Menciono solo esta configuración aquí, ya que trataremos tanto el código fuente como el código de prueba en este artículo.

Código

El código completo discutido aquí está disponible en este repositorio: //github.com/aditya-sridhar/first-maven-app

Agreguemos un código Java simple. Cree la siguiente estructura de carpetas:

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

App.java es el código Java que agregaremos .

Copie el siguiente código en App.java:

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

Este es un código simple que tiene 2 funciones.

Pero una cosa a observar es que el código usa expresiones lambda dentro del ciclo forEach en la función printVals .

Las expresiones Lambda necesitan como mínimo Java 8 para ejecutarse. Pero, de forma predeterminada, Maven 3.8.0 se ejecuta con la versión 1.6 de Java.

Así que necesitamos decirle a maven que use Java 1.8 en su lugar. Para hacer esto usaremos complementos de Maven.

Complementos de Maven

Usaremos el complemento del compilador de Maven para indicar qué versión de Java usar. Agregue las siguientes líneas a pom.xml:

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

Puede ver que las versiones de origen y destino de Java están configuradas en 1.8 .

Los complementos básicamente realizan alguna acción en maven. El complemento del compilador compila los archivos fuente.

El pom.xml completo está disponible aquí.

Hay muchos complementos de Maven disponibles. Al saber cómo usar bien los complementos, Maven puede usarse para hacer cosas increíbles. ?

Dependencias de Maven

Normalmente, mientras escribimos código, usaremos muchas bibliotecas existentes. Estas bibliotecas existentes no son más que dependencias. Maven se puede utilizar para administrar dependencias fácilmente.

En el pom.xml de nuestro proyecto puedes ver la siguiente dependencia:

   junit junit 3.8.1 test  

Esta dependencia nos dice que necesitaremos junit . Junit se utiliza para escribir pruebas unitarias para código Java. De manera similar, se pueden agregar muchas otras dependencias.

Digamos que quiere manejar JSON en el código. Luego puede agregar la dependencia gson como se muestra a continuación:

 com.google.code.gson gson 2.8.5 

Puede buscar artefactos de Maven en //search.maven.org

Dependencias transitivas

Digamos que agrega una dependencia A al proyecto. Ahora Una depende de una dependencia denominada B . B depende de una dependencia llamada C .

Dado que está utilizando una en el proyecto, también tendrá que B y C .

Pero, afortunadamente, es suficiente si agrega solo A en pom.xml. Debido a Maven puede darse cuenta de que A depende de B y B que depende de C. Por lo tanto internamente Maven descargará automáticamente B y C .

Aquí B y C son dependencias transitivas.

Repositorio personalizado de Maven

Todas estas dependencias están disponibles en un repositorio central público de Maven //repo.maven.apache.org/maven2

Es posible que haya algunos artefactos que sean privados de su empresa. En este caso, puede mantener un repositorio privado de maven dentro de su organización. No cubriré esta parte en este tutorial.

Añadiendo la clase de prueba

Dado que la dependencia junit está presente en el proyecto, podemos agregar clases de prueba.

Cree la siguiente estructura de carpetas:

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.