Por que usar Gradle em vez de Ant ou Maven? [fechadas]

https://stackoverflow.com/questions/1163173

18-09-2019
|

Pergunta

O que outra ferramenta de construção destinada a Java realmente me pegar?

Se você usar Gradle sobre outra ferramenta, por quê?

Solução

Não uso Gradle com raiva me (apenas um projeto brinquedo até agora) [ meios autor eles usaram Gradle apenas em um projeto de brinquedo, até agora, não que Gradle é um projeto de brinquedo - ver comentários] , mas eu diria que as razões se poderia considerar o uso seria por causa das frustrações de Ant e Maven.

Na minha experiência, Ant é muitas vezes somente gravação (sim, eu sei que é possível escrever lindamente modular, elegante construção s, mas o fato é que a maioria das pessoas não o fazem). Para quaisquer projetos não triviais se torna alucinante, e toma grande cuidado para assegurar que o complexo compilações são verdadeiramente portátil. Sua natureza imperativa pode levar a reprodução da configuração entre as compilações (embora macros podem ajudar aqui).

Maven leva a abordagem oposta e espera que você integrar completamente com o ciclo de vida do Maven. usuários Ant experientes encontrar este particularmente chocante como Maven remove muitas das liberdades que você tem em Ant. Por exemplo há um Sonatype blogue que enumera muitas das críticas Maven e suas respostas.

O mecanismo de plugins Maven permite configurações de compilação muito poderosas, e os meios modelo de herança, você pode definir um pequeno conjunto de POMs pais encapsulando suas configurações de compilação para toda a empresa e projectos individuais podem herdar essas configurações, deixando-os leves. configuração Maven é muito detalhado (embora Maven 3 promessas para resolver este), e se você quiser fazer alguma coisa que "não é o caminho Maven" você tem que escrever um plugin ou usar a integração Ant hacky. Nota Acontece que eu gosto de escrever Maven plugins, mas apreciam esse objeto vontade muitos para o esforço envolvido.

Gradle promete bater o ponto doce entre Ant e Maven. Ele usa Ivy 's abordagem para a resolução de dependências. Ela permite a convenção sobre configuração, mas também inclui tarefas Ant como cidadãos de primeira classe. Ele também permite que sabiamente você use repositórios Maven / Ivy existente.

Então, se você bateu e ficou preso com qualquer um dos pontos de dor Ant / Maven, é provavelmente vale a pena tentar Gradle para fora, embora na minha opinião, continua a ser visto, se você não seria apenas trocando os problemas conhecidos do os desconhecidos. A prova do pudim está em comê-lo embora assim que eu iria reservar seu julgamento até que o produto é um pouco mais maduro e outros eliminados quaisquer torções (que eles chamam de bleeding edge por uma razão). Eu ainda vou usá-lo em meus projetos de brinquedo, porém, é sempre bom estar ciente das opções.

Outras dicas

Gradle pode ser usado para muitas finalidades - é um canivete suíço muito melhor do que Ant -. Mas é especificamente voltado para a multi-projeto cria

Em primeiro lugar, Gradle é uma ferramenta de programação dependência que também significa que é uma ferramenta de programação. Com Gradle você pode executar qualquer tarefa aleatória na sua configuração e Gradle irá certificar-se dependecies todos declarados são devida e tempestivamente executado. Seu código pode ser transmitida através de muitos diretórios em qualquer tipo de layout (árvore, plana, disperso, ...).

Gradle tem duas fases distintas: avaliação e execução. Basicamente, durante a avaliação Gradle irá procurar e avaliar scripts de construção nos diretórios que é suposto para olhar. Durante a execução Gradle irá executar tarefas que foram carregados durante a tomada de avaliação em tarefas conta inter-dependências.

No topo destes programação dependência apresenta Gradle adiciona recursos de projeto e de dependência JAR por intergration com Apache Ivy. Como você sabe Ivy é uma ferramenta de gerenciamento de dependência muito mais poderoso e muito menos opinativo do que dizem Maven.

Gradle detecta dependências entre projectos e entre projetos e JARs. obras Gradle com repositórios Maven (download e upload) como o iBiblio um ou os seus próprios repositórios mas também suporta e outro tipo de infra-estrutura de repositório que você pode ter.

Em multi-projeto cria Gradle é ao mesmo tempo flexível e se adapta a estrutura e arquitetura da construção. Você não tem de se adaptar a sua estrutura ou arquitetura para a sua ferramenta de construção como seria necessário com Maven.

Gradle se esforça muito para não entrar em seu caminho, um esforço Maven quase nunca faz. Convenção é bom ainda assim é a flexibilidade. Gradle dá-lhe muitos mais recursos do que Maven faz, mas o mais importante em muitos casos Gradle irá oferecer-lhe um caminho de transição indolor longe do Maven.

Isto pode ser um pouco controverso, mas não Gradle não esconder o fato de que é uma linguagem de programação de pleno direito.

Ant + ant-contrib é essencialmente uma linguagem de programação completa turing que ninguém quer realmente para o programa na.

Maven tenta tomar o caminho inverso de tentar ser completamente declarativo e forçá-lo a escrever e compilar um plugin se você precisa de lógica. Ele também impõe um modelo de projeto que é completamente inflexível. combina Gradle a melhor de todas essas ferramentas:

Segue-convenção-over-configuração (ala Maven), mas apenas na medida em que você quer que ele
Permite-lhe escrever tarefas personalizadas flexíveis como em Ant
Ele fornece apoio a projectos multi-módulo que é superior a ambos Ant e Maven
Tem uma DSL que faz com que os 80% coisas fácil e os 20% coisas possíveis (ao contrário de outras ferramentas de compilação que fazem a 80% fácil, 10% possível e 10% efetivamente impossível).

Gradle é a ferramenta de construção mais configurável e flexível eu ainda tenho que usar. Ela exige algum investimento na frente para aprender o DSL e conceitos como configurações, mas se você precisa de um no-nonsense e completamente configurável ferramenta JVM construção é difícil de bater.

Gradle bem combina Ant e Maven, as vantagens das duas estruturas. Flexibilidade de Ant e convenção sobre configuração, gerenciamento de dependência e plugins do Maven.

Então, se você quer ter uma compilação Java padrão, como em Maven, mas tarefa de teste tem que fazer alguma etapa personalizada que poderia ser semelhante abaixo.

build.gradle:

apply plugin:'java'
task test{
  doFirst{
    ant.copy(toDir:'build/test-classes'){fileset dir:'src/test/extra-resources'}
  }
  doLast{
    ...
  }
}

No topo do que ele usa sintaxe Groovy que dá muito mais poder de expressão, em seguida, formiga / maven de xml.

É um super conjunto de Ant - você pode usar todas as tarefas Ant em Gradle com mais agradável, groovy-como sintaxe, isto é,

ant.copy(file:'a.txt', toDir:"xyz")

ant.with{
  delete "x.txt"
  mkdir "abc"
  copy file:"a.txt", toDir: "abc"
}

Nós usamos Gradle e escolheu sobre Maven e Ant. Ant nos deu total flexibilidade e Ivy dá uma melhor gestão da dependência do Maven, mas não há grande apoio para multi-projeto é construído. Você acaba fazendo um monte de codificação para suportar multi-projeto é construído. Também ter alguns build-a-convenção é agradável e faz construir scripts mais concisa. Com Maven, é preciso construir por convenção longe demais, e personalizar seu processo de construção torna-se um hack. Além disso, Maven promove cada projeto publicação de um artefato. Às vezes você tem um projeto dividido em subprojetos, mas você quer todos os subprojetos a ser construído e versionadas juntos. Não é realmente algo Maven é projetado para.

Com Gradle você pode ter a flexibilidade de Ant e construção por convenção de Maven. Por exemplo, é trivial para estender o ciclo de vida de construção convencional com a sua própria tarefa. E você não é obrigado a usar uma convenção, se você não quiser. Groovy é muito mais agradável ao código de XML. Em Gradle, você pode definir dependências entre projetos no sistema de arquivos local, sem a necessidade de publicar os artefatos para cada um para um repositório. Finalmente, Gradle usa Ivy, por isso tem uma excelente gestão de dependência. A única desvantagem real para mim até agora é a falta de integração madura Eclipse, mas as opções para Maven não são realmente muito melhor.

Este não é minha resposta, mas ele definitivamente ressoa comigo. É de ThoughtWorks' tecnologia de radar de outubro 2012 :

Duas coisas fizeram com que a fadiga com ferramentas de construção baseados em XML como Ant e Maven: muitas chaves pontudos irritados ea aspereza do plug-in arquiteturas. Embora as questões de sintaxe podem ser tratadas através de geração, plug-in arquitecturas limitar severamente a capacidade para construir ferramentas para crescer graciosamente como projetos se tornam mais complexas. Viemos a sentir que os plug-ins são o nível errado de abstração, e preferem ferramentas baseadas em idiomas como Gradle e Rake Em vez disso, porque eles oferecem abstrações mais refinado e mais flexibilidade a longo prazo.

Gradle colocar a parte de trás diversão em construção / montagem software. Eu costumava formiga para software construir toda a minha carreira e eu sempre considerado a parte real "buildit" do trabalho dev ser um mal necessário. Alguns meses atrás nossa empresa se cansou de não usar um repositório binário (aka verificando em frascos nas vcs) e me foi dada a tarefa de investigar isso. Iniciado com hera, uma vez que poderia ser aparafusado no topo da formiga, não teve muita sorte para conseguir meus artefatos construídos publicados como eu queria. Eu fui para Maven e cortou afastado com xml, trabalhou esplêndida para algumas libs auxiliares simples, mas eu tive problemas sérios tentando agrupar aplicações pronto para implantar. Incomodada muito tempo pesquisando plugins e ler fóruns e acabou de baixar trilhões de frascos de apoio para vários plugins que tive um tempo difícil de usar. Finalmente eu fui para Gradle (ficando bastante amargo, neste ponto, e irritado que "não deve ser tão difícil!")

Mas desde o primeiro dia o meu humor começou a melhorar. Eu estava chegando a algum lugar. Levei como duas horas para migrar o meu primeiro módulo formiga eo arquivo de construção foi basicamente nada. Facilmente montada uma tela. O grande "wow" foi: construção roteiros em XML, o quão estúpido é isso? o fato de que declarar uma dependência leva uma linha é muito atraente para mim -> você pode facilmente ver todas as dependências para um determinado projeto em uma página. A partir de então I foi em um rolo constante, para cada problema que eu enfrentei até agora não há uma solução simples e elegante. Eu acho que estas são as razões:

Groovy é muito intuitivo para desenvolvedores Java
documentação é grande a incrível
a flexibilidade é interminável

Agora eu passo meus dias tentando pensar em novos recursos para adicionar ao nosso processo de criação. Como doente é isso?

Também é muito mais fácil de gerir nativa constrói. Ant e Maven são efetivamente Java-only. Existem alguns plugins para Maven que tentar lidar com alguns projetos nativos, mas eles não fazem um trabalho eficaz. tarefas Ant pode ser escrito de que os projetos nativos de compilação, mas eles são muito complexo e difícil.

Nós fazemos Java com JNI e muitos outros bits nativas. Gradle simplificado our mess Ant consideravelmente. Quando começamos a introduzir a gestão de dependências para os projetos nativos era confuso. Temos Maven para fazê-lo, mas o código Gradle equivalente foi uma pequena fração do que era necessário em Maven, e as pessoas podiam lê-lo e compreendê-lo sem se tornar gurus Maven.

Eu concordo em parte com Ed Staub. Gradle definitivamente é mais poderosa em comparação com Maven e oferece mais flexibilidade a longo prazo.

Depois de realizar uma avaliação para se deslocar de Maven para Gradle, decidimos manter a maven-se para duas questões encontramos com Gradle (velocidade é mais lenta do que o perito, o procurador não estava funcionando).

Licenciado em: CC-BY-SA com atribuição

Não afiliado a StackOverflow