Maven: 1.7. Comparando com Maven Ant
Paulo Sérgio da Silva Pacheco
Maven: The Complete Reference
Os autores deste livro não têm interesse na criação de uma rixa entre Apache Ant e Apache Maven, mas também estamos conscientes do fato de que a maioria das organizações tem que tomar uma decisão entre as duas soluções padrão: Apache Ant e Maven Apache. Nesta seção, comparar e contrastar as ferramentas.
Formiga se destaca no processo de construção, é um sistema de construção modelado após fazer com metas e dependências. Cada alvo consiste em um conjunto de instruções que são codificados em XML. Há uma cópia de tarefas e um javac tarefa, bem como um frasco de tarefa. Quando você usa o Ant, você fornecer Formiga com instruções específicas para compilar e empacotar sua saída. Veja o exemplo a seguir de um simples build.xml arquivo:
Um arquivo Ant build.xml simples.
<project name="my-project" default="dist" basedir=".">
<description>
exemplo simples arquivo build
</ Description>
<- Definir as propriedades globais para esta compilação ->
<property name="src" location="src/main/java"/>
<property name="build" location="target/classes"/>
<property name="dist" location="target"/>
<target name="init">
<- Criar o carimbo de tempo ->
<tstamp/>
<- Criar a estrutura de diretório de compilação usado por compilação ->
<mkdir dir="${build}"/>
</ Target>
<Nome target = "compilar" depende = "init"
description = "compilar o código fonte">
<- Compilar o código Java a partir de $ {src} em $ {} construir ->
<javac srcdir="${src}" destdir="${build}"/>
</ Target>
<Nome target = "dist" depende = "compilar"
description = "gerar a distribuição">
<- Criar o diretório de distribuição ->
<mkdir dir="${dist}/lib"/>
<- Coloque tudo em $ {} construir no {} DSTAMP arquivo jar MyProject-$ -.>
<jar jarfile="${dist}/lib/MyProject-${DSTAMP}.jar" basedir="${build}"/>
</ Target>
<Nome target = "limpo"
description = "limpar">
<- Excluir a $ {} construir e $ {dist} árvores de diretório ->
<delete dir="${build}"/>
<delete dir="${dist}"/>
</ Target>
</ Project>Neste exemplo Ant simples, você pode ver como você tem que dizer Ant exatamente o que fazer. Há uma meta de compilação que inclui o javac tarefa que compila a fonte no / main src / java o diretório para o destino / classes diretório.Você tem que dizer Ant exatamente onde sua fonte é, de onde você quer que o bytecode resultante para ser armazenada, e como empacotar tudo isso em um arquivo JAR. Embora existam alguns desenvolvimentos recentes que ajudam a tornar Ant menos processual, a experiência de um desenvolvedor com Formiga está na codificação de uma linguagem procedural escrito em XML.
Contraste o exemplo Ant anterior com um exemplo Maven. No Maven, para criar um arquivo JAR de alguma fonte Java, tudo que você precisa fazer é criar um simples pom.xml , coloque o seu código-fonte em $ {basedir} / src / main / java e execute mvn instalar a partir da linha de comando . O exemplo Maven pom.xml que atinge os mesmos resultados que o arquivo Ant simples listadas no Um arquivo Ant build.xml simples é mostrado na A pom.xml Maven Sample .
<project>
<modelVersion> 4.0.0 </ modelVersion>
<groupId> org.sonatype.mavenbook </ groupId>
<artifactId> my-project </ artifactId>
<versão> 1.0 </ version>
</ Project>Isso é tudo o que você precisa em seu pom.xml . Correndo mvn instalar na linha de comando irá processar recursos, compilar fonte, executar testes de unidade, criar um JAR, e instalar o JAR em um repositório local para reutilização em outros projetos. Sem a modificação, você pode executar mvn site e, em seguida, encontrar um index.html arquivo no alvo / área que contém links para JavaDoc e alguns relatos sobre o seu código-fonte.
Evidentemente, este é o projeto de exemplo mais simples possível, contendo nada mais do que um código-fonte e produzir um JAR simples. É um projeto que segue de perto as convenções Maven e não requer quaisquer dependências ou personalização. Se quiséssemos começar a personalizar o comportamento, a nossa pom.xml vai crescer em tamanho, e no maior de projetos que você pode ver coleções de POM Maven muito complexos, que contêm uma grande quantidade de personalização plugin e declarações de dependência. Mas, mesmo quando os arquivos POM do seu projeto tornar-se mais substancial, que possuem um tipo totalmente diferente de informação a partir do arquivo de construção de um projeto de tamanho similar usando Ant. POM Maven conter declarações: "Este é um projeto JAR", e "O código fonte está em src / main / java ". Arquivos de compilação Ant contêm instruções explícitas: "Este é projeto", "A fonte está em src / main / java "," javac Run contra este diretório "," Coloque os resultados no alvo / classes "," Criar um JAR do ... . ", etc Onde Formiga teve que ser explícito sobre o processo, havia algo de" built-in "para Maven que só sabia onde o código fonte foi e como ela deve ser processada.
As diferenças entre Ant e Maven neste exemplo são:
Apache Ant
- O Formiga não têm convenções formais, como uma estrutura de diretório do projeto comum ou comportamento padrão. Você tem que dizer Ant exatamente onde encontrar a fonte e onde colocar a saída. Convenções informais têm surgido ao longo do tempo, mas eles não foram codificadas no produto.
- Ant é processual. Você tem que dizer Ant exatamente o que fazer e quando fazê-lo. Você tem que dizer a ele para compilar, em seguida, copiar e depois comprimir.
- O Formiga não tem um ciclo de vida. Você tem que definir metas e dependências de meta. Você tem que anexar uma sequência de tarefas para cada meta manualmente.
Apache Maven
- Maven tem convenções. Ele sabe onde o seu código-fonte é porque você seguiu a convenção. Das Maven Compiler Plugin colocar o bytecode no alvo / aulas , e produz um arquivo JAR no alvo.
- Maven é declarativa. Tudo o que tinha a fazer era criar um pom.xml arquivo e colocar a sua fonte no diretório padrão. Maven cuidava do resto.
- Maven tem um ciclo de vida que foi chamado quando você executou
mvn instalar. Este comando disse Maven para executar uma série de fases do ciclo de vida sequenciais até atingir a fase de instalação do ciclo de vida.Como um efeito colateral dessa viagem através do ciclo de vida, Maven executou uma série de metas de plugin padrão que fez coisas como compilar e criar um JAR.
Maven foi construído com inteligência sobre as tarefas do projeto comum na forma de plugins Maven. Se você quisesse escrever e executar testes de unidade, tudo que você precisa fazer é escrever os testes, colocá-los em $ {basedir} / src / test / java , adicionar uma dependência teste de escopo de cada TestNG ou JUnit e executar mvn teste . Se você quisesse implantar uma aplicação Web e não um JAR, tudo que você precisa fazer é mudar o tipo de projeto a guerra e colocar o seu docroot em $ {basedir} / src / main / webapp . Claro, você pode fazer tudo isso com Ant, mas você vai estar escrevendo as instruções a partir do zero. Em Formiga, você primeiro tem que descobrir onde o arquivo JAR JUnit deve ser. Então você teria que criar um caminho de classe que inclui o arquivo JAR JUnit. Então você diria a Formiga onde deve olhar para o código fonte de teste, escreva uma meta que compila a fonte de teste para bytecode, e executar os testes de unidade com JUnit.
Sem suporte a tecnologias como antlibs e Ivy (mesmo com essas tecnologias de suporte), Formiga tem a sensação de ac 'build processual ustom. Um conjunto eficiente de Maven POMs em um projeto que adere às convenções assumidas do Maven tem surpreendentemente pouco XML em comparação com a alternativa Ant. Outro benefício do Maven é a dependência de plugins Maven amplamente compartilhados. Todo mundo usa o plugin infalível Maven para teste de unidade, e se alguém adiciona suporte para um novo framework de testes unitários, você pode ganhar novos recursos em sua própria compilação apenas incrementar a versão de um plugin Maven especial no POM do seu projeto.
A decisão de usar Maven ou Ant não é um binário, e Ant ainda tem um lugar em uma compilação complexa. Se a sua compilação atual contém algum processo altamente personalizado, ou se você já escreveu alguns scripts Ant para concluir um processo específico de uma maneira específica, que não pode ser adaptado para os padrões do Maven, você ainda pode usar esses scripts com Maven. Formiga é disponibilizado como um plugin do Maven núcleo. Plugins personalizados Maven pode ser implementado em Formiga, e projetos Maven pode ser configurado para executar scripts Ant dentro do ciclo de vida do projeto Maven.
Nome...: PAULO PACHECOE-Mail.: PauloSS...@gmail.com.brMSN....: PauloSS...@Hotmail.com
Yahoo..: PauloSSPacheco@yahoo.comFixo...: 085 3086 6769Celular: 085 8888 4498 OI085 9702 4498 TIM