Guia rápido de formigas

ANT significa Outra ferramenta bacana. É uma ferramenta de construção baseada em Java da Apache. Antes de entrar em detalhes do Apache Ant, vamos primeiro entender porque precisamos de uma ferramenta de construção em primeiro lugar.

Necessidade de uma ferramenta de construção

Em média, um desenvolvedor gasta uma quantidade substancial de tempo fazendo tarefas rotineiras, como construção e implantação, que incluem:

Compilando o código
Empacotando os binários
Implementar os binários no servidor de teste
Testando as mudanças
Copiar o código de um local para outro

Para automatizar e simplificar as tarefas acima, o Apache Ant é útil. É uma ferramenta de construção e implantação de sistema operacional que pode ser executada a partir da linha de comando.

História da Formiga Apache

Ant foi criado por James Duncan Davidson (o autor original do Tomcat).
Ele foi originalmente usado para construir o Tomcat e foi empacotado como parte da distribuição do Tomcat.
O Ant nasceu dos problemas e complexidades associados à ferramenta Apache Make.
O Ant foi promovido como um projeto independente no Apache no ano de 2000. A versão mais recente do Apache Ant em maio de 2014 é 1.9.4.

Características do Apache Ant

Ant é a ferramenta de desenvolvimento e implementação Java mais completa disponível.
Ant é uma plataforma neutra e pode lidar com propriedades específicas da plataforma, como separadores de arquivo.
O Ant pode ser usado para executar tarefas específicas da plataforma, como modificar o tempo de modificação de um arquivo usando o comando 'touch'.
Os scripts Ant são escritos usando XML simples. Se você já está familiarizado com XML, pode aprender Ant muito rapidamente.
O Ant é bom em automatizar tarefas repetitivas complicadas.
O Ant vem com uma grande lista de tarefas predefinidas.
Ant fornece uma interface para desenvolver tarefas customizadas.
O Ant pode ser facilmente chamado a partir da linha de comando e pode ser integrado a IDEs comerciais e gratuitos.

O Apache Ant Ant é distribuído sob a Apache Software License, uma licença de código aberto totalmente desenvolvida e certificada pela iniciativa de código aberto.

A versão mais recente do Apache Ant, incluindo seu código-fonte completo, arquivos de classe e documentação pode ser encontrada em http://ant.apache.org.

Instalando Apache Ant

Presume-se que você já tenha baixado e instalado o Java Development Kit (JDK) em seu computador. Caso contrário, siga as instruções aqui .

Certifique-se de que a variável de ambiente JAVA_HOME esteja configurada para a pasta onde seu JDK está instalado.
Baixe os binários de http://ant.apache.org
Descompacte o arquivo zip em um local conveniente c: \ pasta. usando Winzip, winRAR, 7-zip ou ferramentas semelhantes.
Crie uma nova variável de ambiente chamada ANT_HOME que aponta para a pasta de instalação do Ant, neste caso c:\apache-ant-1.8.2-bin pasta.
Anexe o caminho do arquivo em lote Apache Ant à variável de ambiente PATH. No nosso caso, seria oc:\apache-ant-1.8.2-bin\bin pasta.

Verificando a instalação do Apache Ant

Para verificar a instalação bem-sucedida do Apache Ant em seu computador, digite ant no prompt de comando.

Você deve ver uma saída semelhante a:

C:\>ant -version
Apache Ant(TM) version 1.8.2 compiled on December 20 2010

Se você não vir a saída acima, verifique se você seguiu as etapas de instalação corretamente.

Instalando Eclipse

Este tutorial também cobre a integração do Ant com o IDE Eclipse. Portanto, se você ainda não instalou o Eclipse, baixe e instale o Eclipse

Para instalar o Eclipse:

Baixe os binários mais recentes do Eclipse em www.eclipse.org
Descompacte os binários do Eclipse em um local conveniente, digamos c: \ pasta
Execute o Eclipse em c: \ eclipse \ eclipse.exe

Normalmente, o arquivo de construção do Ant, chamado build.xmldeve residir no diretório base do projeto. No entanto, não há restrição quanto ao nome do arquivo ou sua localização. Você está livre para usar outros nomes de arquivo ou salvar o arquivo de construção em algum outro local.

Para este exercício, crie um arquivo chamado build.xml em qualquer lugar do seu computador com o seguinte conteúdo:

<?xml version="1.0"?>
   <project name="Hello World Project" default="info">
   <target name="info">
      <echo>Hello World - Welcome to Apache Ant!</echo>
   </target>
</project>

Observe que não deve haver linha (s) em branco ou espaço (s) em branco antes da declaração xml. Se você permitir, a seguinte mensagem de erro ocorre durante a execução do ant build -

A correspondência do destino da instrução de processamento "[xX] [mM] [lL]" não é permitida. Todos os arquivos de construção requerem oproject elemento e pelo menos um target elemento.

O elemento XML project tem três atributos:

Atributos	Descrição
nome	O nome do projeto. (Opcional)
padrão	O destino padrão para o script de construção. Um projeto pode conter qualquer número de alvos. Este atributo especifica qual destino deve ser considerado o padrão. (Obrigatório)
Basedir	O diretório base (ou) a pasta raiz do projeto. (Opcional)

Um destino é uma coleção de tarefas que você deseja executar como uma unidade. Em nosso exemplo, temos um objetivo simples para fornecer uma mensagem informativa ao usuário.

Os destinos podem ter dependências de outros destinos. Por exemplo, umdeploy alvo pode ter uma dependência do package alvo, o package alvo pode ter uma dependência do compilealvo e assim por diante. Dependências são denotadas usando odependsatributo. Por exemplo:

<target name="deploy" depends="package">
  ....
</target>
<target name="package" depends="clean,compile">
  ....
</target>
<target name="clean" >
  ....
</target>
<target name="compile" >
  ....
</target>

O elemento de destino possui os seguintes atributos:

Atributos	Descrição
nome	O nome do alvo (obrigatório)
depende	Lista separada por vírgulas de todos os destinos dos quais esse destino depende. (Opcional)
descrição	Uma breve descrição do alvo. (opcional)
E se	Permite a execução de um alvo com base na veracidade de um atributo condicional. (opcional)
a menos que	Adiciona o destino à lista de dependências do Ponto de Extensão especificado. Um Ponto de Extensão é semelhante a um destino, mas não possui nenhuma tarefa. (Opcional)

o echoA tarefa no exemplo acima é uma tarefa trivial que imprime uma mensagem. Em nosso exemplo, ele imprime a mensagem Hello World .

Para executar o arquivo ant build, abra o prompt de comando e navegue até a pasta onde o build.xml reside e digite ant info. Você também pode digitarantem vez de. Ambos vão funcionar, porqueinfoé o destino padrão no arquivo de construção. Você deve ver a seguinte saída:

C:\>ant
Buildfile: C:\build.xml

info: [echo] Hello World - Welcome to Apache Ant!

BUILD SUCCESSFUL
Total time: 0 seconds

C:\>

Os arquivos de construção Ant são escritos em XML, o que não permite declarar variáveis como você faz em sua linguagem de programação favorita. No entanto, como você deve ter imaginado, seria útil se o Ant permitisse declarar variáveis como nome do projeto, diretório de origem do projeto, etc.

Ant usa o propertyelemento que permite especificar propriedades. Isso permite que as propriedades sejam alteradas de uma construção para outra ou de um ambiente para outro.

Por padrão, o Ant fornece as seguintes propriedades predefinidas que podem ser usadas no arquivo de construção:

Propriedades	Descrição
ant.file	A localização completa do arquivo de construção.
ant.version	A versão da instalação do Apache Ant.
Basedir	O basedir da construção, conforme especificado no basedir atributo do project elemento.
ant.java.version	A versão do JDK usada pelo Ant.
ant.project.name	O nome do projeto, conforme especificado no name Atributo do project elemento.
ant.project.default-target	O destino padrão do projeto atual.
ant.project.invoked-targets	Lista separada por vírgulas dos destinos que foram chamados no projeto atual.
ant.core.lib	A localização completa do arquivo jar Ant.
ant.home	O diretório inicial da instalação do Ant.
ant.library.dir	O diretório inicial para os arquivos da biblioteca Ant - normalmente a pasta ANT_HOME / lib.

O Ant também disponibiliza as propriedades do sistema (Exemplo: file.separator) para o arquivo de construção.

Além do acima, o usuário pode definir propriedades adicionais usando o propertyelemento. O exemplo a seguir mostra como definir uma propriedade chamadasitename:

<?xml version="1.0"?>
<project name="Hello World Project" default="info">
   <property name="sitename" value="www.tutorialspoint.com"/>
   <target name="info">
      <echo>Apache Ant version is ${ant.version} - You are 
         at ${sitename} </echo>
   </target>
</project>

A execução do Ant no arquivo de construção acima produz a seguinte saída:

C:\>ant
Buildfile: C:\build.xml

info: [echo] Apache Ant version is Apache Ant(TM) version 1.8.2  
      compiled on December 20 2010 - You are at www.tutorialspoint.com

BUILD SUCCESSFUL
Total time: 0 seconds
C:\>

Definir propriedades diretamente no arquivo de construção é bom, se você estiver trabalhando com um punhado de propriedades. No entanto, para um projeto grande, faz sentido armazenar as propriedades em um arquivo de propriedades separado.

Armazenar as propriedades em um arquivo separado oferece os seguintes benefícios:

Ele permite que você reutilize o mesmo arquivo de construção, com diferentes configurações de propriedade para diferentes ambientes de execução. Por exemplo, o arquivo de propriedades de construção pode ser mantido separadamente para ambientes DEV, TEST e PROD.
É útil quando você não sabe os valores de uma propriedade (em um ambiente específico) antecipadamente. Isso permite que você execute a construção em outros ambientes onde o valor da propriedade é conhecido.

Não existe uma regra rígida e rápida, mas normalmente o arquivo de propriedades é nomeado build.properties e é colocado ao lado do build.xmlArquivo. Você pode criar vários arquivos de propriedades de construção com base nos ambientes de implantação - comobuild.properties.dev e build.properties.test.

O conteúdo do arquivo de propriedades de construção é semelhante ao arquivo de propriedades java normal. Eles contêm uma propriedade por linha. Cada propriedade é representada por um nome e um par de valores. Os pares de nome e valor são separados por um sinal de igual (=). É altamente recomendável que as propriedades sejam anotadas com comentários adequados. Os comentários são listados usando o caractere hash (#).

O exemplo a seguir mostra um build.xml arquivo e seu associado build.properties Arquivo:

build.xml

<?xml version="1.0"?>
<project name="Hello World Project" default="info">
   <property file="build.properties"/>
      <target name="info">
         <echo>Apache Ant version is ${ant.version} - You are 
            at ${sitename} </echo>
      </target>
</project>

build.properties

# The Site Name
sitename=www.tutorialspoint.com
buildversion=3.3.2

No exemplo acima, sitenameé uma propriedade personalizada mapeada para o nome do site. Você pode declarar qualquer número de propriedades personalizadas desta maneira. Outra propriedade customizada listada no exemplo acima é obuildversion, que, neste caso, se refere à versão da construção.

Além do acima, Ant vem com uma série de propriedades de construção predefinidas, que estão listadas na seção anterior, mas são representadas abaixo novamente.

Propriedades	Descrição
ant.file	A localização completa do arquivo de construção.
ant.version	A versão da instalação do Apache Ant.
Basedir	O basedir da construção, conforme especificado no basedir atributo do project elemento.
ant.java.version	A versão do JDK usada pelo Ant.
ant.project.name	O nome do projeto, conforme especificado no name Atributo do project elemento.
ant.project.default-target	O destino padrão do projeto atual.
ant.project.invoked-targets	Lista separada por vírgulas dos destinos que foram chamados no projeto atual.
ant.core.lib	A localização completa do arquivo jar Ant.
ant.home	O diretório inicial da instalação do Ant.
ant.library.dir	O diretório inicial para os arquivos da biblioteca Ant - normalmente a pasta ANT_HOME / lib.

O exemplo apresentado neste capítulo usa o ant.version propriedade embutida.

Ant fornece vários tipos de dados predefinidos. Não confunda o termo "tipos de dados" com aqueles que estão disponíveis na linguagem de programação; em vez disso, considere-os como um conjunto de serviços já integrados ao produto.

Os seguintes tipos de dados são fornecidos pelo Apache Ant.

Conjunto de arquivos

Os tipos de dados do conjunto de arquivos representam uma coleção de arquivos. É usado como um filtro para incluir ou excluir arquivos que correspondem a um determinado padrão.

Por exemplo, consulte o código a seguir. Aqui, o atributo src aponta para a pasta de origem do projeto.

O conjunto de arquivos seleciona todos os arquivos .java na pasta de origem, exceto aqueles que contêm a palavra 'Stub'. O filtro de distinção entre maiúsculas e minúsculas é aplicado ao conjunto de arquivos, o que significa que um arquivo com o nome Samplestub.java não será excluído do conjunto de arquivos.

<fileset dir="${src}" casesensitive="yes">
   <include name="**/*.java"/>
   <exclude name="**/*Stub*"/>
</fileset>

Conjunto de padrões

Um conjunto de padrões é um padrão que permite filtrar arquivos ou pastas facilmente com base em certos padrões. Os padrões podem ser criados usando os seguintes metacaracteres:

? - Corresponde a apenas um caractere.
* - Corresponde a zero ou muitos caracteres.
** - Corresponde a zero ou muitos diretórios recursivamente.

O exemplo a seguir descreve o uso de um conjunto de padrões.

<patternset id="java.files.without.stubs">
   <include name="src/**/*.java"/>
   <exclude name="src/**/*Stub*"/>
</patternset>

O conjunto de padrões pode então ser reutilizado com um conjunto de arquivos da seguinte maneira:

<fileset dir="${src}" casesensitive="yes">
   <patternset refid="java.files.without.stubs"/>
</fileset>

Lista de arquivos

O tipo de dados filelist é semelhante ao conjunto de arquivos, exceto pelas seguintes diferenças:

filelist contém listas explicitamente nomeadas de arquivos e não suporta curingas.
tipo de dados filelist pode ser aplicado para arquivos existentes ou não existentes.

Vejamos o seguinte exemplo do tipo de dados filelist. Aqui, o atributowebapp.src.folder aponta para a pasta de origem do aplicativo da web do projeto.

<filelist id="config.files" dir="${webapp.src.folder}">
   <file name="applicationConfig.xml"/>
   <file name="faces-config.xml"/>
   <file name="web.xml"/>
   <file name="portlet.xml"/>
</filelist>

Conjunto de filtros

Usando um tipo de dados de conjunto de filtros junto com a tarefa de cópia, você pode substituir determinado texto em todos os arquivos que correspondem ao padrão com um valor de substituição.

Um exemplo comum é anexar o número da versão ao arquivo de notas de versão, conforme mostrado no código a seguir.

<copy todir="${output.dir}">
   <fileset dir="${releasenotes.dir}" includes="**/*.txt"/>
   <filterset>
      <filter token="VERSION" value="${current.version}"/>
   </filterset>
</copy>

Neste código:

O atributo output.dir aponta para a pasta de saída do projeto.
O atributo releasenotes.dir aponta para a pasta de notas de versão do projeto.
O atributo current.version aponta para a pasta da versão atual do projeto.
A tarefa de cópia, como o nome sugere, é usada para copiar arquivos de um local para outro.

Caminho

o pathtipo de dados é comumente usado para representar um caminho de classe. As entradas no caminho são separadas por ponto e vírgula ou dois pontos. No entanto, esses caracteres são substituídos no tempo de execução pelo caractere separador de caminho do sistema em execução.

O classpath é definido para a lista de arquivos jar e classes no projeto, conforme mostrado no exemplo abaixo.

<path id="build.classpath.jar">
   <pathelement path="${env.J2EE_HOME}/${j2ee.jar}"/>
   <fileset dir="lib">
      <include name="**/*.jar"/>
   </fileset>
</path>

Neste código:

O atributo env.J2EE_HOME aponta para a variável de ambiente J2EE_HOME.
O atributo j2ee.jar aponta para o nome do arquivo jar J2EE na pasta base J2EE.

Agora que aprendemos sobre os tipos de dados no Ant, é hora de colocar esse conhecimento em ação. Vamos construir um projeto neste capítulo. O objetivo deste capítulo é construir um arquivo Ant que compila as classes java e as coloca na pasta WEB-INF \ classes.

Considere a seguinte estrutura de projeto:

Os scripts do banco de dados são armazenados no db pasta.
O código-fonte java é armazenado no src pasta.
As imagens, js, META-INF, estilos (css) são armazenados no war pasta.
Os JSPs são armazenados no jsp pasta.
Os arquivos jar de terceiros são armazenados no lib pasta.
Os arquivos da classe java são armazenados no WEB-INF\classes pasta.

Este projeto forma o Hello World Aplicativo de fax para o restante deste tutorial.

C:\work\FaxWebApplication>tree
Folder PATH listing
Volume serial number is 00740061 EC1C:ADB1
C:.
+---db
+---src
.  +---faxapp
.  +---dao
.  +---entity
.  +---util
.  +---web
+---war
   +---images
   +---js
   +---META-INF
   +---styles
   +---WEB-INF
      +---classes
      +---jsp
      +---lib

Aqui está o build.xml necessário para este projeto. Vamos considerá-lo peça por peça.

<?xml version="1.0"?>
<project name="fax" basedir="." default="build">
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
      <pathelement path="${build.dir}"/>
   </path>

   <target name="build" description="Compile source tree java files">
      <mkdir dir="${build.dir}"/>
      <javac destdir="${build.dir}" source="1.5" target="1.5">
         <src path="${src.dir}"/>
         <classpath refid="master-classpath"/>
      </javac>
   </target>
 
   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
</project>

Primeiro, vamos declarar algumas propriedades para as pastas source, web e build.

<property name="src.dir" value="src"/>
<property name="web.dir" value="war"/>
<property name="build.dir" value="${web.dir}/WEB-INF/classes"/>

Neste exemplo:

src.dir refere-se à pasta de origem do projeto onde os arquivos de origem java podem ser encontrados.
web.dir refere-se à pasta de origem da web do projeto, onde você pode encontrar os JSPs, web.xml, css, javascript e outros arquivos relacionados à web
build.dir refere-se à pasta de saída da compilação do projeto.

Propriedades podem se referir a outras propriedades. Conforme mostrado no exemplo acima, obuild.dir propriedade faz uma referência ao web.dir propriedade.

Neste exemplo, o src.dir refere-se à pasta de origem do projeto.

O alvo padrão do nosso projeto é o compilealvo. Mas primeiro vamos olhar para oclean alvo.

O destino limpo, como o nome sugere, exclui os arquivos da pasta de construção.

<target name="clean" description="Clean output directories">
   <delete>
      <fileset dir="${build.dir}">
         <include name="**/*.class"/>
      </fileset>
   </delete>
</target>

O master-classpath contém as informações do classpath. Nesse caso, inclui as classes na pasta build e os arquivos jar na pasta lib.

<path id="master-classpath">
   <fileset dir="${web.dir}/WEB-INF/lib">
      <include name="*.jar"/>
   </fileset>
   <pathelement path="${build.dir}"/>
</path>

Finalmente, o destino de construção para construir os arquivos. Em primeiro lugar, criamos o diretório de construção, se ele não existir. Em seguida, executamos o comando javac (especificando jdk1.5 como nossa compilação de destino). Fornecemos a pasta de origem e o caminho de classe para a tarefa javac e solicitamos que solte os arquivos de classe na pasta de construção.

<target name="build" description="Compile main source tree java files">
   <mkdir dir="${build.dir}"/>
   <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
      deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
   </javac>
</target>

A execução de Ant neste arquivo compila os arquivos de origem java e coloca as classes na pasta de construção.

O seguinte resultado é o resultado da execução do arquivo Ant:

C:\>ant
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

Os arquivos são compilados e colocados no build.dir pasta.

A documentação é uma obrigação em qualquer projeto. A documentação desempenha um grande papel na manutenção de um projeto. Java torna a documentação mais fácil com o uso dejavadocferramenta. O Ant torna isso ainda mais fácil, gerando a documentação sob demanda.

Como você sabe, a ferramenta javadoc é altamente flexível e permite várias opções de configuração. O Ant expõe essas opções de configuração por meio da tarefa javadoc. Se você não estiver familiarizado com javadocs, sugerimos que comece com este Tutorial de documentação Java .

A seção a seguir lista as opções javadoc mais comumente usadas no Ant.

Atributos

A fonte pode ser especificada usando sourcepath, sourcepathref ou sourcefiles.

sourcepath é usado para apontar para a pasta dos arquivos de origem (por exemplo, pasta src).
sourcepathref é usado para referir-se a um caminho referenciado pelo atributo path (por exemplo, delegates.src.dir).
sourcefiles é usado quando você deseja especificar os arquivos individuais como uma lista separada por vírgulas.

O caminho de destino é especificado usando o destdir pasta (por exemplo, build.dir).

Você pode filtrar o javadoctarefa especificando os nomes dos pacotes a serem incluídos. Isso é conseguido usando opackagenames atributo, uma lista separada por vírgulas de arquivos de pacote.

Você pode filtrar o processo javadoc para mostrar apenas as classes e membros públicos, privados, de pacote ou protegidos. Isso é conseguido usando oprivate, public, package e protected atributos.

Você também pode dizer à tarefa javadoc para incluir as informações do autor e da versão usando os respectivos atributos.

Você também pode agrupar os pacotes usando o group atributo, para que seja fácil de navegar.

Juntando tudo

Vamos continuar nosso tema do Hello worldAplicativo de fax. Vamos adicionar um destino de documentação ao nosso projeto de aplicativo de fax.

Dada a seguir é um exemplo de tarefa javadoc usada em nosso projeto. Neste exemplo, especificamos o javadoc para usar osrc.dir como o diretório de origem, e doc como o alvo.

Também personalizamos o título da janela, o cabeçalho e as informações de rodapé que aparecem nas páginas de documentação do java.

Além disso, criamos três grupos:

um para as classes de utilitários em nossa pasta de origem,
um para as classes de interface do usuário e
um para as classes relacionadas ao banco de dados.

Você pode notar que o grupo de pacotes de dados possui dois pacotes - faxapp.entity e faxapp.dao.

<target name="generate-javadoc">
   <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
      destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[= Fax Application =]]></doctitle>
      <bottom>
         <![CDATA[Copyright © 2011. All Rights Reserved.]]>
      </bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/>
      <group title="data packages" 
         packages="faxapp.entity.*:faxapp.dao.*"/>
   </javadoc>
   <echo message="java doc has been generated!" />
</target>

Vamos executar a tarefa Ant do javadoc. Ele gera e coloca os arquivos de documentação java na pasta doc.

Quando o javadoc target é executado, ele produz o seguinte resultado:

C:\>ant generate-javadoc
Buildfile: C:\build.xml

java doc has been generated!

BUILD SUCCESSFUL
Total time: 10.63 second

Os arquivos de documentação java estão agora presentes no doc pasta.

Normalmente, os arquivos javadoc são gerados como parte dos destinos de liberação ou pacote.

A próxima etapa lógica após compilar seus arquivos de origem java, é construir o arquivo java, ou seja, o arquivo JAR. Criar arquivos JAR com Ant é muito fácil com ojartarefa. Os atributos comumente usados da tarefa jar são os seguintes:

Atributos	Descrição
Basedir	O diretório base para o arquivo JAR de saída. Por padrão, isso é definido como o diretório base do projeto.
comprimir	Aconselha o Ant a compactar o arquivo à medida que cria o arquivo JAR.
manter compressão	Enquanto o compress atributo é aplicável aos arquivos individuais, o keepcompression atributo faz a mesma coisa, mas se aplica a todo o arquivo.
destfile	O nome do arquivo JAR de saída.
duplicado	Aconselha o Ant sobre o que fazer quando arquivos duplicados são encontrados. Você pode adicionar, preservar ou reprovar os arquivos duplicados.
exclui	Aconselha o Ant a não incluir essas listas de arquivos separados por vírgulas no pacote.
excludesfile	O mesmo que acima, exceto que os arquivos de exclusão são especificados usando um padrão.
inclui	Inverso de exclui.
includefile	Inverso de excludesfile.
atualizar	Aconselha o Ant a sobrescrever arquivos no arquivo JAR já construído.

Continuando nosso Hello WorldProjeto de aplicativo de fax, vamos adicionar um novo destino para produzir os arquivos jar. Mas antes disso, vamos considerar a tarefa jar fornecida abaixo.

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class"
/>

Aqui o web.dirpropriedade aponta para o caminho dos arquivos de origem da web. No nosso caso, é aqui que o util.jar será colocado.

o build.dir propriedade neste exemplo aponta para a pasta de construção onde os arquivos de classe para o util.jar podem ser encontrados.

Neste exemplo, criamos um arquivo jar chamado util.jar usando as aulas do faxapp.util.*pacote. No entanto, estamos excluindo as classes que terminam com o nome Teste. O arquivo jar de saída será colocado na pasta lib do aplicativo da web.

Se quisermos tornar o util.jar um arquivo jar executável, precisamos adicionar o manifest com o Main-Class metaatributo.

Portanto, o exemplo acima será atualizado como:

<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class">
   <manifest>
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest>
</jar>

Para executar a tarefa jar, envolva-a dentro de um destino, mais comumente, o destino de construção ou pacote e execute-os.

<target name="build-jar">
<jar destfile="${web.dir}/lib/util.jar"
   basedir="${build.dir}/classes"
   includes="faxapp/util/**"
   excludes="**/Test.class">
   <manifest>
      <attribute name="Main-Class" value="com.tutorialspoint.util.FaxUtil"/>
   </manifest>
</jar>
</target>

A execução do Ant neste arquivo cria o arquivo util.jar para nós.

O seguinte resultado é o resultado da execução do arquivo Ant:

C:\>ant build-jar
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 1.3 seconds

O arquivo util.jar agora é colocado na pasta de saída.

Criar arquivos WAR com Ant é extremamente simples e muito semelhante à tarefa de criação de arquivos JAR. Afinal, o arquivo WAR, como o arquivo JAR, é apenas outro arquivo ZIP.

A tarefa WAR é uma extensão da tarefa JAR, mas tem algumas adições interessantes para manipular o que vai para a pasta WEB-INF / classes e gerar o arquivo web.xml. A tarefa WAR é útil para especificar um layout específico do arquivo WAR.

Como a tarefa WAR é uma extensão da tarefa JAR, todos os atributos da tarefa JAR se aplicam à tarefa WAR.

Atributos	Descrição
webxml	Caminho para o arquivo web.xml
lib	Um agrupamento para especificar o que vai para a pasta WEB-INF \ lib.
Aulas	Um agrupamento para especificar o que vai para a pasta WEB-INF \ classes.
metainf	Especifica as instruções para gerar o arquivo MANIFEST.MF.

Continuando nosso Hello WorldProjeto de aplicativo de fax, vamos adicionar um novo destino para produzir os arquivos jar. Mas antes disso, consideremos a tarefa de guerra. Considere o seguinte exemplo:

<war destfile="fax.war" webxml="${web.dir}/web.xml">
   <fileset dir="${web.dir}/WebContent">
      <include name="**/*.*"/>
   </fileset>
   <lib dir="thirdpartyjars">
      <exclude name="portlet.jar"/>
   </lib>
   <classes dir="${build.dir}/web"/>
</war>

Conforme os exemplos anteriores, o web.dir variável refere-se à pasta da web de origem, ou seja, a pasta que contém os arquivos JSP, css, javascript etc.

o build.dirvariável refere-se à pasta de saída - aqui é onde as classes para o pacote WAR podem ser encontradas. Normalmente, as classes serão agrupadas na pasta WEB-INF / classes do arquivo WAR.

Neste exemplo, estamos criando um arquivo war chamado fax.war. O arquivo WEB.XML é obtido na pasta de origem da web. Todos os arquivos da pasta 'WebContent' na web são copiados para o arquivo WAR.

A pasta WEB-INF / lib é preenchida com os arquivos jar da pasta thirdpartyjars. No entanto, estamos excluindo o portlet.jar, pois ele já está presente na pasta lib do servidor de aplicativos. Por fim, estamos copiando todas as classes da pasta web do diretório de construção e colocando na pasta WEB-INF / classes.

Envolva a tarefa de guerra dentro de um alvo Ant (geralmente pacote) e execute-o. Isso criará o arquivo WAR no local especificado.

É inteiramente possível aninhar os diretores de classes, lib, metainf e webinf de modo que vivam em pastas espalhadas em qualquer lugar na estrutura do projeto. Mas as melhores práticas sugerem que seu projeto da Web deve ter a estrutura de Conteúdo da Web semelhante à estrutura do arquivo WAR. O projeto de Aplicativo de Fax tem sua estrutura delineada usando este princípio básico.

Para executar a tarefa de guerra, envolva-a dentro de um alvo, mais comumente, o alvo de construção ou pacote e execute-os.

<target name="build-war">
   <war destfile="fax.war" webxml="${web.dir}/web.xml">
   <fileset dir="${web.dir}/WebContent">
      <include name="**/*.*"/>
   </fileset>
   <lib dir="thirdpartyjars">
      <exclude name="portlet.jar"/>
   </lib>
   <classes dir="${build.dir}/web"/>
   </war>
</target>

Executar o Ant neste arquivo criará o fax.war arquivo para nós.

O seguinte resultado é o resultado da execução do arquivo Ant:

C:\>ant build-war
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 12.3 seconds

O arquivo fax.war agora é colocado na pasta de saída. O conteúdo do arquivo war será:

fax.war:
   +---jsp             This folder contains the jsp files
   +---css             This folder contains the stylesheet files
   +---js              This folder contains the javascript files
   +---images          This folder contains the image files
   +---META-INF        This folder contains the Manifest.Mf
   +---WEB-INF
      +---classes   This folder contains the compiled classes
      +---lib       Third party libraries and the utility jar files
      WEB.xml       Configuration file that defines the WAR package

Aprendemos os diferentes aspectos do Ant usando o Hello World Aplicação web de fax em pedaços.

Agora é hora de colocar tudo junto para criar um arquivo build.xml completo e completo. Considerarbuild.properties e build.xml arquivos da seguinte forma:

build.properties

deploy.path=c:\tomcat6\webapps

build.xml

<?xml version="1.0"?>

<project name="fax" basedir="." default="usage">
   <property file="build.properties"/>
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="javadoc.dir" value="doc"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
      <pathelement path="${build.dir}"/>
   </path>
    
   <target name="javadoc">
      <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
         destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[<h1>= Fax Application =</h1>]]>
      </doctitle>
      <bottom><![CDATA[Copyright © 2011. All Rights Reserved.]]>
      </bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/> 
      <group title="data packages" 
         packages="faxapp.entity.*:faxapp.dao.*"/>
      </javadoc>
   </target>

   <target name="usage">
      <echo message=""/>
      <echo message="${name} build file"/>
      <echo message="-----------------------------------"/>
      <echo message=""/>
      <echo message="Available targets are:"/>
      <echo message=""/>
      <echo message="deploy    --> Deploy application as directory"/>
      <echo message="deploywar --> Deploy application as a WAR file"/>
      <echo message=""/>
   </target>

   <target name="build" description="Compile main 
      source tree java files">
   <mkdir dir="${build.dir}"/>
      <javac destdir="${build.dir}" source="1.5" 
         target="1.5" debug="true"
         deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
      </javac>
   </target>

   <target name="deploy" depends="build" 
      description="Deploy application">
   <copy todir="${deploy.path}/${name}" 
      preservelastmodified="true">
      <fileset dir="${web.dir}">
         <include name="**/*.*"/>
      </fileset>
   </copy>
   </target>

   <target name="deploywar" depends="build" 
      description="Deploy application as a WAR file">
      <war destfile="${name}.war"
         webxml="${web.dir}/WEB-INF/web.xml">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </war>
      <copy todir="${deploy.path}" preservelastmodified="true">
         <fileset dir=".">
            <include name="*.war"/>
         </fileset>
      </copy>
   </target>
    

   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>
</project>

Neste exemplo:

Primeiro declaramos o caminho para a pasta webapps no Tomcat no arquivo de propriedades de construção como o deploy.path variável.
Também declaramos a pasta de origem para os arquivos java no src.dir variável.
Em seguida, declaramos a pasta de origem para os arquivos da web no web.dir variável. javadoc.dir é a pasta para armazenar a documentação java, e build.dir é o caminho para armazenar os arquivos de saída do build.
Em seguida, declaramos o nome do aplicativo da web, que é fax no nosso caso.
Também definimos o caminho da classe mestre que contém os arquivos JAR presentes na pasta WEB-INF / lib do projeto.
Também incluímos os arquivos de classe presentes no build.dir no caminho da classe mestre.
O destino Javadoc produz o javadoc necessário para o projeto e o destino de uso é usado para imprimir os destinos comuns que estão presentes no arquivo de construção.

O exemplo acima mostra dois destinos de implantação: deploy e deploywar.

O destino de implantação copia os arquivos do diretório da web para o diretório de implantação, preservando o registro de data e hora da última modificação. Isso é útil ao implantar em um servidor que oferece suporte a implantação dinâmica.

O destino limpo limpa todos os arquivos construídos anteriormente.

O destino deploywar constrói o arquivo war e então copia o arquivo war para o diretório de implementação do servidor de aplicativos.

No capítulo anterior, aprendemos como empacotar um aplicativo e implantá-lo em uma pasta.

Neste capítulo, vamos implementar o aplicativo da Web diretamente na pasta de implementação do servidor de aplicativos e, em seguida, adicionar alguns destinos Ant para iniciar e parar os serviços. Vamos continuar com oHello Worldaplicativo da web de fax. Esta é uma continuação do capítulo anterior, os novos componentes estão destacados em negrito.

build.properties

# Ant properties for building the springapp

appserver.home=c:\\install\\apache-tomcat-7.0.19
# for Tomcat 5 use $appserver.home}/server/lib
# for Tomcat 6 use $appserver.home}/lib
appserver.lib=${appserver.home}/lib

deploy.path=${appserver.home}/webapps

tomcat.manager.url=http://www.tutorialspoint.com:8080/manager
tomcat.manager.username=tutorialspoint
tomcat.manager.password=secret

build.xml

<?xml version="1.0"?>

<project name="fax" basedir="." default="usage">
   <property file="build.properties"/>
   <property name="src.dir" value="src"/>
   <property name="web.dir" value="war"/>
   <property name="javadoc.dir" value="doc"/>
   <property name="build.dir" value="${web.dir}/WEB-INF/classes"/>
   <property name="name" value="fax"/>

   <path id="master-classpath">
      <fileset dir="${web.dir}/WEB-INF/lib">
         <include name="*.jar"/>
      </fileset>
   <pathelement path="${build.dir}"/>
   </path>
    
   <target name="javadoc">
   <javadoc packagenames="faxapp.*" sourcepath="${src.dir}" 
      destdir="doc" version="true" windowtitle="Fax Application">
      <doctitle><![CDATA[<h1>= Fax Application 
         =</h1>]]></doctitle>
      <bottom><![CDATA[Copyright © 2011. All 
         Rights Reserved.]]></bottom>
      <group title="util packages" packages="faxapp.util.*"/>
      <group title="web packages" packages="faxapp.web.*"/>
      <group title="data packages" packages="faxapp.entity.*:faxapp.dao.*"/>
   </javadoc>
   </target>

   <target name="usage">
   <echo message=""/>
   <echo message="${name} build file"/>
   <echo message="-----------------------------------"/>
   <echo message=""/>
   <echo message="Available targets are:"/>
   <echo message=""/>
   <echo message="deploy    --> Deploy application as directory"/>
   <echo message="deploywar --> Deploy application as a WAR file"/>
   <echo message=""/>
   </target>

   <target name="build" description="Compile main 
      source tree java files">
   <mkdir dir="${build.dir}"/>
   <javac destdir="${build.dir}" source="1.5" target="1.5" debug="true"
      deprecation="false" optimize="false" failonerror="true">
      <src path="${src.dir}"/>
      <classpath refid="master-classpath"/>
   </javac>
   </target>

   <target name="deploy" depends="build" description="Deploy application">
      <copy todir="${deploy.path}/${name}" 
         preservelastmodified="true">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </copy>
   </target>

   <target name="deploywar" depends="build" 
      description="Deploy application as a WAR file">
      <war destfile="${name}.war"
         webxml="${web.dir}/WEB-INF/web.xml">
         <fileset dir="${web.dir}">
            <include name="**/*.*"/>
         </fileset>
      </war>
      <copy todir="${deploy.path}" preservelastmodified="true">
         <fileset dir=".">
            <include name="*.war"/>
         </fileset>
      </copy>
   </target>
    

   <target name="clean" description="Clean output directories">
      <delete>
         <fileset dir="${build.dir}">
            <include name="**/*.class"/>
         </fileset>
      </delete>
   </target>

<!-- ============================================================ -->
<!-- Tomcat tasks -->
<!-- ============================================================ -->

<path id="catalina-ant-classpath">
<!-- We need the Catalina jars for Tomcat -->
<!--  * for other app servers - check the docs -->
   <fileset dir="${appserver.lib}">
      <include name="catalina-ant.jar"/>
   </fileset>
</path>

<taskdef name="install" classname="org.apache.catalina.ant.InstallTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="reload" classname="org.apache.catalina.ant.ReloadTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="list" classname="org.apache.catalina.ant.ListTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="start" classname="org.apache.catalina.ant.StartTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>
<taskdef name="stop" classname="org.apache.catalina.ant.StopTask">
   <classpath refid="catalina-ant-classpath"/>
</taskdef>

<target name="reload" description="Reload application in Tomcat">
   <reload url="${tomcat.manager.url}"username="${tomcat.manager.username}"
      password="${tomcat.manager.password}" path="/${name}"/>
</target>
</project>

Neste exemplo, usamos o Tomcat como nosso servidor de aplicativos. Primeiro, no arquivo de propriedades de construção, definimos algumas propriedades adicionais.

o appserver.home aponta para o caminho de instalação para o servidor de aplicativos Tomcat.
o appserver.lib aponta para os arquivos de biblioteca na pasta de instalação do Tomcat.
o deploy.path variável agora aponta para a pasta webapp no Tomcat.

Os aplicativos no Tomcat podem ser interrompidos e iniciados usando o aplicativo gerenciador do Tomcat. A URL para o aplicativo gerenciador, nome de usuário e senha também são especificados no arquivo build.properties. Em seguida, declaramos um novo CLASSPATH que contém ocatalina-ant.jar. Este arquivo jar é necessário para executar tarefas Tomcat por meio do Apache Ant.

O catalina-ant.jar fornece as seguintes tarefas:

Propriedades	Descrição
InstallTask	Instala um aplicativo da web. Nome da classe: org.apache.catalina.ant.InstallTask
ReloadTask	Recarregue um aplicativo da web. Nome da classe: org.apache.catalina.ant.ReloadTask
ListTask	Lista todos os aplicativos da web. Nome da classe: org.apache.catalina.ant.ListTask
StartTask	Inicia um aplicativo da web. Nome da classe: org.apache.catalina.ant.StartTask
StopTask	Para um aplicativo da web. Nome da classe: org.apache.catalina.ant.StopTask
ReloadTask	Recarrega um aplicativo da web sem parar. Nome da classe: org.apache.catalina.ant.ReloadTask

A tarefa de recarregamento requer os seguintes parâmetros adicionais:

URL para o aplicativo do gerenciador
Nome de usuário para reiniciar o aplicativo da web
Senha para reiniciar o aplicativo web
Nome do aplicativo da web a ser reiniciado

Deixe-nos emitir o deploy-warpara copiar o webapp para a pasta Tomcat webapps e, em seguida, permitir que recarregemos o aplicativo da Web de fax. O seguinte resultado é o resultado da execução do arquivo Ant:

C:\>ant deploy-war
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 6.3 seconds

C:\>ant reload
Buildfile: C:\build.xml

BUILD SUCCESSFUL
Total time: 3.1 seconds

Depois que a tarefa acima é executada, o aplicativo da web é implementado e o aplicativo da web é recarregado.

Você pode usar Ant para executar o código Java. No exemplo a seguir, a classe java recebe um argumento (endereço de e-mail do administrador) e envia um e-mail.

public class NotifyAdministrator
{
   public static void main(String[] args)
   {
      String email = args[0];
      notifyAdministratorviaEmail(email);
      System.out.println("Administrator "+email+" has been notified");
   }
   public static void notifyAdministratorviaEmail(String email
   { 
	   //......
   }
}

Aqui está uma construção simples que executa esta classe java.

<?xml version="1.0"?>
<project name="sample" basedir="." default="notify">
   <target name="notify">
      <java fork="true" failonerror="yes" classname="NotifyAdministrator">
         <arg line="[email protected]"/>
      </java>
   </target>
</project>

Quando a construção é executada, ela produz o seguinte resultado:

C:\>ant
Buildfile: C:\build.xml

notify: [java] Administrator [email protected] has been notified

BUILD SUCCESSFUL
Total time: 1 second

Neste exemplo, o código java faz uma coisa simples - enviar um e-mail. Poderíamos ter usado a tarefa Ant embutida para fazer isso. No entanto, agora que você teve a ideia, pode estender seu arquivo de construção para chamar o código java que executa coisas complicadas, por exemplo: criptografa seu código-fonte.

Se você já baixou e instalou o Eclipse, tem muito pouco a fazer para começar. O Eclipse vem pré-empacotado com o plugin Ant, pronto para uso.

Siga as etapas simples para integrar o Ant ao Eclipse.

Certifique-se de que o build.xml faça parte do seu projeto java e não resida em um local externo ao projeto.
Habilite Ant View seguindo Window > Show View > Other > Ant > Ant.
Abra o Project Explorer, arraste o build.xml para a Ant View.

Sua visualização do Ant é semelhante a:

Ao clicar nos destinos, construir / limpar / uso executará o Ant com o destino.

Clicar em "fax" executará o destino padrão - usage.

O plugin Ant Eclipse também vem com um bom editor para editar arquivos build.xml. O editor está ciente do esquema build.xml e pode ajudá-lo com a conclusão do código.

Para usar o editor Ant, clique com o botão direito em build.xml (no Project Explorer) e selecione Abrir com> Editor Ant. O editor Ant deve ser semelhante a:

O editor Ant lista os destinos no lado direito. A lista de alvos serve como um marcador que permite ir direto para a edição de um alvo específico.

JUnit é a estrutura de teste de unidade comumente usada para desenvolvimentos baseados em Java. É fácil de usar e estender. Existem várias extensões JUnit disponíveis. Se você não estiver familiarizado com o JUnit, faça o download em www.junit.org e leia seu manual.

Este capítulo mostra como executar testes JUnit usando Ant. O Ant torna-o direto na tarefa JUnit.

Os atributos da tarefa JUnit são apresentados a seguir:

Propriedades	Descrição
dir	De onde invocar a VM. Isso é ignorado quandofork está desabilitado.
jvm	Comando usado para chamar a JVM. Isso é ignorado quandofork está desabilitado.
garfo	Executa o teste em uma JVM separada
propriedade de erro	O nome da propriedade a ser definida se houver um erro JUnit
falha propriedade	O nome da propriedade a ser definida se houver uma falha JUnit
Haltonerror	Para a execução quando ocorre um erro de teste
Haltonfailure	Para a execução quando ocorre uma falha
resumo impresso	Aconselha o Ant a exibir estatísticas simples para cada teste
showoutput	Aconselha o Ant a enviar a saída para seus logs e formatadores
tempdir	Caminho para o arquivo temporário que o Ant usará
tempo esgotado	Sai dos testes que demoram mais para serem executados do que esta configuração (em milissegundos).

Vamos continuar o tema do Hello World Aplicativo da web de fax e adicione um destino JUnit.

O exemplo a seguir mostra uma execução simples de teste JUnit:

<target name="unittest">
   <junit haltonfailure="true" printsummary="true">
      <test name="com.tutorialspoint.UtilsTest"/>
   </junit>
</target>

Este exemplo mostra a execução de JUnit na classe junit com.tutorialspoint.UtilsTest. Executar o código acima produz a seguinte saída:

test:
[echo] Testing the application
[junit] Running com.tutorialspoint.UtilsTest
[junit] Tests run: 12, Failures: 0, Errors: 0, Time elapsed: 16.2 sec
BUILD PASSED

O Ant vem com um conjunto predefinido de tarefas, mas você pode criar suas próprias tarefas, conforme mostrado no exemplo abaixo.

Tarefas Ant personalizadas devem estender o org.apache.tools.ant.Taskclasse e deve estender o método execute (). Abaixo está um exemplo simples:

package com.tutorialspoint.ant;
import org.apache.tools.ant.Task;
import org.apache.tools.ant.Project;
import org.apache.tools.ant.BuildException;
public class MyTask extends Task {
   String message;
   public void execute() throws BuildException {
      log("Message: " + message, Project.MSG_INFO);
   }
   public void setMessage(String message) {
      this.message= message;
   }
}

Para executar a tarefa personalizada, você precisa adicionar o seguinte ao Hello World Aplicativo da web de fax:

<target name="custom">
   <taskdef name="custom" classname="com.tutorialspoint.ant.MyTask" />
   <custom message="Hello World!"/>
</target>

Executar a tarefa personalizada acima imprime a mensagem 'Hello World!'

c:\>ant custom
test:
[custom] Message : Hello World!
elapsed: 0.2 sec
BUILD PASSED

Este é apenas um exemplo simples, você pode usar o poder do Ant para fazer o que quiser para melhorar seu processo de construção e implantação.

Impressão