Elegir la herramienta de construcción adecuada: Ant vs Maven vs Gradle

Durante el desarrollo de software, los desarrolladores deben reconstruir el mismo código una y otra vez. A menudo intentan usar scripts bash u otros lenguajes de scripting para automatizar la tarea. Sin embargo, hay herramientas de compilación disponibles que son más apropiadas para la automatización de compilación. Las herramientas de construcción predominantes son:

Hormiga Apache con Ivy
Maven
Gradle

Investiguemos las herramientas para obtener más información.

Hormiga Apache con Ivy

Apache Ant es una herramienta de línea de comandos basada en Java que utiliza archivos XML para definir scripts de compilación. Se usa principalmente para compilaciones de Java, pero también se puede usar para el desarrollo de C / C ++. Las tareas integradas brindan formas de compilar, ensamblar, probar y ejecutar aplicaciones de software. Los usuarios también pueden crear sus propios "antlibs" para mejorar la funcionalidad de Ant. Apache Ivy es una herramienta de gestión de dependencias que se integra fácilmente con Ant para proporcionar un ecosistema más robusto. El desarrollo de Ant comenzó en 2000.

Pros

Mejor control sobre el proceso de construcción general
Lo suficientemente flexible para trabajar con cualquier proceso de trabajo

Contras

Los archivos de compilación basados en XML pueden crecer mucho y no se pueden mantener
Se necesita mucho tiempo y recursos para mantener los scripts de compilación
La integración IDE es difícil de lograr

Ejemplo de hormiga con hiedra

Puede instalar la última Ant desde aquí. Tienes que descargar el zip, expandir y poner la carpeta bin en tu ruta. Puede usar el siguiente comando para ver si Ant está instalado correctamente:

$ ant -version
Apache Ant (TM) versión 1.10.1 compilado el 2 de febrero de 2017

Una vez que haya instalado Ant, puede descargar el último jar de Ivy y colocarlo en la carpeta lib dentro del directorio Ant.

Una vez que haya instalado Ant, cree las carpetas helloworld y helloworld / src. Dentro de la carpeta src, ponga helloworld.archivo java con el código:

/ **************************
Imprime "Hola mundo!"
*************************** /
helloworld clase pública
public static void main (String [] args)
Sistema.fuera.println ("Hola mundo!");

Ahora en la carpeta helloworld crea una compilación.xml con el siguiente código:

Y en la misma carpeta helloworld, crea la hiedra.xml con el siguiente código:

La estructura del directorio debería verse así:

Hola Mundo
| - construir.xml
| - hiedra.xml
'- src
'-- Hola Mundo.Java

Ahora puede ejecutar la compilación con el comando:

$ tarro de hormigas

Una compilación exitosa debería proporcionar un resultado como este:

$ tarro de hormigas
Archivo de compilación: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build.xml
resolver:
[ivy: recuperar] :: Apache Ivy 2.4.0-20141213170938 :: http: // hormiga.apache.org / ivy / ::
[ivy: retrieve] :: configuración de carga :: url = jar: file: / Users / zak / BuildTools / ANT / apache
-hormiga-1.10.1 / lib / ivy-2.4.0.frasco!/ org / apache / ivy / core / settings / ivysettings.xml
[ivy: retrieve] :: resolviendo dependencias :: org.apache # helloworld; [correo electrónico protegido]
MacBook Air.local
[ivy: recuperar] confs: [predeterminado]
[ivy: retrieve] encontró junit # junit; 4.12 en público
[ivy: recuperar] organización encontrada.hamcrest # hamcrest-core; 1.3 en público
[Ivy: recuperar] :: informe de resolución :: resolver 397ms :: artefactos dl 15ms
---------------------------------------------------------------------
| | módulos || artefactos |
| conf | numero | buscar | abatido | desalojado || número | dwnlded |
---------------------------------------------------------------------
| por defecto | 2 | 0 | 0 | 0 || 4 | 0 |
---------------------------------------------------------------------
[ivy: recuperar] :: recuperar :: org.apache # helloworld
[ivy: retrieve] confs: [predeterminado]
[ivy: retrieve] 0 artefactos copiados, 4 ya recuperados (0kB / 39ms)
compilar:
[mkdir] Directorio creado: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build /
clases
[javac] / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build.xml: 22: advertencia:
'includeantruntime' no se estableció, por defecto para construir.sysclasspath = último; establecer en falso
para compilaciones repetibles
[javac] Compilando 1 archivo fuente en / Users / zak / _work / LearnBuildScripts / LearnANT /
helloworld / build / classes
frasco:
[mkdir] Directorio creado: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build / bin
[jar] Jar de construcción: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build / bin /
Hola Mundo.frasco
CONSTRUIR CON ÉXITO
Tiempo total: 6 segundos

Puede probar el archivo jar de esta manera:

$ java -cp build / bin / helloworld.jar helloworld
Hola Mundo!

Hemos definido el archivo jar que se colocará en la carpeta build / bin. Las carpetas se crean durante la compilación. El comando ant jar llama al objetivo jar en la compilación.xml.

Maven

Maven fue desarrollado para resolver los problemas que enfrentan las secuencias de comandos basadas en Ant. Conservó los archivos XML, pero adoptó un enfoque diferente de la organización. En Ant, los desarrolladores tienen que crear todas las tareas. Maven reduce la creación de tareas implementando estándares más estrictos para organizar el código. Como resultado, es más fácil comenzar con proyectos estándar.

También introdujo descargas de dependencia que facilitaron el desarrollo. Antes de la introducción de Ivy en Ant, los usuarios tenían que administrar las dependencias localmente. Maven adoptó primero la filosofía de gestión de la dependencia.

Sin embargo, los estrictos estándares de Mavens dificultan la escritura de scripts de compilación personalizados. Es fácil trabajar con la herramienta siempre que el proyecto siga los estrictos estándares.

Pros

Descargas de dependencias automáticas
Todas las dependencias se registran automáticamente en el control de código fuente como parte de los scripts de Maven
Estandariza y simplifica el proceso de construcción
Se integra fácilmente con sistemas IDE y CI / CD

Contras

No es flexible en la creación de flujos de trabajo personalizados
Curva de aprendizaje empinada y el proceso es difícil de entender para los principiantes
Requiere mucho tiempo resolver problemas de construcción y nuevas integraciones de bibliotecas
No es bueno con varias versiones de la misma dependencia

Ejemplo de Maven

Puede descargar la última versión de Maven desde aquí. Puede verificar la instalación de esta manera:

$ mvn --version
Apache Maven 3.5.2 (138edd61fd100ec658bfa2d307c43b76940a5d7d; 2017-10-18T00: 58: 13-07: 00)
Inicio de Maven: / Users / zak / BuildTools / Maven / apache-maven-3.5.2
Versión de Java: 1.8.0_74, proveedor: Oracle Corporation
Inicio de Java: / Biblioteca / Java / JavaVirtualMachines / jdk1.8.0_74.jdk / Contenidos / Inicio / jre
Configuración regional predeterminada: en_US, codificación de plataforma: UTF-8
Nombre del sistema operativo: "mac os x", versión: "10.11.6 ", arco:" x86_64 ", familia:" mac "

Crea una carpeta helloworld y genera un proyecto con el siguiente comando:

$ mvn arquetipo: generar -DgroupId = com.nombre de empresa.helloworld -DartifactId = helloworld
-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = false

Debería crear la estructura de carpetas y generar la salida que se ve así:

[INFO] Escaneando proyectos…
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (sin POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFORMACIÓN] >>> maven-arquetipo-complemento: 3.0.0: generar (cli predeterminado)> generar fuentes
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.0.0:generate (default-cli) < generate-sources
@ standalone-pom <<<
[INFO]
[INFO]
[INFO] --- maven-archetype-plugin: 3.0.0: generar (predeterminado-cli) @ standalone-pom ---
[INFO] Generando proyecto en modo Batch
[INFO] ----------------------------------------------------------------------------
[INFO] Utilizando los siguientes parámetros para crear un proyecto desde Antiguo (1.x) Arquetipo:
Maven-arquetipo-inicio rápido: 1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parámetro: basedir, Valor: / Users / zak / _work / LearnBuildScripts / LearnMaven
[INFO] Parámetro: paquete, Valor: com.nombre de empresa.Hola Mundo
[INFO] Parámetro: groupId, Valor: com.nombre de empresa.Hola Mundo
[INFO] Parámetro: artifactId, Valor: helloworld
[INFO] Parámetro: packageName, Valor: com.nombre de empresa.Hola Mundo
[INFO] Parámetro: versión, Valor: 1.0-INSTANTÁNEA
[INFO] proyecto creado a partir de Antiguo (1.x) Arquetipo en el directorio: / Users / zak / _work /
LearnBuildScripts / LearnMaven / helloworld
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUYE EL ÉXITO
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 8.602 segundos
[INFO] Finalizado en: 2018-01-27T00: 05: 37-08: 00
[INFO] Memoria final: 15 M / 152 M
[INFO] ------------------------------------------------------------------------

La estructura de la carpeta debería verse así:

El pom.xml contiene las configuraciones de compilación. Dentro del pom.xml, el código se ve así:

xsi: schemaLocation = "http: // maven.apache.org / POM / 4.0.0 http: // maven.apache.org / maven-v4_0
_0.xsd ">
4.0.0
com.nombre de empresa.Hola Mundo
Hola Mundo
frasco
1.0-INSTANTÁNEA
Hola Mundo
http: // maven.apache.org

junit
junit
3.8.1
prueba

Puede generar el archivo jar usando el siguiente comando:

paquete $ mvn
[INFO] Escaneando proyectos…
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Construyendo helloworld 1.0-INSTANTÁNEA
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin: 2.6: recursos (recursos predeterminados) @ helloworld ---
[ADVERTENCIA] Al usar la codificación de plataforma (UTF-8 en realidad) para copiar recursos filtrados,.mi.
la construcción depende de la plataforma!
[INFO] omitir directorio de recursos no existente / Usuarios / zak / _work / LearnBuildScripts / LearnMaven /
helloworld / src / main / resources
[INFO]
[INFO] --- maven-compiler-plugin: 3.1: compilar (compilación predeterminada) @ helloworld ---
[INFO] Cambios detectados: recompilación del módulo!
[ADVERTENCIA] No se ha configurado la codificación del archivo, utilizando la codificación de plataforma UTF-8, i.mi. construir es
dependiente de la plataforma!
[INFO] Compilando 1 archivo fuente en / Users / zak / _work / LearnBuildScripts / LearnMaven /
hola mundo / objetivo / clases
[INFO]
[INFORMACIÓN] --- maven-resources-plugin: 2.6: testResources (predeterminado-testResources) @
Hola Mundo ---
[ADVERTENCIA] Al usar la codificación de plataforma (en realidad, UTF-8) para copiar recursos filtrados,.mi.
la construcción depende de la plataforma!
[INFO] omitir directorio de recursos no existente / Usuarios / zak / _work / LearnBuildScripts / LearnMaven /
helloworld / src / test / resources
[INFO]
[INFO] --- maven-compiler-plugin: 3.1: testCompile (predeterminado-testCompile) @ helloworld ---
[INFO] Cambios detectados: recompilación del módulo!
[ADVERTENCIA] No se ha configurado la codificación del archivo, utilizando la codificación de plataforma UTF-8, i.mi. construir es
dependiente de la plataforma!
[INFO] Compilando 1 archivo fuente en / Users / zak / _work / LearnBuildScripts / LearnMaven
/ helloworld / target / test-classes
[INFO]
[INFORMACIÓN] --- maven-surefire-plugin: 2.12.4: prueba (prueba predeterminada) @ helloworld ---
[INFO] Directorio de informes Surefire: / Users / zak / _work / LearnBuildScripts / LearnMaven
/ helloworld / target /
informes-infalibles
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Ejecutando com.nombre de empresa.Hola Mundo.AppTest
Pruebas ejecutadas: 1, Fallos: 0, Errores: 0, Omitidos: 0, Tiempo transcurrido: 0.014 segundos
Resultados:
Pruebas ejecutadas: 1, Fallos: 0, Errores: 0, Omitidos: 0
[INFO]
[INFORMACIÓN] --- maven-jar-plugin: 2.4: jar (jar por defecto) @ helloworld ---
[INFO] Creación de jar: / Users / zak / _work / LearnBuildScripts / LearnMaven / helloworld / target /
hola mundo-1.0-INSTANTÁNEA.frasco
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUYE EL ÉXITO
[INFO] ------------------------------------------------------------------------
[INFO] Tiempo total: 5.624 segundos
[INFO] Finalizado en: 2018-01-27T00: 11: 10-08: 00
[INFO] Memoria final: 16M / 114M
[INFO] ------------------------------------------------------------------------

Puede ejecutar el archivo jar de esta manera:

$ java -cp destino / helloworld-1.0-INSTANTÁNEA.jar com.nombre de empresa.Hola Mundo.Aplicación
Hola Mundo!

El archivo jar se coloca en la carpeta de destino.

Gradle

Gradle combina el poder de Ant y Maven. La primera versión de Gradle se lanzó en 2012. Ha tenido una rápida adopción. Google lo está usando actualmente para el sistema operativo Android.

En lugar de XML, Gradle usa el lenguaje Groovy. Como resultado, las secuencias de comandos de compilación en Gradle son más fáciles de escribir y leer. Inicialmente estaba usando Ivy para la administración de dependencias, pero ahora está usando su propio motor de dependencia.

Pros

Proporciona estandarización sin dejar de ser flexible
Scripts de compilación fáciles de leer y escribir
Mejor manejando múltiples versiones de dependencias
Capaz de manejar múltiples lenguajes y tecnologías de programación
Comunidad activa que ayuda a desarrollar la herramienta
Gradle DSL (lenguaje específico de dominio) simplifica la estructura de configuración
Gradle proporciona mejoras de rendimiento usando incrementalmente, build cache y Gradle Daemon

Contras

La integración IDE no es tan buena como Maven

Ejemplo de Gradle

Puedes instalar Gradle desde aquí. Una vez que haya configurado Gradle en su camino, puede verificarlo de la siguiente manera:

$ gradle --version
------------------------------------------------------------
Gradle 4.5
------------------------------------------------------------
Tiempo de construcción: 2018-01-24 17:04:52 UTC
Revisión: 77d0ec90636f43669dc794ca17ef80dd65457bec
Maravilloso: 2.4.12
Ant: Apache Ant (TM) versión 1.9.9 compilado el 2 de febrero de 2017
JVM: 1.8.0_74 (Oracle Corporation 25.74-b02)
SO: Mac OS X 10.11.6 x86_64

A continuación, cree la siguiente estructura de directorios:

Hola Mundo
| - construir.gradle
'- src
| - principal
'- java
'-- Hola Mundo
'-- Hola Mundo.Java

Para el hola mundo.java puso el código del ejemplo de Ant. Y para construir.gradle puso el siguiente código:

aplicar complemento: 'java'
versión = '1.0 '
repositorios
mavenCentral ()

dependencias
testCompile grupo: 'junit', nombre: 'junit', versión: '4.12 '

Puede usar el comando "gradle tasks -all" para ver todos los comandos disponibles. Gradle recoge automáticamente los complementos que especificas en la compilación.gradle y le muestra las tareas adicionales disponibles debido a los complementos.

Puede obtener la compilación ejecutando:

$ tarro gradle
CONSTRUYE EXITOSO en 1 s
2 tareas procesables: 2 ejecutadas

Puede ejecutar su jar de esta manera:

$ java -cp build / libs / helloworld-1.0.jar helloworld
Hola Mundo!

El archivo jar se coloca en la carpeta build / libs.

Conclusión

Entre las herramientas de compilación, Ant puede ser útil para proyectos más pequeños, mientras que Maven es mejor para asegurarse de que todos los desarrolladores sigan las mismas reglas. Gradle es la última herramienta que proporciona la mayor flexibilidad.

Referencias:

http: // hormiga.apache.org /
http: // hormiga.apache.org / ivy /
https: // maven.apache.org /
https: // gradle.org /
http: // makble.com / gradle-junit-helloworld-example
https: // ejemplos.javacodegeeks.com / core-java / gradle / gradle-hello-world-tutorial /
https: // gradle.org / maven-vs-gradle /
https: // maven.apache.org / guides / Getting-started / maven-en-cinco-minutos.html
https: // stackoverflow.com / questions / 20755437 / java-build-tools-ant-vs-maven
https: // conversaciones sobre tecnología.com / 2014/06/18 / build-tools /
https: // www.quora.com / ¿Cuáles-son-los-pros-y-contras-de-Maven-versus-Ant-como-herramientas-de-construcción-para-Java