Especialização em web com interfaces ricas. Ferramentas de automação

(1)

Especialização em web com interfaces

ricas

Ferramentas de automação

Prof. Fabrízzio Alphonsus A. M. N. Soares

fabrizzio@inf.ufg.br professor.fabrizzio@gmail.com Instituto de Informática

Universidade Federal de Goiás

Aula 11 1 de junho de 2012

(2)

Apache Ant

Nesta aula iremos aprender a:

Utilizar ferramentas para automação em tarefas de programação.

(3)

Apache Ant I

Com o Ant podemos realizar tarefas corriqueiras que vão desde a criação e exclusão de diretórios até o empacotamento de ar-quivos JAR e WAR.

(4)

Apache Ant II

Se você é desenvolver Java, mas ainda não conhece esta ferra-menta, a leitura e releitura deste tutorial trarão muitos benefí-cios e redução de tempo no desenvolvimento de seus projetos.

(5)

O que é o Apache Ant I

O Apache Ant, ou simplesmente Ant, é uma ferramenta es-crita em Java e usada para a automatização de builds e tarefas. Para desenvolvedores veteranos, o Ant é uma espécie de make, porém, mais simples de se configurar e usar.

(6)

O que é o Apache Ant II

O uso do Ant é justificado devido à quantidade de tarefas que devem ser executadas antes que uma aplicação esteja pronta para instalação ou distribuição final.

(7)

O que é o Apache Ant III

Entre estas tarefas estão:

compilação de classes Java; criação ou exclusão de diretórios; empacotamento de arquivos; execução de programas externos; etc.

(8)

O que é o Apache Ant IV

Quando se está usando um IDE, este se encarrega de realizar estas tarefas, uma vez que muitos deles já trazem o Ant em-butido. No entanto, o entendimento do Ant, e suas principais tarefas, é muito importante para o desenvolvedor Java que de-seja entender como estas operações funcionam nos bastidores.

(9)

O que é o Apache Ant V

O processo de automação de tarefas usando o Ant está comple-tamente centrado no uso de um documento XML que contém toda a informação sobre as tarefas a serem executadas.

Como estes documentos XML são criados e configurados pelo desenvolvedor, recomendo que você reveja seus conhecimentos sobre esta linguagem de marcação antes de progredirmos.

(10)

Baixando e instalando I

Os passos descritos neste tópico guiarão você durante o processo de baixar, instalar e configurar a ferramenta Ant no Windows XP.

De acordo com a documentação no endereço http://ant.apache.org/, esta ferramenta pode ser usada com sucesso em outras plata-formas tais como Linux, Solaris, MacOS X, entre outros.

(11)

Baixando e instalando II

Para instalar o Apache Ant no Ubuntu Linux basta busca-lo no Synaptic.

(12)

Baixando e instalando III

Esta ula foi escrita usando-se a versão 1.8.2 do Ant (liberada em Dezembro de 2010). Para baixar a versão mais recente basta

di-recionar seu navegador para o endereço http://ant.apache.org/bindownload.cgi e localizar o link apache-ant-x.y.z-bin.zip.

(13)

Baixando e instalando IV

Clique neste link, baixe o arquivo para seu computador e siga os passos descritos a seguir para instalar, configurar e testar o Ant:

1 Descompacte o arquivo que você baixou em qualquer

diretório. O resultado será uma pasta com o nome apache-ant-x.y.z-bin contendo outra pasta chamada apache-ant-x.y.z. Altere o nome da segunda pasta para ant e mova-a para o diretório raiz de seu sistema.

(14)

Baixando e instalando V

2 A única exigência para que o Ant funcione corretamente é

que você possua uma instalação recente do SDK JavaSE. Se você possui o Tomcat ou o servidor de aplicações do JavaEE instalado e rodando na sua máquina, não precisa se preocupar. O seu SDK JavaSE já está instalado e funcionando. Dessa forma, só precisamos adicionar o diretório bin do Ant ao path do sistema. No Windows XP isso é feito da seguinte forma:

a. Vá até Iniciar -> Configurações -> Painel de Controle -> Sistema;

(15)

Baixando e instalando VI

c. Em “Variáveis de usuário para...” você tem as opções de incluir, alterar ou remover as variáveis e/ou seus valores. Se a variável PATH ainda não estiver definida, defina-a. Em seguida adicione o valor “C:

ant

bin”. Isso fará com que o Windows (ou qualquer sistema que você esteja executando) reconheça o comando ant a partir de qualquer diretório. Se a variável PATH contiver mais de um valor, certifique-se de que esteja em um formato similar a:

1 C:\Sun\AppServer\bin;C:\Sun\AppServer\jdk\bin;C:\ant\

(16)

Baixando e instalando VII

1 E agora, hora de testar o Ant. Se você seguiu todos os

passos descritos para a instalação e configuração, abra uma janela do DOS (ou o prompt do Linux) e digite o seguinte comando:

1 ant -version

Se a ferramenta estiver funcionando corretamente você verá o seguinte resultado:

(17)

Entendendo alvos, tarefas e o arquivo

build.xml I

A automatização de tarefas com o Ant é feita usando-se ar-quivos de configuração escritos em XML. Estes arar-quivos, geral-mente chamados de build.xml possuem uma estrutura uniforme, variando apenas alguns elementos.

(18)

Entendendo alvos, tarefas e o arquivo

build.xml II

Em geral, seguem o seguinte modelo:

1 <project name="nome_projeto" basedir="." default="alvo1"> 2 <target name="alvo1"> 3 <tarefa1 /> 4 <tarefa2 /> 5 </target> 6 7 <target name="alvo2"> 8 <tarefa1 /> 9 <tarefa2 /> 10 </target> 11 12 <target name="alvo3"> 13 <tarefa1 />

(19)

Entendendo alvos, tarefas e o arquivo

build.xml III

A raiz deste documento XML é o elemento project. Os elementos-filhos são chamados de target (alvo) que, por sua vez, possuem tasks (tarefas) como seus elementos-filhos.

(20)

Entendendo alvos, tarefas e o arquivo

build.xml IV

Veja a definição dos três atributos para o elemento project: name: O nome do projeto. Este atributo pode ser omitido;

basedir: O diretório base a partir do qual os demais caminhos para arquivos e diretórios serão calculados. O valor “.” define o diretório atual. Este atributo pode ser omitido;

(21)

Entendendo alvos, tarefas e o arquivo

build.xml V

Um elemento project pode conter um número ilimitado de tar-gets. Os elementos targets possuem elementos-filhos que nos permitem definir as tarefas a serem realizadas quando um de-terminado alvo é executado. Entre os atributos de um elemento target o mais importante é name. Este atributo não pode ser omitido.

(22)

Entendendo alvos, tarefas e o arquivo

build.xml VI

Tarefas (tasks) são trechos de código que podem ser executados dependendo do objetivo da aplicação e de qual alvo o Ant está executando no momento. Dentre as tarefas mais comuns es-tão: criar, renomear ou excluir diretórios, compilar e empacotar arquivos, etc.

(23)

Criando diretórios e copiando arquivos

usando Ant I

Vamos um exemplo do uso do Apache Ant como ferramenta para criar diretórios e copiar arquivos.

Para isso você deverá efetuar os seguintes passos:

1 Crie um diretório chamado “antTeste”. Lembre-se. Limite

seus nomes de diretórios a oito caracteres no DOS;

2 Dentro deste diretório crie um arquivo em branco

chamado “index.jsp”;

3 Abra o bloco de notas (ou seu editor favorito) e crie o

(24)

Criando diretórios e copiando arquivos

usando Ant II

1 <project name="teste" basedir="." default="alvo"> 2 <target name="alvo">

3 <mkdir dir="paginas" />

4 <copy file="index.jsp" todir="paginas" /> 5 </target>

(25)

Criando diretórios e copiando arquivos

usando Ant III

Salve este arquivo com o nome de build.xml no diretório ant-Teste. Se este diretório foi criado na raiz do seu sistema, você poderá abrir uma seção do DOS, navegar até o diretório ant-Teste e executar o seguinte comando:

(26)

Criando diretórios e copiando arquivos

usando Ant IV

Se a estrutura do documento XML estiver bem formada, você verá o seguinte resultado:

Buildfile: build.xml alvo:

[mkdir] Created dir: C:\ANTTESTE\paginas [copy] Copying 1 file to C:\ANTTESTE\paginas BUILD SUCCESSFUL

(27)

Criando diretórios e copiando arquivos

usando Ant V

Abra o diretório antTeste e verá que a pasta paginas foi criada e dentro desta temos uma cópia do arquivo index.jsp. Vamos entender como isso aconteceu:

O elemento raiz do documento XML:

1 <project name="teste" basedir="." default="alvo"> 2 </project>

Define o diretório atual como valor para a propriedade basedir e define o target alvo como padrão. Desta maneira, o mesmo resultado poderia ser obtido omitindo o valor alvo na chamada ao Ant:

(28)

Criando diretórios e copiando arquivos

usando Ant VI

(29)

Criando diretórios e copiando arquivos

usando Ant VII

Observe agora a estrutura do elemento target cujo nome é alvo:

1 <target name="alvo"> 2 <mkdir dir="paginas" />

Veja que a primeira tarefa deste alvo é criar o diretório “paginas”:

A segunda tarefa copia o arquivo index.jsp para o diretório pa-ginas:

(30)

Criando diretórios e copiando arquivos

usando Ant VIII

1 <copy file="index.jsp" todir="paginas" />

Como você pode ver, o atributo basedir foi definido, mas não o usamos durante a execução das tarefas (embora a ferramenta o tenha usado implicitamente para saber o diretório a partir do qual as tarefas propostas deveriam ser realizadas).

(31)

Usando variáveis durante o processo de

automação de tarefas I

O Apache Ant nos permite usar variáveis nos documentos XML usados na automação das tarefas. Este é um recurso interes-sante, pois torna o processo mais dinâmico e encoraja o reapro-veitamento de código. Além disso, a ferramenta traz algumas variáveis embutidas e permite o acesso a propriedades do sis-tema, como veremos mais adiante.

(32)

Usando variáveis durante o processo de

automação de tarefas II

Em geral o acesso a variáveis é feito na forma ${nome_da_variável}. Veja um exemplo de tarefa que cria uma pasta chamada paginas no diretório home do usuário atual:

1 <target name="diretorio">

2 <mkdir dir="${user.home}/paginas" /> 3 </target>

(33)

Usando variáveis durante o processo de

automação de tarefas III

Outra forma de se usar variáveis é declará-las globais usando a tarefa property. Isso é feito antes da declaração de qualquer elemento target. Veja um exemplo:

1 <project name="teste" basedir="c:/estudos" default="dir"> 2

3 <property name="src" location="src"/> 4 <property name="build" location="build"/> 5 6 <target name="dir"> 7 <mkdir dir="${src}/java" /> 8 <mkdir dir="${build}/dist" /> 9 </target> 10 11 </project>

(34)

Usando variáveis durante o processo de

automação de tarefas IV

Uma tarefa property possui muitos atributos. Para este exemplo estamos usando name e location. Veja suas definições:

name: O valor da propriedade, ou seja, aquele que será referenciado como variável dentro das tarefas do documento XML.

location: Associa a propriedade a um nome de arquivo ou diretório. Neste caso o caminho pode ser absoluto ou relativo. Sendo relativo, o caminho será expandido de

(35)

Usando variáveis durante o processo de

automação de tarefas V

O valor da propriedade basedir é “c:

estudos”. Se chamarmos o Ant neste exemplo teremos o se-guinte resultado:

Buildfile: build.xml dir:

[mkdir] Created dir: C:\estudos\src\java [mkdir] Created dir: C:\estudos\build\dist BUILD SUCCESSFUL

(36)

Usando variáveis durante o processo de

automação de tarefas VI

Experimente alterar os valores dos atributos name e location e observe o resultado obtido. Altere agora o valor da propriedade basedir e efetue mais alguns testes.

(37)

Como compilar arquivos Java usando Ant

I

Nosso próximo exemplo é um pouco mais elaborado e coloca em prática alguns dos conceitos explicados nos tópicos anteriores. Desta vez você usará o Ant para compilar um arquivo .java, criar um diretório e mover para este diretório o resultado da compilação, ou seja, o arquivo com a extensão .class.

(38)

Como compilar arquivos Java usando Ant

II

Para isso siga os seguintes passos:

1 Crie um diretório no qual o projeto será desenvolvido,

pode ser algo como “c:

testes” (ou algo semelhante se estiver usando Linux);

2 Abra seu editor favorito e escreva o seguinte programa

Java (para sua comodidade este arquivo pode ser baixado clicando-se aqui):

1 public class TesteAnt{

2 public static void main(String args[]){

(39)

Como compilar arquivos Java usando Ant

III

Salve este arquivo com o nome de TesteAnt.java no diretório que você criou no passo 1.

3 Crie um documento XML semelhante ao mostrado a

seguir:

1 <project name="teste" basedir="." default="compilar"> 2

3 <property name="classes" location="classes"/> 4

5 <target name="dir">

6 <mkdir dir="classes" /> 7 </target>

8

9 <target name="compilar" depends="dir"> 10 <javac srcdir="${basedir}"

11 destdir="${classes}" /> 12 </target>

(40)

Como compilar arquivos Java usando Ant

IV

13

14 </project>

Salve este arquivo com o nome build.xml no diretório que você criou no passo 1.

4 Hora do teste. Abra uma seção do DOS, navegue até o

diretório que você criou e execute o comando:

(41)

Como compilar arquivos Java usando Ant

V

[mkdir] Created dir: C:\TESTES\classes compilar:

[javac] Compiling 1 source file to C:\TESTES\classes BUILD SUCCESSFUL

(42)

Como compilar arquivos Java usando Ant

VI

Abra o diretório “c:

testes” e verá a pasta classes. Dentro desta pasta você encon-trará o arquivo TesteAnt.class.

Realmente uma ferramenta muito útil, não? Vamos ver como isso aconteceu.

(43)

Como compilar arquivos Java usando Ant

VII

Observação Importante:

Se houver mais de um arquivo .java neste diretório todos eles serão compilados e os arquivos .class correspondentes serão co-piados para a pasta classes. Existe, porém, uma ressalva nesta regra: somente arquivos .java que não possuem seus arquivos .class correspondentes ou arquivos .java mais recentes que seus arquivos .class é que serão compilados.

Mais adiantes veremos o uso de filtros para compilar apenas determinados arquivos.

(44)

Como compilar arquivos Java usando Ant

VIII

Este exemplo pode ser executado chamando o Ant sem argu-mentos. Lembra-se de que, na falta de argumentos, a tarefa que será executada é aquela definida no atributo default? Analise a seguinte tarefa:

(45)

Como compilar arquivos Java usando Ant

IX

Veja que ao usarmos o atributo depends, estamos informando ao Ant que a tarefa compilar deverá ser executada somente após a execução da tarefa dir. E, nem precisamos chamar esta tarefa a partir da linha de comando. O Ant se encarrega de tudo.

(46)

Como compilar arquivos Java usando Ant

X

Após a criação do diretório classes na tarefa dir:

temos a tarefa que compila o arquivo .java e copia o resultado (o arquivo .class) para o diretório classes:

(47)

Como compilar arquivos Java usando Ant

XI

Veja que para este exemplo fornecemos ao compilador Java ape-nas o diretório de saída (srcdir) e o diretório de destino (dest-dir). É possível fornecer mais informações tais como classpath, target, etc.

(48)

Uso do Ant na execução de aplicativos

Java I

Vamos ver como é possível executar o arquivo resultante da compilação (arquivos .class). Para isto vamos modificar o do-cumento XML usado no exemplo anterior para esta nova versão:

1 <project name="teste" basedir="." default="compilar"> 2

3 <property name="classes" location="classes"/> 4 <property name="arquivo" value="TesteAnt" /> 5

9

(49)

Uso do Ant na execução de aplicativos

Java II

15 <target name="executar" depends="dir, compilar"> 16 <java classname="${arquivo}" > 17 <classpath path="${classes}" /> 18 </java> 19 </target> 20 21 </project>

(50)

Uso do Ant na execução de aplicativos

Java III

Este arquivo XML contém informações para algumas tarefas um pouco mais complexas. Comece analisando a segunda tarefa property:

1 <property name="arquivo" value="TesteAnt" />

Veja que está tarefa se chama arquivo e possui o valor TesteAnt. Fique atento ao uso deste valor mais adiante. O diretório classes é criado com o seguinte alvo:

(51)

Uso do Ant na execução de aplicativos

Java IV

Para compilar o arquivo TesteAnt.java e copiá-lo para a pasta classes usamos o alvo:

3 destdir="${classes}" /> 4 </target>

Finalmente, executamos o arquivo resultante (TesteAnt.class) usando o alvo:

(52)

Uso do Ant na execução de aplicativos

Java V

1 <target name="executar" depends="dir, compilar"> 2 <java classname="${arquivo}" >

3 <classpath path="${classes}" /> 4 </java>

(53)

Uso do Ant na execução de aplicativos

Java VI

Veja que esta tarefa depende das duas tarefas anteriores. Desta forma, você poderá executar o Ant fornecendo o alvo executar como argumento:

(54)

Uso do Ant na execução de aplicativos

Java VII

Dentre os argumentos que podem ser fornecidos para a tarefa java, os mais importantes são classname (o nome da classe a ser executada) e classpath (o caminho para o diretório que contem a(s) classe(s)).

Observe que temos que usar o atributo path juntamente com o argumento classpath.

(55)

Uso do Ant na execução de aplicativos

Java VIII

Como sugestão, recomendo que você investigue na documenta-ção do Ant outros argumentos possíveis.

(56)

Exibindo mensagens durante o processo

de automação das tarefas I

Durante o processo de execução das diversas tarefas definidas no documento XML, é possível exibir mensagens usando a ta-refa echo. Este procedimento é útil quando precisamos de um feedback visual dos procedimentos realizados pelo Ant.

(57)

Exibindo mensagens durante o processo

de automação das tarefas II

O documento XML a seguir mostra a você como se certificar de que os valores fornecidos para algumas variáveis são realmente aqueles que você precisa durante a realização das tarefas. O exemplo mostra ainda como exibir valores das variáveis embu-tidas no Ant:

(58)

Exibindo mensagens durante o processo

de automação das tarefas III

1 <project name="teste" basedir="." default="exibir"> 2

3 <tstamp>

4 <format property="horas" pattern="hh:mm:ss" locale="br" />

5 <format property="data" pattern="dd/MM/yyyy" locale="br" />

6 </tstamp> 7

8 <property name="projeto.nome" value="TesteEcho"/> 9

10 <target name="exibir">

11 <echo>Este e um exemplo de como voce pode usar

12 a tarefa echo para exibir mensagens durante o

(59)

Exibindo mensagens durante o processo

de automação das tarefas IV

17 <target name="java">

18 <echo message="Instalacao do Java: ${java.home}"/> 19 </target>

20

21 <target name="projeto">

22 <echo message="Projeto: ${projeto.nome}"/> 23 </target>

24

25 <target name="DataHora">

26 <echo message="Data e Hora: ${data} - ${horas}" /> 27 </target>

28

(60)

Exibindo mensagens durante o processo

de automação das tarefas V

Este documento XML apresenta a tarefa Tstamp. Esta tarefa é muito útil quando queremos exibir informações sobre a hora e a data em que o arquivo que a contém foi processado pelo Ant.

(61)

Exibindo mensagens durante o processo

de automação das tarefas VI

Seu propósito é definir as propriedades DSTAMP, TSTAMP e TODAY. Por padrão, a propriedade DSTAMP é definida no formato “yyyyMMdd”, TSTAMP é definida no formato “hhmm” e TODAY no formato “MMMM dd yyyy”. Uma abordagem interessante é usar o elemento format para formatar estes dados de acordo com o formato a que estamos acostumados.

(62)

Exibindo mensagens durante o processo

de automação das tarefas VII

Veja como o usamos no exemplo:

1 <tstamp>

2 <format property="horas" pattern="hh:mm:ss" locale="br"/> 3 <format property="data" pattern="dd/MM/yyyy" locale="br"/> 4 </tstamp>

Aqui temos um elemento format com três atributos:

1 O primeiro atributo define a variável global que poderá

(63)

Exibindo mensagens durante o processo

de automação das tarefas VIII

3 O atributo locale pode ser omitido sem prejudicar a

estrutura do documento.

Por enquanto, saiba que as variáveis horas e data poderão ser acessadas em todo o documento XML usando-se os formatos ${data} e ${horas}.

(64)

Exibindo mensagens durante o processo

de automação das tarefas IX

Após a definição da tarefa Tstamp, temos uma tarefa property:

1 <property name="projeto.nome" value="TesteEcho"/>

Usamos esta tarefa para fornecer um nome para o projeto. Veja que é possível usar pontos (.) nos nomes das tarefas property. Isso facilita a criação de hierarquias. A partir deste ponto o nome do projeto pode ser acessado usando-se ${projeto.nome}.

(65)

Exibindo mensagens durante o processo

de automação das tarefas X

O primeiro alvo, que pode ser invocado por “ant exibir”, exe-cuta apenas a tarefa echo. Como resultado, teremos apenas a exibição, no console, do texto entre as tags <echo></echo>:

1 <target name="exibir">

2 <echo>Este e um exemplo de como voce pode usar

3 a tarefa echo para exibir mensagens durante o processo

4 de automacao de builds.

5 </echo> 6 </target>

(66)

Exibindo mensagens durante o processo

de automação das tarefas XI

O segundo alvo, que pode ser invocado por “ant java”, exe-cuta outra tarefa echo. Desta vez temos a exibição do local de instalação do Java:

1 <target name="java">

2 <echo message="Instalacao do Java: ${java.home}"/> 3 </target>

Os dois últimos alvos, invocados por “ant projeto” e “ant Da-taHora”, fazem uso da tarefa echo para exibir o nome do projeto

(67)

Como gerar arquivos JAR usando Ant I

Agora que você já conhece algumas das tarefas básicas da fer-ramenta Ant, podemos avançar um pouco mais.

Neste tópico você aprenderá como escrever um aplicativo Java composto de três classes. Em seguida escreverá um arquivo de build que compilará estas classes. Finalmente você as colocará em um arquivo Jar para distribuição. Lembre-se de que todo o processo de compilação das classes e geração do arquivo Jar deverá ser feito por um único arquivo de build.

(68)

Como gerar arquivos JAR usando Ant II

O primeiro passo será escrever os arquivos .java que farão parte do exemplo. Este é um aplicativo simples composto de três classes chamadas Empresa, Funcionario e Cliente (boa hora para praticar composição).

(69)

Como gerar arquivos JAR usando Ant III

Para acompanhar este exemplo você deverá criar um diretório chamado testes em seu sistema (no meu sistema estou usando “C:

testes”). Em seguida crie três arquivos .java de acordo com as listagens seguintes:

(70)

Como gerar arquivos JAR usando Ant IV

1 class Funcionario{ 2 private String nome; 3 private double salario; 4

5 public Funcionario(String nome, double salario){

6 this.nome = nome;

7 this.salario = salario;

8 }

9

10 public String getNome(){ 11 return nome;

12 }

13

14 public double getSalario(){ 15 return salario;

(71)

Como gerar arquivos JAR usando Ant V

1 class Cliente{

2 private String nome; 3 private int codigo; 4

5 public Cliente(String nome, int codigo){

6 this.nome = nome;

7 this.codigo = codigo;

8 }

9

10 public String getNome(){ 11 return nome;

12 }

13

14 public int getCodigo(){ 15 return codigo;

16 }

(72)

Como gerar arquivos JAR usando Ant VI

1 public class Empresa{

2 public static void main(String args[]){

3 Funcionario func = new Funcionario("Carlos", 3465.23);

4 Cliente cli = new Cliente("Bush", 324);

5 6 System.out.println("Funcionário: " + func.getNome()); 7 System.out.println("Cliente: " + cli.getCodigo()); 8 9 System.exit(0); 10 } 11 }

(73)

Como gerar arquivos JAR usando Ant VII

Este exemplo é muito simples. Tudo que temos aqui é uma classe pública (Empresa) que constrói instancias de duas classes que possuem acesso de pacote. Não entraremos em detalhes sobre o funcionamento de cada uma.

(74)

Como gerar arquivos JAR usando Ant VIII

Nosso objetivo é entender como o Ant nos possibilita compilar e empacotar estas classes em um arquivo Jar. Sendo assim vamos escrever o arquivo build.xml. Eis a listagem:

1 <project name="teste" basedir="." default="executar"> 2

3 <property name="classes" location="classes"/> 4 5 <target name="dir"> 6 <mkdir dir="classes" /> 7 </target> 8 9 <target name="limpar"> 10 <delete dir="classes"/> 11 </target> 12

(75)

Como gerar arquivos JAR usando Ant IX

17 </target> 18

19 <target name="empacotar" depends="compilar"> 20 <mkdir dir="build/jar"/>

21 <jar destfile="build/jar/Empresa.jar"

22 basedir="${basedir}/classes">

23 <manifest>

24 <attribute name="Main-Class" value="Empresa"/>

25 </manifest>

26 </jar>

27 </target> 28

29 <target name="executar" depends="empacotar, limpar"> 30 <java jar="build/jar/Empresa.jar" fork="true"/> 31 </target>

32

(76)

Como gerar arquivos JAR usando Ant X

Antes de executarmos este exemplo certifique-se de ter efetuado todos os passos descritos anteriormente, ou seja, você deverá ter um diretório chamado C:

testes contendo três arquivos .java e o arquivo de build (build.xml). Agora é só abrir uma seção do DOS, navegar até C:

testes e inserir o comando abaixo:

(77)

Como gerar arquivos JAR usando Ant XI

Veja o resultado da execução do arquivo de build: Buildfile: build.xml

dir:

[mkdir] Created dir: C:\testes\classes compilar:

[javac] Compiling 3 source files to C:\testes\classes empacotar:

[mkdir] Created dir: C:\testes\build\jar

(78)

Como gerar arquivos JAR usando Ant XII

limpar:

[delete] Deleting directory C:\testes\classes executar:

[java] Funcionario: Osmar [java] Cliente: 324

BUILD SUCCESSFUL

(79)

Como gerar arquivos JAR usando Ant XIII

Como podemos ver por este resultado, nosso arquivo de build foi executado da maneira que esperávamos. Abra o diretório C: testes

build

jar e verá que o arquivo Empresa.jar realmente foi gerado. Caso deseje executa-lo novamente sem a ajuda do Ant basta abrir uma seção do DOS e digitar o comando abaixo:

(80)

Como gerar arquivos JAR usando Ant XIV

Vamos agora entender todas as tarefas contidas neste arquivo de build. Comece analisando o elemento project:

1 <project name="teste" basedir="." default="executar">

Veja que o nome do projeto é teste, o diretório base é o diretório atual e a tarefa padrão (no caso de omitirmos a tarefa na linha de comando) é executar. Em seguida temos a tarefa property que nos permite definir uma variável global chamada classes:

(81)

Como gerar arquivos JAR usando Ant XV

Quando este arquivo de build é executado temos uma série de tarefas dependentes umas das outras. Por exemplo, a tarefa executar depende das tarefas empacotar e limpar. Já a tarefa empacotar depende da tarefa compilar e assim por diante. Veja a seqüência da execução das tarefas (assumindo que a tarefa padrão seja executar):

1 dir 2 compilar

3 empacotar

4 limpar 5 executar

(82)

Como gerar arquivos JAR usando Ant XVI

Veja o trecho da tarefa dir:

(83)

Como gerar arquivos JAR usando Ant

XVII

Tudo que fazemos aqui é criar um diretório chamado classes. Em seguida observe a tarefa compilar:

3 classpath="${classes}" 4 destdir="${classes}" /> 5 </target>

(84)

Como gerar arquivos JAR usando Ant

XVIII

Para a tarefa javac definimos valores para três atributos. São eles:

srcdir define o diretório em que os arquivos .java a serem compilados se encontram. Usamos o atributo basedir para especificar o diretório atual.

classpath Usado para indicar ao compilador o(s) caminho(s) em que algumas classes necessárias ao correto processo de compilação de encontram. Para o caso de você precisar especificar mais de um

(85)

Como gerar arquivos JAR usando Ant XIX

destdir define o diretório onde as classes compiladas serão gravadas.

(86)

Como gerar arquivos JAR usando Ant XX

E agora, a tarefa mais importante do build, a tarefa responsável por gerar o arquivo jar:

1 <target name="empacotar" depends="compilar"> 2 <mkdir dir="build/jar"/>

3 <jar destfile="build/jar/Empresa.jar" 4 basedir="${basedir}/classes">

5 <manifest>

6 <attribute name="Main-Class" value="Empresa"/>

7 </manifest>

8 </jar> 9 </target>

(87)

Como gerar arquivos JAR usando Ant XXI

O primeiro passo é criar o diretório onde o arquivo jar será gravado:

Em seguida temos a tarefa jar. Esta tarefa possui os seguintes atributos:

1 destfile - É o caminho e nome do arquivo jar a ser criado. 2 basedir - Diretório a partir do qual os arquivos a serem

(88)

Como gerar arquivos JAR usando Ant

XXII

Todo arquivo jar precisa ter o arquivo de manifesto. Este arquivo é criado com o elemento manifest:

1 <manifest>

2 <attribute name="Main-Class" value="Empresa"/> 3 </manifest>

É aqui que fornecemos o nome da classe principal do aplicativo. Falhar em fornecer este valor fará com que o arquivo jar não

(89)

Como gerar arquivos JAR usando Ant

XXIII

Após a geração do arquivo jar, o diretório classes é excluído com a seguinte tarefa:

1 <target name="limpar"> 2 <delete dir="classes"/> 3 </target>

E, finalmente, o aplicativo é executado com a seguinte tarefa:

1 <target name="executar" depends="empacotar, limpar"> 2 <java jar="build/jar/Empresa.jar" fork="true"/> 3 </target>

(90)

Como gerar arquivos JAR usando Ant

XXIV

Quando o valor true é fornecido para o atributo fork da tarefa java, a execução do arquivo é feita em uma nova instancia da JVM e não aquela que está sendo usada para a execução do Ant.

(91)

Interagindo com o Ant via console

durante a execução dos arquivos de build I

Uma das aplicações mais interessantes da comunicação com o Ant após o início da execução do arquivo de build é solicitar nomes de diretórios ou arquivos ou ainda solicitar confirmação para uma tarefa a ser executada.

(92)

Interagindo com o Ant via console

durante a execução dos arquivos de build II

A tarefa input é usada quando queremos pausar a execução do Ant e esperar pelo pressionamento de alguma tecla ou informa-ção do usuário. Veja um exemplo:

(93)

Interagindo com o Ant via console

durante a execução dos arquivos de build III

O simples fato de inserir esta tarefa no fluxo de execução de um determinado alvo fará com que a execução do build seja in-terrompida e recomece somente quando você pressionar a tecla Enter. É claro que é sempre uma boa idéia informar o usuário sobre este procedimento. Assim, uma abordagem melhor é usar:

(94)

Interagindo com o Ant via console

durante a execução dos arquivos de build IV

Caso você desejar a confirmação do usuário antes de proceder com a execução do arquivo de build poderá usar o seguinte código (como um exemplo vale mais que 1000 palavras, o build a seguir pede confirmação antes de criar um diretório e copiar um arquivo):

1 <project name="teste" basedir="." default="alvo"> 2

3 <target name="alvo">

4 <input

5 message="O diretorio paginas sera criado agora.

Deseja

(95)

Interagindo com o Ant via console

durante a execução dos arquivos de build V

11 </condition>

12 <fail if="sair">O processo de build foi cancelado.</fail >

13

17

(96)

Interagindo com o Ant via console

durante a execução dos arquivos de build VI

C:\testes>ant

[input] O diretorio paginas sera criado agora. Deseja continuar (s/n)?(s,n) s

[mkdir] Created dir: C:\testes\paginas [copy] Copying 1 file to C:\testes\paginas BUILD SUCCESSFUL

(97)

Interagindo com o Ant via console

durante a execução dos arquivos de build VII

Veja que aqui a resposta para a pergunta foi “s”. Se responder-mos “n” tereresponder-mos outro resultado. Observe:

C:\testes>ant

[input] O diretorio paginas sera criado agora. Deseja continuar (s/n)?(s,n) n

BUILD FAILED

(98)

Interagindo com o Ant via console

durante a execução dos arquivos de build VIII

(99)

Interagindo com o Ant via console

durante a execução dos arquivos de build IX

O primeiro passo para entender este arquivo de build é começar analisando a tarefa input:

1 <input

2 message="O diretorio paginas sera criado agora. Deseja

3 continuar (s/n)?"

4 validargs="s,n" 5 addproperty="valor" />

(100)

Interagindo com o Ant via console

durante a execução dos arquivos de build X

Veja que aqui temos três atributos. Veja suas definições a se-guir:

1 message - É a mensagem a ser exibida para o usuário; 2 validargs - Uma string contendo as palavras (ou letras)

válidas como argumento de entrada no console. Observe que validarags é sensitiva à maiúsculas e minúsculas. Em nosso exemplo aceitamos somente “s” e “n”. Se

quiséssemos aceitar também “S” e “N” bastaria acrescentar estas letras ao valor do atributo.

(101)

Interagindo com o Ant via console

durante a execução dos arquivos de build XI

Logo após o elemento input temos uma condição:

1 <condition property="sair">

2 <equals arg1="n" arg2="${valor}"/> 3 </condition>

(102)

Interagindo com o Ant via console

durante a execução dos arquivos de build XII

Esta condição define uma propriedade (ou seria melhor chamá-la de variável?) global chamada sair. Inicialmente o valor para esta propriedade é false. Dentro do elemento condition temos um elemento equals que compara o valor informado pelo usuário (presente em arg2) com um dos valores válidos como entrada. No nosso exemplo, a propriedade sair terá o valor true se o valor informado pelo usuário for igual a “n”.

(103)

Interagindo com o Ant via console

durante a execução dos arquivos de build XIII

E agora o trecho mais importante: um elemento fail:

1 <fail if="sair">O processo de build foi cancelado.</fail>

Este elemento possui apenas um atributo (a mensagem a ser exibida) e é usado para testarmos valores de propriedades para decidir se a execução do build deverá prosseguir ou ser interrom-pida. Veja como testamos o valor da propriedade sair definida anteriormente no elemento condition. É importante observar que, se o teste efetuado no elemento fail resultar verdadeiro, a execução do arquivo é interrompida, ou seja, nenhuma linha de código após este elemento será executada.

(104)

Como obter valores via console durante a

execução de um build Ant I

Nosso próximo exemplo mostra como solicitar ao usuário que forneça o nome de um diretório a ser criado. Observe que se o usuário não fornecer um valor, ou seja, simplesmente pressionar Enter, o arquivo de build se encarregará de fornecer um valor padrão para o diretório.

(105)

Como obter valores via console durante a

execução de um build Ant II

Veja a listagem:

1 <project name="teste" basedir="." default="dir"> 2

4 <input

5 message="Forneca um nome para o diretorio a ser

criado e 6 pressione Enter:" 7 addproperty="diretorio" 8 defaultvalue="paginas" /> 9 10 <mkdir dir="${diretorio}" /> 11 </target> 12 13 </project>

(106)

Como obter valores via console durante a

execução de um build Ant III

Execute este arquivo de build e terá o resultado mostrado a seguir:

C:\testes>ant

[input] Forneca um nome para o diretorio a ser criado e pressione Enter:

(107)

Como obter valores via console durante a

execução de um build Ant IV

Total time: 6 seconds

Veja que forneci o nome “estudos” para o diretório a ser criado. Experimente agora executar o arquivo novamente e, pressione Enter sem informar valor algum. Veja como o diretório paginas será criado.

O trecho mais importante deste arquivo é a propriedade de-faultvalue que possibilita definir um valor default (padrão) para a propriedade diretorio caso o usuário pressione Enter sem in-formar um valor:

(108)

Como obter valores via console durante a

execução de um build Ant V

1 <input

2 message="Forneca um nome para o diretorio a ser criado e

3 pressione Enter:"

4 addproperty="diretorio" 5 defaultvalue="paginas" />