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 geralmente tentam usar scripts de bash ou outras linguagens de script para automatizar a tarefa. No entanto, existem ferramentas de construção disponíveis que são mais apropriadas para a automação de construção. As ferramentas predominantes de construção 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 construções de java, mas também pode ser usado para o desenvolvimento de C/C ++. Tarefas internas 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 da formiga. Apache Ivy é uma ferramenta de gerenciamento de dependência que se integra facilmente à ANT para fornecer um ecossistema mais robusto. O desenvolvimento de 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 crescer grandes e inquente
• Muito tempo e recursos são necessários para manter os scripts de construção
• A integração do IDE é difícil de alcançar

Formiga com Ivy Exemplo

Você pode instalar a formiga mais recente daqui. Você precisa baixar o zip, expandir e colocar a pasta Bin em seu caminho. Você pode usar o seguinte comando para ver se a ANT está instalada corretamente:

$ ANT -versão
Apache Ant (TM) Versão 1.10.1 Compilado em 2 de fevereiro de 2017

Depois de instalar a formiga, você pode baixar o mais recente jarra de hera e colocá -lo na pasta Lib dentro do diretório de formigas.

Depois de instalar a formiga, crie pastas helloworld e helloworld/src. Dentro da pasta SRC, coloque Helloworld.arquivo java com o código:

/****************************
Imprime "Hello World!"
***************************/
classe pública helloworld
public static void main (string [] args)
Sistema.fora.println ("Hello World!");

Agora, na pasta Helloworld, crie uma construção.Arquivo XML com o seguinte código:

E na mesma pasta Helloworld, crie a hera.Arquivo XML com o seguinte código:

A estrutura do diretório deve ficar assim:

Olá Mundo
|- Construir.xml
|- Ivy.xml
'- Src
'-- Olá Mundo.Java

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

$ Ant Jar

Uma compilação bem -sucedida deve fornecer saída como esta:

$ Ant Jar
BuildFile:/Users/Zak/_work/LearnBuildScripts/LEDENDANT/HELLOWORLD/BUILD.xml
resolver:
[Ivy: recuperar] :: Apache Ivy 2.4.0 - 20141213170938 :: http: // Ant.apache.org/ Ivy/ ::
[Ivy: recuperar] :: Configurações de carregamento :: url = jar: arquivo:/users/zak/buildtools/Ant/apache
-Ant-1.10.1/lib/Ivy-2.4.0.jarra!/org/apache/Ivy/core/Settings/IVySettings.xml
[Ivy: recuperar] :: Resolvando dependências :: org.apache#helloworld; funcionando@zakirs-
MacBook-Air.local
[Ivy: recuperar] Confs: [padrão]
[Ivy: recuperar] Encontrado Junit#Junit; 4.12 em público
[Ivy: recuperar] Org encontrado.Hamcrest#hamcrest-core; 1.3 em público
[Ivy: recuperar] :: Relatório de Resolução :: Resolva 397ms :: Artifacts DL 15ms
---------------------------------------------------------------------
| | Módulos || artefatos |
| conf | número | Pesquisa | DWNLDED | EXTECIDO || Número | DWNLDED |
---------------------------------------------------------------------
| padrão | 2 | 0 | 0 | 0 || 4 | 0 |
---------------------------------------------------------------------
[Ivy: recuperar] :: recuperação :: org.Apache#helloworld
[Ivy: recuperar] Confs: [padrão]
[Ivy: recuperar] 0 artefatos copiados, 4 já recuperado (0kb/39ms)
compilar:
[mkdir] criou Dir:/users/zak/_work/LearnBuildscripts/LEDENDANT/HELLOWORLD/BURNHO/
Aulas
[Javac]/Usuários/Zak/_work/LearnBuildScripts/LEDENDANT/HELLOWORLD/BUILD.XML: 22: Aviso:
'IncluireArntuntime' não estava definido, inadimplente para construir.sysclasspath = last; definido como falso
Para construções repetíveis
[Javac] Compilando 1 arquivo de origem para/usuários/zak/_work/LearnBuildScripts/SELEDANT/
helloworld/build/classes
jarra:
[mkdir] Criado Dir:/Users/Zak/_work/LearnBuildScripts/Simandante/Helloworld/Build/Bin
[jar] jar de construção:/usuários/zak/_work/learnbuildscripts/SELEDANT/helloworld/build/bin/
Olá Mundo.jarra
Construir sucesso
Tempo total: 6 segundos

Você pode experimentar o arquivo JAR como este:

$ 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 jar de formiga chama o alvo da jar na construção.xml.

Maven

O MAVEN foi desenvolvido para resolver os problemas enfrentados com script baseado em formigas. Manteve os arquivos XML, mas adotou uma abordagem diferente da organização. Na formiga, os desenvolvedores precisam criar todas as tarefas. Maven diminui a criação de tarefas implementando padrões mais fortes para organizar o código. Como resultado, é mais fácil começar em projetos padrão.

Também introduziu downloads de dependência que facilitaram o desenvolvimento. Antes da introdução do Ivy em Ant, os usuários tinham que gerenciar dependências localmente. Maven adotou a filosofia de gerenciamento de dependência primeiro.

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

Prós

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

Contras

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

Exemplo maven

Você pode baixar o mais recente Maven daqui. Você pode verificar a instalação como esta:

$ mvn --version
Apache Maven 3.5.2 (138EDD61FD100EC658BFA2D307C43B76940A5D7D; 2017-10-18T00: 58: 13-07: 00)
Maven Home:/Usuários/Zak/BuildTools/Maven/Apache-Maven-3.5.2
Versão Java: 1.8.0_74, fornecedor: Oracle Corporation
Java Home:/Biblioteca/Java/JavavirtualMachines/JDK1.8.0_74.JDK/Conteúdo/Home/Jre
Local padrão: en_us, codificação da plataforma: UTF-8
Nome do OS: "Mac OS X", versão: "10.11.6 ", arch:" x86_64 ", família:" mac "

Crie uma pasta Helloworld e gerar um projeto com o seguinte comando:

$ mvn arquétipo: generate -dgroupid = com.nome da empresa.helloworld -Dartifactid = helloworld
-DarchetypeartifactId = maven-arcetype-quickstart -dinteractiveMode = false

Ele deve criar a estrutura da pasta e gerar a saída que se parece com a seguinte:

[Info] Digitalização para projetos…
[Info]
[Info] ------------------------------------------------------------------------
[INFO] Building Maven Stub Project (sem POM) 1
[Info] ------------------------------------------------------------------------
[Info]
[Info] >>> maven-arquetipo-plugin: 3.0.0: Gereate (padrão-cli)> gerar fontes
@ Standalone-Pom >>>
[Info]
[Info] <<< maven-archetype-plugin:3.0.0:generate (default-cli) < generate-sources
@ Standalone-Pom <<<
[Info]
[Info]
[Info] --- Maven-Arquetipo-Plugin: 3.0.0: Gereate (padrão-cli) @ Standalone-Pom ---
[Info] Gerando projeto no modo em lote
[Info] ----------------------------------------------------------------------------
[Info] Usando os seguintes parâmetros para a criação do projeto a partir de antigo (1.x) Arquétipo:
Maven-Arquetipo-Quickstart: 1.0
[Info] ----------------------------------------------------------------------------
[Info] parâmetro: baseado, valor:/usuários/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, valor: com.nome da empresa.Olá Mundo
[Info] Parâmetro: Versão, Valor: 1.0-SNAPSHOT
[Info] Projeto criado a partir de antigo (1.x) Arquétipo em dir:/usuários/zak/_work/
LearnBuildScripts/LearnMaven/Helloworld
[Info] ------------------------------------------------------------------------
[Info] Construa sucesso
[Info] ------------------------------------------------------------------------
[Informações] Tempo total: 8.602 s
[Info] terminado em: 2018-01-27T00: 05: 37-08: 00
[Info] Memória final: 15m/152m
[Info] ------------------------------------------------------------------------

A estrutura da pasta deve ficar assim:

Olá Mundo
|- pom.xml
'- Src
|- Main
| '- Java
| '- com
| '-- nome da empresa
| '-- Olá Mundo
| '-- Aplicativo.Java
'-- teste
'- Java
'- com
'-- nome da empresa
'-- Olá Mundo
'- AppTest.Java

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

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-SNAPSHOT
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] Digitalização para projetos…
[Info]
[Info] ------------------------------------------------------------------------
[Info] Construindo Helloworld 1.0-SNAPSHOT
[Info] ------------------------------------------------------------------------
[Info]
[Info] --- Maven-RESOURCES-PLUGIN: 2.6: Recursos (padrão-resistência) @ helloworld ---
[Aviso] Usando a codificação da plataforma (UTF-8 na verdade) para copiar recursos filtrados, i i.e.
Build depende da plataforma!
[Info] Skip Non ResourceDirectory/Users/Zak/_work/LearnBuildScripts/LearnMaven/
helloworld/src/main/recursos
[Info]
[Info] --- maven-compiler-plugin: 3.1: Compile (padrão-compile) @ helloworld ---
[Info] Alterações detectadas - recompilar o módulo!
[Aviso] A codificação de arquivos não foi definida, usando a codificação da plataforma UTF-8, i i.e. construção é
Plataforma dependente!
[Info] compilando 1 arquivo de origem para/usuários/zak/_work/LearnBuildScripts/LearnMaven/
helloworld/alvo/classes
[Info]
[Info] --- Maven-RESOURCES-PLUGIN: 2.6: TestResources (padrão-testresources) @
Olá Mundo ---
[Aviso] Usando a codificação da plataforma (UTF-8 na verdade) para copiar recursos filtrados, i i.e.
Build depende da plataforma!
[Info] Skip Non ResourceDirectory/Users/Zak/_work/LearnBuildScripts/LearnMaven/
helloworld/src/teste/recursos
[Info]
[Info] --- maven-compiler-plugin: 3.1: TestCompile (padrão padrão) @ helloworld ---
[Info] Alterações detectadas - recompilar o módulo!
[Aviso] A codificação de arquivos não foi definida, usando a codificação da plataforma UTF-8, i i.e. construção é
Plataforma dependente!
[Info] compilando 1 arquivo de origem para/usuários/zak/_work/LearnBuildscripts/LearnMaven
/Helloworld/Target/Test Classes
[Info]
[Info] --- maven-surefire-plugin: 2.12.4: teste (teste padrão) @ helloworld ---
[Info] Diretório de relatório Surefire:/Users/Zak/_work/LearnBuildscripts/LearnMaven
/helloworld/alvo/
Surefire-relatórios
-------------------------------------------------------
T e s t s
-------------------------------------------------------
Running com.nome da empresa.Olá Mundo.AppTest
Testes executados: 1, falhas: 0, erros: 0, ignorado: 0, Time decorrido: 0.014 Sec
Resultados :
Testes executados: 1, falhas: 0, erros: 0, ignorado: 0
[Info]
[Info] --- maven-jar-plugin: 2.4: jar (padrão-jar) @ helloworld ---
[Info] Jar de construção:/Usuários/Zak/_work/LearnBuildScripts/LearnMaven/Helloworld/Target/
Helloworld-1.0-SNAPSHOT.jarra
[Info] ------------------------------------------------------------------------
[Info] Construa sucesso
[Info] ------------------------------------------------------------------------
[Info] Tempo total: 5.624 s
[Info] terminado em: 2018-01-27T00: 11: 10-08: 00
[Info] Memória final: 16m/114m
[Info] ------------------------------------------------------------------------

Você pode executar o arquivo jar como este:

$ java -CP Target/Helloworld -1.0-SNAPSHOT.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. Viu uma adoção rápida. O Google está atualmente usando para Android SO.

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

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 e tecnologias de programação
• Comunidade ativa ajudando a desenvolver a ferramenta
• Gradle DSL (linguagem específica do domínio) torna a estrutura de configuração simples
• Gradle fornece melhorias de desempenho usando incrementalmente, construir cache e o daemon Gradle

Contras

• Integração IDE não tão boa quanto Maven

Exemplo gradle

Você pode instalar gradle a partir daqui. Depois de configurar o Gradle em seu caminho, você pode verificar::

$ gradle -versão
------------------------------------------------------------
Gradle 4.5
------------------------------------------------------------
Tempo de construção: 2018-01-24 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)
OS: Mac OS x 10.11.6 x86_64

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

Olá Mundo
|- Construir.Gradle
'- Src
|- Main
'- Java
'-- Olá Mundo
'-- Olá Mundo.Java

Para o Helloworld.Java colocou o código do exemplo da formigidade. E para construção.Gradle colocou o seguinte código:

Aplicar o plug -in: 'Java'
versão = '1.0 '
Repositórios
mavencentral ()

dependências
TestCompile Group: 'Junit', Nome: 'Junit', versão: '4.12 '

Você pode usar o comando “gradle tarefas -ath” para analisar todos os comandos disponíveis. Gradle pega automaticamente os plugins que você especifica na compilação.Gradle arquivo e mostra as tarefas extras disponíveis devido aos plugins.

Você pode obter a construção executando:

$ gradle jar
Construir 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, a 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 fornece a maior flexibilidade.

Referências:

• http: // formiga.apache.org/
• http: // formiga.apache.org/Ivy/
• https: // maven.apache.org/
• https: // gradle.org/
• http: //.com/gradle-Junit-Uloworld-Exemplo
• https: // exemplos.javacodegeeks.com/core-java/gradle/gradle-hello-mundo-tutorial/
• https: // gradle.org/maven-vs-gradle/
• https: // maven.apache.Org/Guides/Getting Started/Maven em cinco minutos.html
• https: // Stackoverflow.com/questões/20755437/java-build-tools-ont-vs-maven
• https: // TechnologyConversations.com/2014/06/18/Build-tools/
• https: // www.Quora.com/o que-é-os-pros e consumo-de-maven-versus-ant-as-construção-tools-for-Java