Choisir le bon outil de construction: Ant vs Maven vs Gradle

Pendant le développement de logiciels, les développeurs doivent reconstruire le même code encore et encore. Ils essaient souvent d'utiliser des scripts bash ou d'autres langages de script pour automatiser la tâche. Cependant, il existe des outils de construction qui sont plus appropriés pour l'automatisation de la construction. Les outils de construction prédominants sont:

• ANT APACH avec Ivy
• Maven
• Grade

Enquêtons sur les outils pour en savoir plus.

ANT APACH avec Ivy

Apache Ant est un outil de ligne de commande basé sur Java qui utilise des fichiers XML pour définir les scripts de construction. Il est principalement utilisé pour les constructions Java, mais il peut également être utilisé pour le développement C / C ++. Les tâches intégrées fournissent des moyens de compiler, assembler, tester et exécuter des applications logicielles. Les utilisateurs peuvent également créer leurs propres «antlibs» pour améliorer la fonctionnalité de la fourmi. Apache Ivy est un outil de gestion des dépendances qui s'intègre facilement à la fourmi pour fournir un écosystème plus robuste. Le développement de la fourmi a commencé en 2000.

Avantages

• Meilleur contrôle sur le processus de construction global
• Suffisamment flexible pour travailler avec n'importe quel processus de travail

Les inconvénients

• Les fichiers de construction basés sur XML peuvent augmenter et incomparables
• Beaucoup de temps et de ressources sont nécessaires pour maintenir les scripts de construction
• L'intégration IDE est difficile à réaliser

Fourmi avec exemple de lierre

Vous pouvez installer la dernière fourmi à partir d'ici. Vous devez télécharger le zip, développer et mettre le dossier bin dans votre chemin. Vous pouvez utiliser la commande suivante pour voir si Ant est correctement installée:

$ Ant-Version
Apache Ant (TM) Version 1.dix.1 compilé le 2 février 2017

Une fois que vous avez installé Ant, vous pouvez télécharger le dernier pot Ivy et le mettre dans le dossier Lib à l'intérieur du répertoire Ant.

Une fois la fourmi installée, créez des dossiers Helloworld et Helloworld / SRC. À l'intérieur du dossier SRC, mettez Helloworld.Fichier Java avec le code:

/ **************************
Imprime "Hello World!"
*************************** /
classe publique Helloworld
public static void main (String [] args)
Système.dehors.println ("Hello World!");

Maintenant dans le dossier Helloworld Créez une construction.Fichier XML avec le code suivant:

Et dans le même dossier Helloworld, créez le lierre.Fichier XML avec le code suivant:

La structure du répertoire devrait ressembler à ceci:

Bonjour le monde
| - construire.xml
| - Ivy.xml
'- SRC
'-- Bonjour le monde.Java

Vous pouvez maintenant exécuter la construction avec la commande:

$ bot ant

Une construction réussie devrait fournir une sortie comme celle-ci:

$ bot ant
Buildfile: / utilisateurs / zak / _work / LearnBuildScripts / Learnant / Helloworld / build.xml
résoudre:
[ivy: récupérer] :: apache ivy 2.4.0 - 20141213170938 :: http: // ant.apache.org / ivy / ::
[ivy: récupérer] :: Chargement Paramètres :: url = jar: fichier: / users / zak / buildtools / ant / apache
-ant-1.dix.1 / lib / ivy-2.4.0.pot!/ org / apache / ivy / core / paramètres / ivysettings.xml
[Ivy: récupérer] :: Résolution des dépendances :: org.apache # helloworld; travail @ zakirs-
Macbook Air.local
[ivy: récupération] Confs: [par défaut]
[Ivy: récupérer] Found Junit # Junit; 4.12 en public
[Ivy: récupérer] Org trouvé.Hamcrest # Hamcrest-core; 1.3 en public
[Ivy: Récupération] :: Resolution Rapport :: Resolve 397ms :: Artefacts dl 15ms
---------------------------------------------------------------------
| | modules || Artefacts |
| conf | Numéro | Recherche | Dwnlded | expulsé || Numéro | Dwnlded |
---------------------------------------------------------------------
| par défaut | 2 | 0 | 0 | 0 || 4 | 0 |
---------------------------------------------------------------------
[ivy: récupérer] :: récupérer :: org.Apache # Helloworld
[ivy: récupération] Confs: [par défaut]
[Ivy: récupérer] 0 artefacts copiés, 4 déjà récupérés (0kb / 39 ms)
compiler:
[mkdir] a créé dir: / utilisateurs / zak / _Work / LearnBuildScripts / Learnant / Helloworld / build /
Des classes
[Javac] / Users / Zak / _Work / LearnBuildScripts / Learnant / Helloworld / Build.XML: 22: AVERTISSEMENT:
'incluant le temps n'était pas réglé, défautant pour construire.sysclasspath = dernier; réglé sur false
Pour les constructions reproductibles
[Javac] Compilant 1 fichier source à / utilisateurs / zak / _Work / LearnBuildScripts / Learnant /
Helloworld / build / classes
pot:
[MKDIR] Créé Dir: / Users / Zak / _Work / LearnBuildScripts / Learnant / Helloworld / Build / Bin
[jar] Building Jar: / Users / Zak / _Work / LearnBuildScripts / Learnant / Helloworld / Build / Bin /
Bonjour le monde.pot
Réussir à réussir
Temps total: 6 secondes

Vous pouvez essayer le fichier de pot comme ceci:

$ java -cp build / bin / helloworld.jar helloworld
Bonjour le monde!

Nous avons défini le fichier JAR à placer dans le dossier Build / Bin. Les dossiers sont créés pendant la construction. La commande de bocal de fourmi appelle la cible de bocal dans la construction.xml.

Maven

Maven a été développé pour résoudre les problèmes rencontrés avec les scripts basés sur la fourmi. Il a gardé les fichiers XML mais a adopté une approche différente de l'organisation. En fourmi, les développeurs doivent créer toutes les tâches. Maven diminue la création de tâches en mettant en œuvre des normes plus fortes pour l'organisation du code. En conséquence, il est plus facile de démarrer sur des projets standard.

Il a également introduit des téléchargements de dépendances qui ont rendu le développement plus facile. Avant l'introduction de l'Ivy dans ANT, les utilisateurs ont dû gérer les dépendances localement. Maven a d'abord adopté la philosophie de gestion des dépendances.

Cependant, les normes strictes Mavens rendent difficile l'écriture de scripts de construction personnalisés. L'outil est facile à travailler aussi longtemps que le projet suit les normes strictes.

Avantages

• Téléchargements de dépendance automatique
• Toutes les dépendances sont automatiquement enregistrées dans le contrôle de la source dans le cadre des scripts Maven
• Standardise et simplifie le processus de construction
• S'intègre facilement aux systèmes IDE et CI / CD

Les inconvénients

• Pas flexible pour créer des workflows personnalisés
• Courbe d'apprentissage abrupte et le processus est difficile à comprendre pour les novices
• Qui prend du temps pour résoudre les problèmes de construction et les nouvelles intégrations de la bibliothèque
• Pas bon avec plusieurs versions de la même dépendance

Exemple de maven

Vous pouvez télécharger le dernier maven à partir d'ici. Vous pouvez vérifier l'installation comme ceci:

$ MVN - Version
Apache maven 3.5.2 (138EDD61FD100EC658BFA2D307C43B76940A5D7D; 2017-10-18T00: 58: 13-07: 00)
Maven Home: / Users / Zak / BuildTools / Maven / Apache-Maven-3.5.2
Version Java: 1.8.0_74, vendeur: Oracle Corporation
Home java: / bibliothèque / java / javavirtualmachines / jdk1.8.0_74.JDK / Contenu / Home / JRE
Par défaut par défaut: en_us, codage de plate-forme: UTF-8
Nom du système d'exploitation: "Mac OS X", version: "10.11.6 ", Arch:" x86_64 ", famille:" Mac "

Créez un dossier Helloworld et générez un projet avec la commande suivante:

$ archétype MVN: générer -dgroupId = com.Nom de l'entreprise.Helloworld -DartifActid = Helloworld
-DarCheTypeArtingIfActid = maven-archetype-quickstart -dinteractiveMode = false

Il devrait créer la structure du dossier et générer la sortie qui ressemble à ceci:

[Info] SCANNING POUR PROJETS…
[INFO]
[INFO] ------------------------------------------------------------------------
[Info] Building Maven Stub Project (pas de Pom) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[Info] >>> maven-architype-plugin: 3.0.0: générer (par défaut-Cli)> générer des sources
@ standalone-pom >>>
[INFO]
[INFO] <<< maven-archetype-plugin:3.0.0:generate (default-cli) < generate-sources
@ autonome-pom <<<
[INFO]
[INFO]
[Info] --- Maven-Archetype-Plugin: 3.0.0: générer (par défaut-Cli) @ standalone-pom ---
[Info] Génération du projet en mode lot
[INFO] ----------------------------------------------------------------------------
[Info] en utilisant les paramètres suivants pour créer un projet à partir d'ancien (1.x) Archétype:
Maven-Archetype-Quickstart: 1.0
[INFO] ----------------------------------------------------------------------------
[Info] Paramètre: basé, valeur: / utilisateurs / zak / _Work / LearnBuildScripts / Learnmaven
[Info] Paramètre: package, valeur: com.Nom de l'entreprise.Bonjour le monde
[Info] Paramètre: groupId, valeur: com.Nom de l'entreprise.Bonjour le monde
[Info] Paramètre: artefactive, valeur: helloworld
[Info] Paramètre: packageName, valeur: com.Nom de l'entreprise.Bonjour le monde
[Info] Paramètre: version, valeur: 1.0-napshot
[Info] Projet créé à partir d'ancien (1.x) Archétype dans dir: / utilisateurs / zak / _work /
Apprendre les produitscript / Learnmaven / Helloworld
[INFO] ------------------------------------------------------------------------
[Info] Créer un succès
[INFO] ------------------------------------------------------------------------
[Info] Temps total: 8.602 s
[Info] terminé au: 2018-01-27T00: 05: 37-08: 00
[Info] Mémoire finale: 15m / 152m
[INFO] ------------------------------------------------------------------------

La structure du dossier devrait ressembler à ceci:

Bonjour le monde
| - Pom.xml
'- SRC
| - Main
| '- Java
| '- com
| '-- Nom de l'entreprise
| '-- Bonjour le monde
| '- App.Java
'-- test
'- Java
'- com
'-- Nom de l'entreprise
'-- Bonjour le monde
'- Apptest.Java

Le pom.XML contient les configurations de construction. À l'intérieur du pom.XML Le code ressemble à ceci:

XSI: ScheMalation = "http: // maven.apache.org / pom / 4.0.0 http: // maven.apache.org / maven-v4_0
_0.xsd ">
4.0.0
com.Nom de l'entreprise.Bonjour le monde
Bonjour le monde
pot
1.0-napshot
Bonjour le monde
http: // maven.apache.org


junite
junite
3.8.1
test

Vous pouvez générer le fichier JAR à l'aide de la commande suivante:

Package MVN $
[Info] SCANNING POUR PROJETS…
[INFO]
[INFO] ------------------------------------------------------------------------
[Info] Building Helloworld 1.0-napshot
[INFO] ------------------------------------------------------------------------
[INFO]
[Info] --- Maven-Resources-Plugin: 2.6: Ressources (resournes par défaut) @ helloworld ---
[AVERTISSEMENT] Utilisation du codage de la plate-forme (UTF-8 En fait) pour copier les ressources filtrées, i.e.
La construction est dépendante de la plate-forme!
[Info] Sautez les ressources non existantes / utilisateurs / zak / _Work / LearnBuildScripts / Learnmaven /
helloworld / src / main / ressources
[INFO]
[Info] --- Maven-Compiler-Plugin: 3.1: compiler (par défaut-compile) @ helloworld ---
[Info] Modifications détectées - Recompilation du module!
[AVERTISSEMENT] Le codage des fichiers n'a pas été défini, en utilisant le codage de plate-forme UTF-8, I.e. build est
en fonction de la plate-forme!
[Info] Compilation 1 fichier source à / utilisateurs / zak / _Work / LearnBuildScripts / Learnmaven /
helloworld / cible / classes
[INFO]
[Info] --- Maven-Resources-Plugin: 2.6: TestResources (par défaut-testResources) @
Bonjour le monde ---
[AVERTISSEMENT] Utilisation du codage de la plate-forme (UTF-8 En fait) pour copier les ressources filtrées, i.e.
La construction est dépendante de la plate-forme!
[Info] Sautez les ressources non existantes / utilisateurs / zak / _Work / LearnBuildScripts / Learnmaven /
HELLOWORLD / SRC / TEST / RESSOURCES
[INFO]
[Info] --- Maven-Compiler-Plugin: 3.1: TestCompile (par défaut-TestCompile) @ Helloworld ---
[Info] Modifications détectées - Recompilation du module!
[AVERTISSEMENT] Le codage des fichiers n'a pas été défini, en utilisant le codage de plate-forme UTF-8, I.e. build est
en fonction de la plate-forme!
[Info] Compilation 1 fichier source à / utilisateurs / zak / _Work / LearnBuildScripts / Learnmaven
/ Helloworld / Target / Test Classes
[INFO]
[Info] --- Maven-Surefire-Plugin: 2.12.4: Test (test par défaut) @ helloworld ---
[Info] répertoire de rapport SureFire: / utilisateurs / zak / _Work / LearnBuildScripts / Learnmaven
/ Helloworld / Target /
Surefire-Reports
-------------------------------------------------------
T e s t s
-------------------------------------------------------
Running Com.Nom de l'entreprise.Bonjour le monde.Apptest
Tests Exécution: 1, échecs: 0, erreurs: 0, sauté: 0, temps écoulé: 0.014 sec
Résultats :
Tests Exécutez: 1, échecs: 0, erreurs: 0, sauté: 0
[INFO]
[Info] --- Maven-Jar-Plugin: 2.4: Jar (par défaut-jar) @ helloworld ---
[Info] Building Jar: / Users / Zak / _Work / LearnBuildScripts / Learnmaven / Helloworld / Target /
helloworld-1.0-napshot.pot
[INFO] ------------------------------------------------------------------------
[Info] Créer un succès
[INFO] ------------------------------------------------------------------------
[Info] Temps total: 5.624 s
[Info] terminé au: 2018-01-27T00: 11: 10-08: 00
[Info] Mémoire finale: 16m / 114m
[INFO] ------------------------------------------------------------------------

Vous pouvez exécuter le fichier JAR comme ceci:

$ Java -CP Target / Helloworld-1.0-napshot.jar com.Nom de l'entreprise.Bonjour le monde.Appliquer
Bonjour le monde!

Le fichier JAR est placé dans le dossier cible.

Grade

Gradle combine la puissance de la fourmi et du maven. La première version de Gradle est sortie en 2012. Il a connu une adoption rapide. Google l'utilise actuellement pour Android OS.

Au lieu de XML, Gradle utilise la langue groovy. En conséquence, les scripts de construction à Gradle sont plus faciles à écrire et à lire. Il utilisait initialement Ivy pour la gestion des dépendances, mais il utilise maintenant son propre moteur de dépendance.

Avantages

• Fournit la normalisation tout en restant flexible
• Scripts de construction facile à lire et à écrire
• Mieux à gérer plusieurs versions de dépendances
• Capable de gérer plusieurs langages et technologies de programmation
• Communauté active aidant à développer l'outil
• Gradle DSL (langage spécifique au domaine) rend la structure de configuration simple
• Gradle fournit des améliorations des performances en utilisant progressivement, Build Cache et le gradle Daemon

Les inconvénients

• L'intégration IDE pas aussi bonne que Maven

Gradle Exemple

Vous pouvez installer Gradle à partir d'ici. Une fois que vous avez installé Gradle sur votre chemin, vous pouvez le vérifier par:

$ gradle --version
------------------------------------------------------------
Gradle 4.5
------------------------------------------------------------
Temps de construction: 2018-01-24 17:04:52 UTC
Révision: 77d0ec90636f43669dc794ca17ef80dd65457bec
Groovy: 2.4.12
Ant: Apache Ant (TM) Version 1.9.9 compilé le 2 février 2017
JVM: 1.8.0_74 (Oracle Corporation 25.74-b02)
OS: Mac OS X 10.11.6 x86_64

Ensuite, créez la structure du répertoire suivant:

Bonjour le monde
| - construire.Grade
'- SRC
| - Main
'- Java
'-- Bonjour le monde
'-- Bonjour le monde.Java

Pour le Helloworld.Java a mis le code de l'exemple de fourmi. Et pour la construction.Gradle a mis le code suivant:

Appliquer le plugin: 'Java'
version = '1.0 '
Référentiels
mavencentral ()

dépendances
Groupe TestCompile: «Junit», nom: «Junit», version: «4.12 '

Vous pouvez utiliser la commande «Gradle Tasks-tout» pour consulter toutes les commandes disponibles. Gradle ramasse automatiquement les plugins que vous spécifiez dans la construction.Fichier Gradle et vous montre les tâches supplémentaires disponibles en raison des plugins.

Vous pouvez obtenir la construction en fonctionnant:

$ gradle
Créer un succès dans 1
2 tâches exploitables: 2 exécutés

Vous pouvez exécuter votre pot comme ceci:

$ java -cp build / libs / helloworld-1.0.jar helloworld
Bonjour le monde!

Le fichier JAR est placé dans le dossier Build / Libs.

Conclusion

Parmi les outils de construction, la fourmi peut être utile pour les petits projets tandis que Maven est meilleur pour s'assurer que tous les développeurs suivent les mêmes règles. Gradle est le dernier outil qui offre le plus de flexibilité.

Les références:

• http: // ant.apache.org /
• http: // ant.apache.org / ivy /
• https: // maven.apache.org /
• https: // gradle.org /
• http: // makble.com / gradle-junit-helloworld-exemple
• https: // exemples.javacodegeeks.com / core-java / gradle / gradle-hello-world-tutorial /
• https: // gradle.org / maven-vs-gradle /
• https: // maven.apache.org / guides / démarrage / maven-in-cinq minutes.html
• https: // stackOverflow.com / questions / 20755437 / java-build-tools-ant-vs-maven
• https: // Technology Conversations.com / 2014/06/18 / build-tools /
• https: // www.quora.com / What-the-the-Pros-and-Cons-of-Maven-Versus-Ant-As-Building-Tools-for-Java