Durante el desarrollo de software, los desarrolladores deben reconstruir el mismo código una y otra vez. A menudo intentan utilizar 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:
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 proporcionan 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:
$ hormiga-versiónHormiga apache(TM)versión 1.10.1 compilada en febrero2 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, coloque el archivo helloworld.java con el código:
/**************************Imprime '¡Hola mundo!'
***************************/
público claseHola Mundo{
público estático vacíoprincipal( Cuerda []argumentos) {
Sistema .fuera.println('¡Hola Mundo!');
}
}
Ahora, en la carpeta helloworld, cree un archivo build.xml con el siguiente código:
>
>
>
>
>
>
Y en la misma carpeta helloworld, cree el archivo ivy.xml con el siguiente código:
>
>
La estructura del directorio debería verse así:
Hola Mundo| - build.xml
| - ivy.xml
`- src
`-- helloworld.java
Ahora puede ejecutar la compilación con el comando:
$hormigafrascoUna compilación exitosa debería proporcionar un resultado como este:
$ tarro de hormigasArchivo de compilación: /Users/zak/_work/LearnBuildScripts/LearnANT/helloworld/build.xml
resolver:
[ivy: recuperar] :: Apache Ivy 2.4.0 - 20141213170938 :: http://ant.apache.org/ivy/ ::
[ivy: retrieve] :: configuración de carga :: url = jar: file: / Users / zak / BuildTools / ANT / apache
-ant-1.10.1 / lib / ivy-2.4.0.jar! /org/apache/ivy/core/settings/ivysettings.xml
[ivy: retrieve] :: resolviendo dependencias :: org.apache # helloworld; [correo electrónico protegido]
MacBook-Air.local
[ivy: retrieve] confs: [predeterminado]
[ivy: retrieve] encontró junit # junit; 4.12 en público
[ivy: retrieve] encontró org.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 | dwnlded | 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 es build.sysclasspath = last; 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 /
helloworld.jar
CONSTRUIR CON ÉXITO
Tiempo total: 6 segundos
Puede probar el archivo jar de esta manera:
$ java -cp build / bin / helloworld.frascoHola MundoHola 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 destino jar en build.xml.
Maven
Maven fue desarrollado para resolver los problemas que enfrentan los scripts basados en Ant. Conservó los archivos XML pero adoptó un enfoque diferente de organización. En Ant, los desarrolladores deben 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 --versionApache 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: /Library/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.Hola Mundo-DartifactId = helloworld-DarchetypeArtifactId = maven-Archetype-quickstart -DinteractiveMode =falso
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-archetype-plugin: 3.0.0: generate (default-cli)> generate-sources
@ 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: generate (default-cli) @ standalone-pom ---
[INFO] Generando proyecto en modo Batch
[INFO] ----------------------------------------------- -----------------------------
[INFO] Uso de los siguientes parámetros para crear un proyecto a partir del arquetipo antiguo (1.x):
Maven-arquetipo-inicio rápido: 1.0
[INFO] ----------------------------------------------- -----------------------------
[INFO] Parámetro: basedir, Valor: / Users / zak / _work / LearnBuildScripts / LearnMaven
[INFO] Parámetro: paquete, Valor: com.companyname.helloworld
[INFO] Parámetro: groupId, Valor: com.companyname.helloworld
[INFO] Parámetro: artifactId, Valor: helloworld
[INFO] Parámetro: packageName, Valor: com.companyname.helloworld
[INFO] Parámetro: versión, Valor: 1.0-SNAPSHOT
Proyecto [INFO] creado a partir del arquetipo antiguo (1.x) en el directorio: / Users / zak / _work /
LearnBuildScripts / LearnMaven / helloworld
[INFO] ----------------------------------------------- -------------------------
[INFO] CONSTRUYE EL ÉXITO
[INFO] ----------------------------------------------- -------------------------
[INFO] Tiempo total: 8.602 s
[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í:
Hola Mundo|- pom.xml
`- src
|-- principal
| `--Java
| `-- con
| `-- nombre de empresa
| `-- Hola Mundo
| `-- App.java
`--prueba
`--Java
`-- con
`-- nombre de empresa
`-- Hola Mundo
`-- AppTest.java
El pom.xml contiene las configuraciones de compilación. Dentro de pom.xml, el código se ve así:
XMLSchema-instancia '
xsi: schemaLocation='http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0
_0.xsd '>
>
>
>
Puede generar el archivo jar usando el siguiente comando:
paquete $ mvn[INFO] Escaneando proyectos ...
[INFO]
[INFO] ----------------------------------------------- -------------------------
[INFO] Building helloworld 1.0-SNAPSHOT
[INFO] ----------------------------------------------- -------------------------
[INFO]
[INFO] --- maven-resources-plugin: 2.6: recursos (recursos predeterminados) @ helloworld ---
[ADVERTENCIA] El uso de codificación de plataforma (UTF-8 en realidad) para copiar recursos filtrados, es decir
¡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 - ¡recompilando el módulo!
[ADVERTENCIA] No se ha configurado la codificación del archivo, utilizando la codificación de plataforma UTF-8, es decir, la compilación es
dependiente de la plataforma!
[INFO] Compilando 1 archivo fuente en / Users / zak / _work / LearnBuildScripts / LearnMaven /
hola mundo / objetivo / clases
[INFO]
[INFO] --- maven-resources-plugin: 2.6: testResources (default-testResources) @
Hola Mundo ---
[ADVERTENCIA] El uso de codificación de plataforma (UTF-8 en realidad) para copiar recursos filtrados, es decir
¡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 (default-testCompile) @ helloworld ---
[INFO] Cambios detectados - ¡recompilando el módulo!
[ADVERTENCIA] No se ha configurado la codificación del archivo, utilizando la codificación de plataforma UTF-8, es decir, la compilación es
dependiente de la plataforma!
[INFO] Compilando 1 archivo fuente en / Users / zak / _work / LearnBuildScripts / LearnMaven
/ helloworld / target / test-classes
[INFO]
[INFO] --- 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.companyname.helloworld.AppTest
Pruebas ejecutadas: 1, Fallos: 0, Errores: 0, Omitidos: 0, Tiempo transcurrido: 0,014 seg.
Resultados:
Pruebas ejecutadas: 1, Fallos: 0, Errores: 0, Omitidos: 0
[INFO]
[INFO] --- maven-jar-plugin: 2.4: jar (predeterminado-jar) @ helloworld ---
[INFO] Creación de jar: / Users / zak / _work / LearnBuildScripts / LearnMaven / helloworld / target /
helloworld-1.0-SNAPSHOT.jar
[INFO] ----------------------------------------------- -------------------------
[INFO] CONSTRUYE EL ÉXITO
[INFO] ----------------------------------------------- -------------------------
[INFO] Tiempo total: 5.624 s
[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 target / helloworld-1.0-INSTANTÁNEA.frascocon.nombre de empresa.Hola Mundo.AplicaciónHola 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. Se ha adoptado rápidamente. Google lo está usando actualmente para el sistema operativo Android.
En lugar de XML, Gradle usa el lenguaje Groovy. Como resultado, los scripts de compilación en Gradle son más fáciles de escribir y leer. Inicialmente usaba 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 de IDE no es tan buena como la de 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--versión------------------------------------------------------------
Gradle4.5
------------------------------------------------------------
Tiempo de construcción:2018-01-24 17:04:52UTC
Revisión: 77d0ec90636f43669dc794ca17ef80dd65457bec
Maravilloso: 2.4.12
Hormiga: Apache Ant(TM)versión 1.9.9 compilada en febrero2 2017
JVM: 1.8.0_74(Oracle Corporation25.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 helloworld.java ponga el código del ejemplo de Ant. Y para build.gradle ponga 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 el archivo build.gradle y te muestra las tareas adicionales disponibles debido a los complementos.
Puede obtener la compilación ejecutando:
$ tarro gradleCONSTRUIR EXITOSO en 1 s
2tareas accionables:2ejecutado
Puede ejecutar su jar de esta manera:
$ java -cp build / libs / helloworld-1.0.frascoHola MundoHola 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://ant.apache.org/
- http://ant.apache.org/ivy/
- https://maven.apache.org/
- https://gradle.org/
- http://makble.com/gradle-junit-helloworld-example
- https://examples.javacodegeeks.com/core-java/gradle/gradle-hello-world-tutorial/
- https://gradle.org/maven-vs-gradle/
- https://maven.apache.org/guides/getting-started/maven-in-five-minutes.html
- https://stackoverflow.com/questions/20755437/java-build-tools-ant-vs-maven
- https://technologyconversations.com/2014/06/18/build-tools/
- https://www.quora.com/What-are-the-pros-and-cons-of-Maven-versus-Ant-as-building-tools-for-Java