|
Arquivo de Códigos - Página Inicial
|
| Você
está aqui:
Inicio
-> Tutoriais
-> Apache Ant |
|
|
Como gerar arquivos JAR usando
Ant |
Agora que você já
conhece algumas das tarefas básicas da ferramenta 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.
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).
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 (para sua comodidade estes arquivos estão
disponíveis para download. Basta clicar no nome de cada
um deles):
Listagem para a classe Funcionario.java:
class Funcionario{
private String nome;
private double salario;
public Funcionario(String nome, double
salario){
this.nome =
nome;
this.salario
= salario;
}
public String getNome(){
return nome;
}
public double getSalario(){
return salario;
}
}
Listagem para a classe Cliente.java:
class Cliente{
private String nome;
private int codigo;
public Cliente(String nome, int codigo){
this.nome =
nome;
this.codigo
= codigo;
}
public String getNome(){
return nome;
}
public int getCodigo(){
return codigo;
}
}
Listagem para Empresa.java:
public class Empresa{
public static void main(String args[]){
Funcionario
func = new Funcionario("Carlos", 3465.23);
Cliente cli
= new Cliente("Bush", 324);
System.out.println("Funcionário:
" + func.getNome());
System.out.println("Cliente:
" + cli.getCodigo());
System.exit(0);
}
}
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. 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:
<project name="teste"
basedir="." default="executar">
<property name="classes"
location="classes"/>
<target name="dir">
<mkdir dir="classes"
/>
</target>
<target name="limpar">
<delete dir="classes"/>
</target>
<target name="compilar"
depends="dir">
<javac srcdir="${basedir}"
classpath="${classes}"
destdir="${classes}"
/>
</target>
<target name="empacotar"
depends="compilar">
<mkdir dir="build/jar"/>
<jar destfile="build/jar/Empresa.jar"
basedir="${basedir}/classes">
<manifest>
<attribute
name="Main-Class" value="Empresa"/>
</manifest>
</jar>
</target>
<target name="executar"
depends="empacotar, limpar">
<java jar="build/jar/Empresa.jar"
fork="true"/>
</target>
</project>
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:
C:\testes>ant
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
[jar] Building jar: C:\testes\build\jar\Empresa.jar
limpar:
[delete] Deleting directory C:\testes\classes
executar:
[java] Funcionario: Osmar
[java] Cliente: 324
BUILD SUCCESSFUL
Total time: 8 seconds
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:
C:\testes\build\jar>java
-jar Empresa.jar
Vamos agora entender todas as tarefas contidas neste arquivo
de build. Comece analisando o elemento project:
<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:
<property name="classes"
location="classes"/>
Essa variável será usada para indicarmos para
o arquivo de build o diretório onde os arquivos .java
deverão ser colocados após a compilação.
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
Veja o trecho da tarefa dir:
<target
name="dir">
<mkdir dir="classes" />
</target>
Tudo que fazemos aqui é criar um diretório chamado
classes. Em seguida observe a tarefa compilar:
<target name="compilar"
depends="dir">
<javac srcdir="${basedir}"
classpath="${classes}"
destdir="${classes}" />
</target>
Para a tarefa javac definimos valores para
três atributos. São eles:
1. 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.
2. 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 caminho,
é possível usar vírgulas ou ponto-e-vírgula
no valor do atributo.
3. destdir – define o diretório
onde as classes compiladas serão gravadas.
E agora, a tarefa mais importante do build, a tarefa responsável
por gerar o arquivo jar:
<target
name="empacotar" depends="compilar">
<mkdir dir="build/jar"/>
<jar destfile="build/jar/Empresa.jar"
basedir="${basedir}/classes">
<manifest>
<attribute
name="Main-Class" value="Empresa"/>
</manifest>
</jar>
</target>
O primeiro passo é criar o diretório onde o arquivo
jar será gravado:
<mkdir
dir="build/jar"/>
Em seguida temos a tarefa jar. Esta tarefa
possui os seguintes atributos:
a) destfile – É o caminho e nome
do arquivo jar a ser criado.
b) basedir – Diretório a partir
do qual os arquivos a serem incluídos no JAR serão
pesquisados.
Todo arquivo jar precisa ter o arquivo de manifesto. Este arquivo
é criado com o elemento manifest:
<manifest>
<attribute name="Main-Class"
value="Empresa"/>
</manifest>
É aqui que fornecemos
o nome da classe principal do aplicativo. Falhar em fornecer
este valor fará com que o arquivo jar não seja
executado corretamente.
Após a geração do arquivo jar, o diretório
classes é excluído com a seguinte
tarefa:
<target
name="limpar">
<delete dir="classes"/>
</target>
E, finalmente, o aplicativo é executado com a seguinte
tarefa:
<target
name="executar" depends="empacotar, limpar">
<java jar="build/jar/Empresa.jar"
fork="true"/>
</target>
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. |
Este tutorial contém as seguintes
seções:
- Apresentação
- O que é o Apache Ant?
- Baixando e Instalando o Apache
Ant
- Entendendo alvos, tarefas e
o arquivo build.xml
- Criando diretórios e
copiando arquivos usando Ant
- Usando variáveis durante
o processo de automação de tarefas
- Como compilar arquivos Java
usando Ant
- Uso do Ant na execução
de aplicativos Java
- Exibindo mensagens durante o
processo de automação das tarefas
- Empacotando aplicações
web com o uso da tarefa War
- Usando a tarefa Unwar para
extrair o conteúdo de um arquivo War
- Como gerar arquivos JAR usando Ant
- Interagindo com o Ant via console
durante a execução dos arquivos de build
- Como obter valores via console
durante a execução de um build Ant
- Como validar a entrada do usuário
em um arquivo de build (como estender a classe Task do Ant)
|
|
| |
|
| |
|
Códigos-fonte 
Bancos de Dados
Usuários On-Line
Veja dicas, truques e anotações de 
