Escolhendo a ferramenta de construção certa: Ant vs Maven vs Gradle

Durante o desenvolvimento de software, os desenvolvedores precisam reconstruir o mesmo código repetidamente. Eles costumam tentar usar scripts bash ou outras linguagens de script para automatizar a tarefa. No entanto, existem ferramentas de compilação disponíveis que são mais apropriadas para a automação de compilação. As ferramentas de construção predominantes são:

Apache Ant com Ivy
Maven
Gradle

Vamos investigar as ferramentas para descobrir mais.

Apache Ant com Ivy

Apache Ant é uma ferramenta de linha de comando baseada em Java que usa arquivos XML para definir scripts de construção. É predominantemente usado para compilações Java, mas também pode ser usado para desenvolvimento C / C ++. As tarefas integradas fornecem maneiras de compilar, montar, testar e executar aplicativos de software. Os usuários também podem criar seus próprios "antlibs" para aprimorar a funcionalidade do Ant. Apache Ivy é uma ferramenta de gerenciamento de dependência que se integra facilmente com Ant para fornecer um ecossistema mais robusto. O desenvolvimento do Ant começou em 2000.

Prós

Melhor controle sobre o processo geral de construção
Flexível o suficiente para trabalhar com qualquer processo de trabalho

Contras

Arquivos de construção baseados em XML podem ficar grandes e impossíveis de manter
Muito tempo e recursos são necessários para manter os scripts de construção
A integração IDE é difícil de conseguir

Exemplo de Formiga com Ivy

Você pode instalar o Ant mais recente aqui. Você tem que baixar o zip, expandir e colocar a pasta bin no seu caminho. Você pode usar o seguinte comando para ver se o Ant está instalado corretamente:

$ ant -version
Apache Ant (TM) versão 1.10.1 compilado em 2 de fevereiro de 2017

Depois de instalar o Ant, você pode baixar o jar Ivy mais recente e colocá-lo na pasta lib dentro do diretório Ant.

Depois de instalar o Ant, crie as pastas helloworld e helloworld / src. Dentro da pasta src, coloque helloworld.arquivo java com o código:

/ **************************
Imprime "Hello World!"
*************************** /
public class helloworld
public static void main (String [] args)
Sistema.Fora.println ("Olá Mundo!");

Agora, na pasta helloworld, crie um build.arquivo xml com o seguinte código:

E na mesma pasta helloworld, crie a ivy.arquivo xml com o seguinte código:

A estrutura do diretório deve ser semelhante a esta:

Olá Mundo
| - construir.xml
| - ivy.xml
'- src
'-- Olá Mundo.Java

Agora você pode executar a compilação com o comando:

jarra de formiga de $

Uma construção bem-sucedida deve fornecer resultados como este:

jarra de formiga de $
Buildfile: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build.xml
resolver:
[ivy: recuperar] :: Apache Ivy 2.4.0 - 20141213170938 :: http: // ant.apache.org / ivy / ::
[ivy: retrieve] :: loading settings :: url = jar: file: / Users / zak / BuildTools / ANT / apache
-formiga-1.10.1 / lib / ivy-2.4.0.jarra!/ org / apache / ivy / core / settings / ivysettings.xml
[ivy: retrieve] :: resolvendo dependências :: org.apache # helloworld; [email protegido]
MacBook-Air.local
[ivy: recuperar] confs: [padrão]
[ivy: recuperar] junit # junit encontrado; 4.12 em público
[ivy: recuperar] org encontrada.hamcrest # hamcrest-core; 1.3 em público
[ivy: recuperar] :: relatório de resolução :: resolver 397ms :: artefatos dl 15ms
---------------------------------------------------------------------
| | módulos || artefatos |
| conf | número | pesquisa | dwnlded | despejado || número | dwnlded |
---------------------------------------------------------------------
| padrão | 2 | 0 | 0 | 0 || 4 0 |
---------------------------------------------------------------------
[ivy: retrieve] :: retrieving :: org.apache # helloworld
[ivy: recuperar] confs: [padrão]
[ivy: retrieve] 0 artefatos copiados, 4 já recuperados (0kB / 39ms)
compilar:
[mkdir] Diretório criado: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build /
Aulas
[javac] / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build.xml: 22: aviso:
'includeantruntime'não foi definido, padronizando para construir.sysclasspath = last; definido como falso
para construções repetíveis
[javac] Compilando 1 arquivo de origem para / Users / zak / _work / LearnBuildScripts / LearnANT /
helloworld / build / classes
jar:
[mkdir] Diretório criado: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build / bin
[jar] Construindo jar: / Users / zak / _work / LearnBuildScripts / LearnANT / helloworld / build / bin /
Olá Mundo.jarra
CONSTRUIR COM SUCESSO
Tempo total: 6 segundos

Você pode experimentar o arquivo jar assim:

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

Definimos o arquivo jar a ser colocado na pasta build / bin. As pastas são criadas durante a construção. O comando ant jar chama o alvo jar na construção.xml.

Maven

Maven foi desenvolvido para resolver os problemas enfrentados com scripts baseados em Ant. Ele manteve os arquivos XML, mas adotou uma abordagem diferente para a organização. No Ant, os desenvolvedores precisam criar todas as tarefas. O Maven diminui a criação de tarefas implementando padrões mais rígidos para organizar o código. Como resultado, é mais fácil começar em projetos padrão.

Ele também introduziu downloads de dependências que tornaram o desenvolvimento mais fácil. Antes da introdução do Ivy no Ant, os usuários tinham que gerenciar dependências localmente. A Maven adotou primeiro a filosofia de gerenciamento de dependências.

No entanto, os padrões estritos do Mavens tornam difícil escrever scripts de construção personalizados. A ferramenta é fácil de trabalhar, desde que o projeto siga os rígidos padrões.

Prós

Downloads de dependência automática
Todas as dependências são registradas automaticamente no controle de origem como parte dos scripts Maven
Padroniza e simplifica o processo de construção
Integra-se facilmente com IDEs e sistemas CI / CD

Contras

Não é flexível na criação de fluxos de trabalho personalizados
Curva de aprendizado íngreme e o processo é difícil para os novatos entenderem
Consome tempo para resolver problemas de construção e novas integrações de biblioteca
Não é bom com várias versões da mesma dependência

Exemplo Maven

Você pode baixar o Maven mais recente aqui. Você pode verificar a instalação assim:

$ mvn --version
Apache Maven 3.5.2 (138edd61fd100ec658bfa2d307c43b76940a5d7d; 2017-10-18T00: 58: 13-07: 00)
Página inicial do Maven: / Users / zak / BuildTools / Maven / apache-maven-3.5.2
Versão Java: 1.8.0_74, fornecedor: Oracle Corporation
Página inicial do Java: / Library / Java / JavaVirtualMachines / jdk1.8.0_74.jdk / Conteúdo / Home / jre
Localidade padrão: en_US, codificação de plataforma: UTF-8
Nome do sistema operacional: "mac os x", versão: "10.11.6 ", arco:" x86_64 ", família:" mac "

Crie uma pasta helloworld e gere um projeto com o seguinte comando:

$ mvn archetype: generate -DgroupId = com.nome da empresa.helloworld -DartifactId = helloworld
-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode = false

Ele deve criar a estrutura da pasta e gerar a saída parecida com esta:

[INFO] Procurando projetos…
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Construindo Projeto Stub Maven (Sem POM) 1
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] >>> plugin-arquétipo do maven: 3.0.0: gerar (default-cli)> gerar fontes
@ 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: gerar (default-cli) @ standalone-pom ---
[INFO] Gerando projeto no modo Batch
[INFO] ----------------------------------------------------------------------------
[INFO] Usando os seguintes parâmetros para a criação de projetos antigos (1.x) Arquétipo:
maven-archetype-quickstart: 1.0
[INFO] ----------------------------------------------------------------------------
[INFO] Parâmetro: basedir, Valor: / Users / zak / _work / LearnBuildScripts / LearnMaven
[INFO] Parâmetro: pacote, Valor: com.nome da empresa.Olá Mundo
[INFO] Parâmetro: groupId, Valor: com.nome da empresa.Olá Mundo
[INFO] Parâmetro: artifactId, Valor: helloworld
[INFO] Parâmetro: packageName, Value: com.nome da empresa.Olá Mundo
[INFO] Parâmetro: versão, Valor: 1.0-INSTANTÂNEO
[INFO] projeto criado a partir do Antigo (1.x) Arquétipo em dir: / Usuários / zak / _work /
LearnBuildScripts / LearnMaven / helloworld
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUIR SUCESSO
[INFO] ------------------------------------------------------------------------
[INFO] Tempo total: 8.602 s
[INFO] Concluído em: 27-01-2018T00: 05: 37-08: 00
[INFO] Memória final: 15M / 152M
[INFO] ------------------------------------------------------------------------

A estrutura da pasta deve ser semelhante a esta:

O pom.xml contém as configurações de construção. Dentro do pom.xml o código se parece com isto:

xsi: schemaLocation = "http: // maven.apache.org / POM / 4.0.0 http: // maven.apache.org / maven-v4_0
_0.xsd ">
4.0.0
com.nome da empresa.Olá Mundo
Olá Mundo
jarra
1.0-INSTANTÂNEO
Olá Mundo
http: // maven.apache.org

Junit
Junit
3.8.1
teste

Você pode gerar o arquivo jar usando o seguinte comando:

pacote $ mvn
[INFO] Procurando projetos…
[INFO]
[INFO] ------------------------------------------------------------------------
[INFO] Construindo o helloworld 1.0-INSTANTÂNEO
[INFO] ------------------------------------------------------------------------
[INFO]
[INFO] --- maven-resources-plugin: 2.6: recursos (recursos-padrão) @ helloworld ---
[AVISO] Usando codificação de plataforma (UTF-8 na verdade) para copiar recursos filtrados, i.e.
a construção depende da plataforma!
[INFO] ignorar resourceDirectory / Users / zak / _work / LearnBuildScripts / LearnMaven / não existente
helloworld / src / main / resources
[INFO]
[INFO] --- maven-compiler-plugin: 3.1: compilar (compilação padrão) @ helloworld ---
[INFO] Alterações detectadas - recompilar o módulo!
[AVISO] A codificação do arquivo não foi definida, usando a codificação da plataforma UTF-8, i.e. construir é
dependente da plataforma!
[INFO] Compilando 1 arquivo de origem para / Users / zak / _work / LearnBuildScripts / LearnMaven /
helloworld / target / classes
[INFO]
[INFO] --- maven-resources-plugin: 2.6: testResources (default-testResources) @
Olá Mundo ---
[AVISO] Usando codificação de plataforma (UTF-8 na verdade) para copiar recursos filtrados, i.e.
a construção depende da plataforma!
[INFO] ignorar resourceDirectory / Users / zak / _work / LearnBuildScripts / LearnMaven / não existente
helloworld / src / test / resources
[INFO]
[INFO] --- maven-compiler-plugin: 3.1: testCompile (default-testCompile) @ helloworld ---
[INFO] Mudanças detectadas - recompilar o módulo!
[AVISO] A codificação do arquivo não foi definida, usando a codificação da plataforma UTF-8, i.e. construir é
dependente da plataforma!
[INFO] Compilando 1 arquivo de origem para / Users / zak / _work / LearnBuildScripts / LearnMaven
/ helloworld / target / test-classes
[INFO]
[INFO] --- maven-surefire-plugin: 2.12.4: test (default-test) @ helloworld ---
[INFO] Diretório de relatórios Surefire: / Users / zak / _work / LearnBuildScripts / LearnMaven
/ helloworld / target /
relatórios infalíveis
-------------------------------------------------------
T E S T S
-------------------------------------------------------
Running com.nome da empresa.Olá Mundo.AppTest
Testes executados: 1, Falhas: 0, Erros: 0, Ignorados: 0, Tempo decorrido: 0.014 s
Resultados :
Testes executados: 1, Falhas: 0, Erros: 0, Ignorados: 0
[INFO]
[INFO] --- maven-jar-plugin: 2.4: jar (default-jar) @ helloworld ---
[INFO] Construindo jar: / Users / zak / _work / LearnBuildScripts / LearnMaven / helloworld / target /
helloworld-1.0-INSTANTÂNEO.jarra
[INFO] ------------------------------------------------------------------------
[INFO] CONSTRUIR SUCESSO
[INFO] ------------------------------------------------------------------------
[INFO] Tempo total: 5.624 s
[INFO] Concluído em: 27-01-2018T00: 11: 10-08: 00
[INFO] Memória final: 16M / 114M
[INFO] ------------------------------------------------------------------------

Você pode executar o arquivo jar assim:

$ java -cp target / helloworld-1.0-INSTANTÂNEO.jar com.nome da empresa.Olá Mundo.Aplicativo
Olá Mundo!

O arquivo jar é colocado na pasta de destino.

Gradle

Gradle combina o poder de Ant e Maven. A primeira versão do Gradle foi lançada em 2012. Teve uma rápida adoção. Atualmente, o Google está usando para o sistema operacional Android.

Em vez de XML, Gradle usa a linguagem Groovy. Como resultado, os scripts de compilação no Gradle são mais fáceis de escrever e ler. Ele estava inicialmente usando Ivy para gerenciamento de dependência, mas agora está usando seu próprio mecanismo de dependência.

Prós

Fornece padronização enquanto permanece flexível
Fácil de ler e escrever scripts de construção
Melhor em lidar com várias versões de dependências
Capaz de lidar com várias linguagens de programação e tecnologias
Comunidade ativa ajudando a desenvolver a ferramenta
Gradle DSL (Domain-Specific Language) torna a estrutura de configuração simples
O Gradle fornece melhorias de desempenho usando incrementalmente, cache de compilação e o Gradle Daemon

Contras

A integração IDE não é tão boa quanto o Maven

Exemplo de Gradle

Você pode instalar o Gradle a partir daqui. Depois de configurar o Gradle em seu caminho, você pode verificá-lo:

$ gradle --version
------------------------------------------------------------
Gradle 4.5
------------------------------------------------------------
Tempo de compilação: 24/01/2018 17:04:52 UTC
Revisão: 77d0ec90636f43669dc794ca17ef80dd65457bec
Groovy: 2.4.12
Ant: Apache Ant (TM) versão 1.9.9 compilado em 2 de fevereiro de 2017
JVM: 1.8.0_74 (Oracle Corporation 25.74-b02)
SO: Mac OS X 10.11.6 x86_64

Em seguida, crie a seguinte estrutura de diretório:

Olá Mundo
| - construir.gradle
'- src
| - principal
'- java
'-- Olá Mundo
'-- Olá Mundo.Java

Para o helloworld.java colocou o código do exemplo Ant. E para construir.gradle colocado no seguinte código:

aplicar plugin: 'java'
versão = '1.0 '
repositórios
mavenCentral ()

dependencies
Grupo testCompile: 'junit', nome: 'junit', versão: '4.12 '

Você pode usar o comando “gradle tasks -all” para ver todos os comandos disponíveis. O Gradle seleciona automaticamente os plug-ins que você especificar na compilação.arquivo gradle e mostra as tarefas extras disponíveis devido aos plug-ins.

Você pode obter a compilação executando:

jar de $ gradle
CONSTRUIR COM SUCESSO em 1s
2 tarefas acionáveis: 2 executadas

Você pode executar seu frasco assim:

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

O arquivo jar é colocado na pasta build / libs.

Conclusão

Entre as ferramentas de construção, o Ant pode ser útil para projetos menores, enquanto o Maven é melhor para garantir que todos os desenvolvedores sigam as mesmas regras. Gradle é a ferramenta mais recente que oferece maior flexibilidade.

Referências:

http: // ant.apache.org /
http: // ant.apache.org / ivy /
https: // maven.apache.org /
https: // gradle.org /
http: // makble.com / gradle-junit-helloworld-example
https: // exemplos.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 / Quais são os prós e contras do Maven-versus-Ant-as-building-tools-for-Java