Durante o desenvolvimento de software, os desenvolvedores precisam reconstruir o mesmo código repetidamente. Eles freqüentemente tentam usar scripts 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 de construção predominantes são:
- Apache Ant com Hera
- Maven
- Gradle
Vamos investigar as ferramentas para saber 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ências que se integra facilmente ao 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 a partir de 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:
$ formiga-versãoApache Ant(TM)versão 1.10.1 compilada em fevereiro2 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 o arquivo helloworld.java com o código:
/ **************************Imprime 'Hello World!'
*************************** /
público classeOlá Mundo{
público estático vazioa Principal( Fragmento []args) {
Sistema .Fora.println('Olá Mundo!');
}
}
Agora, na pasta helloworld, crie um arquivo build.xml com o seguinte código:
>
>
>
>
>
>
E na mesma pasta helloworld, crie o arquivo ivy.xml com o seguinte código:
>
>
A estrutura do diretório deve ser semelhante a esta:
Olá Mundo| - build.xml
| - ivy.xml
`- src
`- helloworld.java
Agora você pode executar a compilação com o comando:
$formigajarraUma construção bem-sucedida deve fornecer uma saída como esta:
jarra de formiga de $Buildfile: /Users/zak/_work/LearnBuildScripts/LearnANT/helloworld/build.xml
resolver:
[ivy: retrieve] :: Apache Ivy 2.4.0 - 20141213170938 :: http://ant.apache.org/ivy/ ::
[ivy: retrieve] :: loading settings :: url = jar: file: / Users / zak / BuildTools / ANT / apache
-ant-1.10.1 / lib / ivy-2.4.0.jar! /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: retrieve] encontrado junit # junit; 4.12 em público
[ivy: retrieve] encontrado org.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 build.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 /
helloworld.jar
CONSTRUIR COM SUCESSO
Tempo total: 6 segundos
Você pode experimentar o arquivo jar assim:
$ java -cp build / bin / helloworld.jarraOlá MundoOlá 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 no build.xml.
Maven
O Maven foi desenvolvido para resolver os problemas enfrentados com scripts baseados no 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 as 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 em aqui . Você pode verificar a instalação assim:
$ mvn --versionApache 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:
Arquétipo de $ mvn: gerar -DgroupId = com.Nome da empresa.Olá Mundo-DartifactId = helloworld-DarchetypeArtifactId = maven-archetype-quickstart -DinteractiveMode =falso
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] >>> maven-archetype-plugin: 3.0.0: generate (default-cli)> generate-sources
@ 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: generate (default-cli) @ standalone-pom ---
[INFO] Gerando projeto no modo Batch
[INFO] ----------------------------------------------- -----------------------------
[INFO] Usando os seguintes parâmetros para criar projeto a partir do antigo (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.companyname.helloworld
[INFO] Parâmetro: groupId, Valor: com.companyname.helloworld
[INFO] Parâmetro: artifactId, Valor: helloworld
[INFO] Parâmetro: packageName, Value: com.companyname.helloworld
[INFO] Parâmetro: versão, Valor: 1.0-SNAPSHOT
[INFO] projeto criado a partir do antigo (1.x) arquétipo em dir: / Users / 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:
Olá Mundo|- pom.xml
``- src
|-- a Principal
| ``-Java
| ``-- com
| ``-- Nome da empresa
| ``-- Olá Mundo
| ``- App.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 este:
XMLSchema-instance '
xsi: schemaLocation='http://maven.apache.org/POM/4.0.0 http://maven.apache.org/maven-v4_0
_0.xsd '>
>
>
>
Você pode gerar o arquivo jar usando o seguinte comando:
pacote $ mvn[INFO] Procurando projetos ...
[INFO]
[INFO] ----------------------------------------------- -------------------------
[INFO] Construindo helloworld 1.0-SNAPSHOT
[INFO] ----------------------------------------------- -------------------------
[INFO]
[INFO] --- maven-resources-plugin: 2.6: resources (default-resources) @ helloworld ---
[AVISO] Usando codificação de plataforma (UTF-8 na verdade) para copiar recursos filtrados, ou seja,
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: compile (default-compile) @ 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, ou seja, a compilação é
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, ou seja,
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] 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, ou seja, a compilação é
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
-------------------------------------------------- -----
Executando com.companyname.helloworld.AppTest
Testes executados: 1, Falhas: 0, Erros: 0, Ignorados: 0, Tempo decorrido: 0,014 seg
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-SNAPSHOT.jar
[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.jarracom.Nome da empresa.Olá Mundo.AplicativoOlá 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. Ele teve uma adoção rápida. Atualmente, o Google o está usando para o sistema operacional Android.
Em vez de XML, o Gradle usa a linguagem Groovy. Como resultado, os scripts de compilação no Gradle são mais fáceis de escrever e ler. Inicialmente, ele estava usando o Ivy para gerenciamento de dependências, 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 de aqui . Depois de configurar o Gradle em seu caminho, você pode verificá-lo:
$ gradle--versão-------------------------------------------------- ----------
Gradle4,5
-------------------------------------------------- ----------
Tempo de construção:2018-01-24 17: 04:52UTC
Revisão: 77d0ec90636f43669dc794ca17ef80dd65457bec
Groovy: 2.4.12
Formiga: Formiga Apache(TM)versão 1.9.9 compilada em fevereiro2 2017
JVM: 1.8.0_74(Oracle Corporation25,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
| -a Principal
``-Java
``-Olá Mundo
``-Olá Mundo.Java
Para o helloworld.java coloque o código do exemplo do Ant. E para build.gradle coloque o seguinte código:
aplicar plugin: 'Java'versão= '1.0'
repositórios{
mavenCentral()
}
dependências{
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 especificados no arquivo build.gradle e mostra as tarefas extras disponíveis devido aos plug-ins.
Você pode obter a compilação executando:
jar de $ gradleCONSTRUIR BEM-SUCEDIDO em 1s
2tarefas acionáveis:2executado
Você pode executar seu frasco assim:
$ java -cp build / libs / helloworld-1.0.jarraOlá MundoOlá 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. O 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://examples.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/What-are-the-pros-and-cons-of-Maven-versus-Ant-as-building-tools-for-Java