Pourquoi utiliser Gradle au lieu de Ant ou Maven?
Qu'est-ce qu'un autre outil de construction destiné à Java m'a vraiment?
Si vous utilisez Gradle sur un autre outil, pourquoi?
Je n'utilise pas Gradle dans la colère moi-même (juste un projet de jouet jusqu'à présent) [l'auteur signifie qu'ils n'ont utilisé Gradle que pour un projet de jouet jusqu'à présent, pas cela Gradle est un projet de jouet - voir les commentaires] , mais je dirais que les raisons pour lesquelles on envisagerait de l'utiliser seraient les frustrations de Ant et Maven.
D'après mon expérience, Ant est souvent en écriture seule (oui, je sais qu'il est possible d'écrire belle construction modulaire et élégante s, mais le fait est que la plupart des gens ne le font pas). Pour tous les projets non triviaux, cela devient hallucinant et veille à ce que les versions complexes soient réellement portables. Son caractère impératif peut conduire à une réplication de la configuration entre les versions (bien que les macros puissent aider ici).
Maven adopte l'approche inverse et attend de vous une intégration complète avec le cycle de vie de Maven. Les utilisateurs expérimentés de Ant trouvent cela particulièrement choquant, car Maven supprime nombre des libertés dont vous disposez dans Ant. Par exemple, il existe un Sonatype blog qui énumère de nombreuses critiques Maven et leurs réponses.
Le mécanisme de plug-in Maven permet des configurations de construction très puissantes. Le modèle d'héritage vous permet de définir un petit ensemble de POM parents encapsulant vos configurations de construction pour l'ensemble de l'entreprise. Les projets individuels peuvent hériter de ces configurations, tout en les allégeant. La configuration de Maven est très détaillée (bien que Maven 3 promette de résoudre ce problème), et si vous voulez faire quelque chose qui ne soit "pas à la manière de Maven", vous devez écrire un plugin ou utiliser l'intégration de hacky Ant. Notez que j'aime écrire des plugins Maven mais je sais que beaucoup s’opposeront à l’effort que cela implique.
Gradle promet de trouver le juste milieu entre Ant et Maven. Il utilise l'approche de Ivy pour la résolution de dépendance. Il permet la convention sur la configuration mais inclut également les tâches Ant en tant que citoyens de première classe. Il vous permet également d'utiliser judicieusement les référentiels Maven/Ivy existants.
Donc, si vous êtes coincé avec l'un des points douloureux de Ant/Maven, cela vaut probablement la peine d'essayer Gradle, bien que, à mon avis, il reste à voir si vous ne vous contentez pas d'échanger des problèmes connus contre des problèmes inconnus. La preuve du pudding est dans le manger cependant, donc je réserve mon jugement jusqu'à ce que le produit soit un peu plus mature et que d'autres aient résolu tous les problèmes (ils appellent ça saigner Edge pour une raison). Je l'utilise quand même dans mes projets de jouets, mais il est toujours bon de connaître les options.
Gradle peut être utilisé à de nombreuses fins - c'est un couteau suisse bien meilleur que Ant - mais il est spécifiquement conçu pour la construction de plusieurs projets.
Tout d'abord, Gradle est un outil de programmation de dépendances, ce qui signifie également que c'est un outil de programmation. Avec Gradle, vous pouvez exécuter n'importe quelle tâche aléatoire de votre configuration et Gradle s'assurera que toutes les dépendances déclarées sont exécutées correctement et dans les délais. Votre code peut être réparti sur de nombreux répertoires et dans n'importe quel type de présentation (arborescence, plate, dispersée, ...).
Gradle a deux phases distinctes: l'évaluation et l'exécution. Au cours de l’évaluation, Gradle recherchera et évaluera des scripts de construction dans les répertoires qu’il est supposé consulter. Pendant l'exécution, Gradle exécutera les tâches qui ont été chargées pendant l'évaluation, en tenant compte des interdépendances des tâches.
En plus de ces fonctionnalités de programmation de dépendance, Gradle ajoute des fonctionnalités de dépendance de projet et JAR en les intégrant à Apache Ivy. Comme vous le savez, Ivy est un outil de gestion de la dépendance beaucoup plus puissant et moins pondéré que Maven.
Gradle détecte les dépendances entre projets et entre projets et JAR. Gradle fonctionne avec les référentiels Maven (télécharger et téléverser), comme le référentiel iBiblio ou vos propres référentiels, mais également les supports et autres types d'infrastructure de référentiels que vous pourriez avoir.
Dans les constructions multi-projets, Gradle est à la fois adaptable et adaptable à la structure et à l'architecture de la construction. Vous n'êtes pas obligé d'adapter votre structure ou votre architecture à votre outil de génération, comme cela serait nécessaire avec Maven.
Gradle essaie très fort de ne pas vous gêner, un effort que Maven ne fait presque jamais. La convention est bonne mais la flexibilité aussi. Gradle vous offre beaucoup plus de fonctionnalités que Maven, mais le plus important dans de nombreux cas, Gradle vous offrira une voie de transition sans douleur loin de Maven.
Cela peut paraître un peu controversé, mais Gradle ne cache pas le fait qu’il s’agit d’un langage de programmation à part entière.
Ant + ant-contrib est essentiellement un langage de programmation complet dans lequel personne ne souhaite vraiment programmer.
Maven essaie d'adopter l'approche opposée d'essayer d'être complètement déclaratif et de vous forcer à écrire et à compiler un plugin si vous avez besoin de logique. Cela impose également un modèle de projet totalement inflexible. Gradle combine le meilleur de tous ces outils:
- Il suit la convention sur la configuration (ala Maven) mais seulement dans la mesure où vous le souhaitez
- Il vous permet d’écrire des tâches personnalisées flexibles comme dans Ant
- Il fournit un support de projet multi-module supérieur à Ant et Maven.
- Son DSL facilite les choses à 80% et rend les choses à 20% possibles (contrairement aux autres outils de construction qui rendent les choses à 80% faciles, 10% possibles et 10% effectivement impossibles).
Gradle est l'outil de compilation le plus configurable et le plus flexible que je n'ai pas encore utilisé. Il faut un investissement initial pour apprendre la DSL et des concepts tels que les configurations, mais si vous avez besoin d'un outil de génération de machine virtuelle virtuelle totalement configurable, il est difficile de le surpasser.
Gradle combine bien Ant et Maven, tirant le meilleur parti des deux frameworks. La flexibilité d'Ant et de la convention sur la configuration, la gestion des dépendances et les plugins de Maven.
Donc, si vous voulez avoir une construction Java standard, comme dans maven, mais que la tâche de test doit effectuer une étape personnalisée, celle-ci pourrait ressembler à celle ci-dessous.
build.gradle:
apply plugin:'Java'
task test{
doFirst{
ant.copy(toDir:'build/test-classes'){fileset dir:'src/test/extra-resources'}
}
doLast{
...
}
}
En plus de cela, il utilise une syntaxe groovy qui donne beaucoup plus de pouvoir d'expression que xml de ant/maven.
C'est un sur-ensemble de Ant - vous pouvez utiliser toutes les tâches Ant de manière graduelle avec une syntaxe plus agréable et plus groovy, c'est-à-dire.
ant.copy(file:'a.txt', toDir:"xyz")
ou
ant.with{
delete "x.txt"
mkdir "abc"
copy file:"a.txt", toDir: "abc"
}
Nous utilisons Gradle et l'avons choisi plutôt que Maven et Ant. Ant nous a donné une flexibilité totale et Ivy offre une meilleure gestion de la dépendance que Maven, mais il n’existe pas de support important pour la construction de plusieurs projets. Vous finissez par faire beaucoup de codage pour supporter des constructions multi-projets. Nice a aussi des constructions par convention, ce qui rend les scripts de construction plus concis. Avec Maven, la construction par convention est trop avancée et la personnalisation de votre processus de construction devient un hack. En outre, Maven fait la promotion de chaque projet publiant un artefact. Parfois, un projet est divisé en sous-projets mais vous souhaitez que tous les sous-projets soient construits et versionnés ensemble. Ce n'est pas vraiment quelque chose que Maven a conçu.
Avec Gradle, vous pouvez avoir la flexibilité de Ant et construire par convention de Maven. Par exemple, il est facile d’étendre le cycle de vie de la construction classique avec votre propre tâche. Et vous n'êtes pas obligé d'utiliser une convention si vous ne le souhaitez pas. Groovy est beaucoup plus agréable à coder que XML. Dans Gradle, vous pouvez définir des dépendances entre des projets sur le système de fichiers local sans qu'il soit nécessaire de publier des artefacts pour chacun dans un référentiel. Enfin, Gradle utilise Ivy, ce qui lui confère une excellente gestion des dépendances. Le seul véritable inconvénient pour moi à ce jour est le manque d'intégration Eclipse mature, mais les options pour Maven ne sont pas vraiment meilleures.
Ce n'est pas ma réponse, mais cela résonne définitivement avec moi. C'est de radar technologique de ThoughtWorks à partir d'octobre 2012 :
Les outils de construction basés sur XML, tels que Ant et Maven, sont fatigués: trop d'accolades pointues en colère et la grossièreté des architectures de plug-in. Bien que les problèmes de syntaxe puissent être résolus tout au long de la génération, les architectures de plug-in limitent considérablement la capacité des outils de construction à se développer normalement à mesure que les projets deviennent plus complexes. Nous en sommes venus à penser que les plug-ins représentent le mauvais niveau d'abstraction et préférons les outils basés sur le langage, tels que Gradle et Rake, car ils offrent des abstractions plus fines et plus de flexibilité à long terme.
Gradle réinvestit le plaisir dans la construction/l’assemblage de logiciels. J'ai utilisé ant pour construire des logiciels toute ma carrière et j'ai toujours considéré la partie "buildit" du développement comme un mal nécessaire. Il y a quelques mois, notre société en a eu assez de ne pas utiliser de dépôt binaire (c'est-à-dire d'inscrire des bocaux dans le vcs) et on m'a confié la tâche d'enquêter sur cette affaire. Commencé avec le lierre, car il pouvait être collé sur une fourmi, je n’ai pas eu beaucoup de chance de faire publier mes artefacts bâtis comme je le voulais. Je suis allé chercher maven et ai piraté xml, travaillé magnifiquement pour quelques librairies d’aide simples, mais j’ai eu de gros problèmes pour essayer de regrouper des applications prêtes à être déployées. Hassled a passé un certain temps à chercher des plugins et des forums de lecture sur Google et a fini par télécharger des milliards de jars de support pour divers plugins que j'ai eu du mal à utiliser. Finalement, je suis allé chercher mon diplôme (je suis devenu assez amer à ce stade-ci et j'ai été contrarié par le fait que "ça ne devrait pas être si difficile!")
Mais dès le premier jour, mon humeur a commencé à s'améliorer. J'allais quelque part. Cela m'a pris environ deux heures pour migrer mon premier module ant et le fichier de construction n’était fondamentalement rien. Facilement équipé d'un écran. Le grand "wow" était: build scripts in xml, comment est-ce stupide? le fait que déclarer une dépendance prenne UNE ligne me plaît beaucoup -> vous pouvez facilement voir toutes les dépendances d'un projet donné sur une seule page. À partir de ce moment-là, je suis sur une lancée constante. Pour chaque problème que j'ai rencontré jusqu'à présent, il existe une solution simple et élégante. Je pense que ce sont les raisons:
- groovy est très intuitif pour les développeurs Java
- la documentation est géniale pour génial
- la flexibilité est sans fin
Maintenant, je passe mes journées à essayer de concevoir de nouvelles fonctionnalités à ajouter à notre processus de construction. Comment est-ce malade?
Il est également beaucoup plus facile de gérer les versions natives. Ant et Maven sont en réalité uniquement Java. Il existe des plugins pour Maven qui essaient de gérer certains projets natifs, mais ils ne font pas un travail efficace. Des tâches Ant peuvent être écrites pour compiler des projets natifs, mais elles sont trop complexes et inconfortables.
Nous faisons Java avec JNI et beaucoup d'autres bits natifs. Gradle a considérablement simplifié nos dégâts causés par les fourmis. Lorsque nous avons commencé à introduire la gestion de la dépendance dans les projets natifs, c'était compliqué. Nous avons demandé à Maven de le faire, mais le code Gradle équivalent ne représentait qu'une infime fraction des besoins de Maven, et les utilisateurs pouvaient le lire et le comprendre sans devenir un gourou Maven.
Je suis en partie d'accord avec Ed Staub. Gradle est définitivement plus puissant que Maven et offre plus de flexibilité à long terme.
Après avoir effectué une évaluation pour passer de maven à grade, nous avons décidé de nous en tenir à deux problèmes rencontrés avec Gradle (la vitesse est plus lente que maven, le proxy ne fonctionnait pas).