> ----- Original Message -----
> From: Raphael
> To: [EMAIL PROTECTED]
> Sent: Friday, August 02, 2002 11:07 AM
> Subject: [java-list] Compilação
>
> Galera, alguém sabe se tem alguma ferramenta que vem com o proprio
> jdk que posso utilizar para compilar uma serie de
> arquivos somente se este foi modificado e não todos os aquivos da pasta???


Use o Jakarta Ant. Não só faz o que você deseja mas faz muito mais.

O Ant não vem com o J2SDK mas é uma daquelas ferramentas indispensáveis para
qualquer desenvolvedor Java. Se você baixou o J2SDK1.4, você deve também
baixar o Ant.

Para começar, veja o minitutorial abaixo.

----------------------------------------------
Como criar um ambiente de desenvolvimento Java usando o J2SDK e o Ant.

O Ant é uma ferramenta indispensável para o desenvolvimento Java. Se você
não usa um IDE, você pode usá-la para automatizar diversos processos e
aumentar significativamente sua produtividade. Se você usa um IDE, você
ainda pode usar o Ant para criar roteiros de montagem independentes de IDE,
para que outras pessoas consigam montar e implantar sua aplicação
independente de terem ou não o mesmo IDE que você. Além disso, o que se pode
fazer com o Ant supera e muito qualquer comando "build" de qualquer IDE
existente hoje no mercado.

Antes de começar, seu ambiente Java deve estar devidamente configurado. Você
deve poder executar java e javac da linha de comando e a variável de
ambiente "JAVA_HOME" deve estar definida e apontar para o local de
instalação do seu SDK.

# Instalação do Ant:
1. Pegue o Ant 1.5 em: http://jakarta.apache.org/ant
2. Abra o ZIP em algum lugar da sua máquina (sugestão: c:\ ou c:\programas
no Windows ou /usr/local/ no Unix)
3. Mude o nome do diretório criado (jakarta-ant-1.5) para simplesmente "ant"
(no Linux, faça um link simbólico). Isto permitirá que você possa baixar
novas versões futuras e não precisar ficar redefinindo variáveis de
ambiente.
4. Defina uma variável de ambiente do sistema "ANT_HOME" que aponte para o
diretório (c:\ant, /usr/local/ant)
5. Acrescente ao seu PATH: $ANT_HOME/bin (Linux) ou %ANT_HOME%\bin (Windows)

Agora você deve poder executar "ant" de qualquer lugar na sua máquina. Deve
aparecer uma mensagem de erro dizendo "build.xml does not exist!". O próximo
passo é criar um build.xml.

# O Buildfile (build.xml), Alvos e Tarefas
O build.xml (buildfile) é o roteiro que o Ant usa para realizar várias
tarefas. É um arquivo XML que representa um "projeto". Um projeto é uma
coleção de alvos, ou targets. Você pode comparar um alvo a um método. Se o
buildfile fosse uma classe, os alvos são métodos.  Cada alvo consiste de uma
seqüência de tarefas que devem ser executadas. Por exemplo, você pode ter um
alvo para compilar, outro para criar um JAR, outro para copiar seu JAR para
outro lugar, etc. Alvos devem ser pequenos e fazerem poucas coisas (de
preferência devem realizar uma tarefa ou uma seqüência indivisível de
tarefas).

As tarefas são os procedimentos existentes dentro dos alvos. Elas são
executadas em seqüência. Se uma delas falha, todo o processo de build falha.

O Ant só executa um alvo de cada vez, mas você pode definir dependências e
fazer com que a execução de um alvo cause a execução de vários outros em
cascata. Você também pode chamar um alvo de dentro de outro. Por exemplo,
suponha que você tenha algumas classes para compilar e depois empacotar em
um JAR. Você pode criar dois alvos: "compilar" e "criar_jar" e dizer que
"criar_jar" depende de "compilar". Quando você executar "ant criar_jar" o
ant irá primeiro executar as tarefas de "compilar" para depois executar
"criar_jar". Mas se as classes já estiverem compiladas? Neste caso, o ant
vai verificar se a versão compilada é mais antiga, e compilará apenas as
classes alteradas.

# Propriedades
Ant permite que se defina propriedades no estilo java.util.Properties.
Propriedades podem ser definidas no próprio buildfile, em arquivo
.properties externo ou passados via linha de comando "-D". Propriedades
definidas como "nome" podem ser referenciadas como "${nome}".

# Exemplo de Buildfile
O buildfile abaixo pode ser usado e reusado em seus projetos. Se suas fontes
estiverem em um diretório "src", basta colocar este build.xml no diretório
que contém "src". Ele criará um diretório "classes" e depositará nele as
classes compiladas. (Se você não quiser usar "src" e "classes" basta mudar o
nome dos diretórios no <property>)

<?xml version="1.0" encoding="iso-8859-1" ?>

<project default="compile" name="Buildfile Generico">

  <property name="src.dir" value="src" />
  <property name="build.dir" value="classes" />

  <target name="init">
    <mkdir dir="${build.dir}" />
  </target>

  <target name="compile" depends="init" description="Compila classes>
    <javac srcdir="${src.dir}" destdir="${build.dir}">
      <classpath path="${build.dir}" />
    </javac>
  </target>

  <target name="clean" description="Remove classes compiladas">
    <delete dir="${build.dir}" />
  </target>

</project>

O buildfile acima possui 3 alvos. O alvo "compile" é default. Para executar
o Ant e compilar seus arquivos, mude para o diretório onde está o build.xml
e digite:

ant

Quando você executar "ant", o ant irá executar o "init", onde criará um
diretório "classes", e depois executará o "compile", onde compilará as
classes localizadas em "src" e as colocará no diretório "classes". Ele usará
como classpath o próprio diretório "classes". Você pode ter outros elementos
<classpath> apontando para outros diretórios, JARs, etc.

Para garantir que o ant só compile as classes que foram alteradas desde o
último build, coloque seus arquivos fonte dentro da estrutura de diretórios
compatível com suas declarações "package".

# Best practices
O Ant estimula a organização. Fica fácil manter seu codigo-fonte separado do
seu código compilado. Também fica fácil usar pacotes. Definir alvos curtos é
uma boa idéia porque eles podem ser reutilizados. Use um alvo "init" para
realizar qualquer inicialização necessária e tenha sempre um alvo "clean"
para remover o código gerado. Para executar uma tarefa específica, como o
"clean", digite:

ant clean

Isto é o suficiente para começar a usar o Ant (o difícil agora vai ser
deixar de usá-lo!) O manual que acompanha a ferramenta é muito bem escrito e
contém exemplos de cada elemento do buildfile. Procure na documentação se há
um plug-in para integrar o Ant com sua ferramenta de desenvolvimento ou IDE
favorito. Se houver, instale-o!

----------------------------------------

[]s
Helder.

--
Helder da Rocha ([EMAIL PROTECTED])
Web Consultant
www.argonavis.com.br
São Paulo, Brazil
+55 (11) 3044 4398
+55 (11) 9291 0567
_____________________________________________
Aumente sua produtividade e a qualidade do seu software!
- Aprenda a usar Ant, JUnit, HttpUnit, XDoclet e Cactus  -
Informações: www.argonavis.com.br/cursos/java/j820/




------------------------------ LISTA SOUJAVA ---------------------------- 
http://www.soujava.org.br  -  Sociedade de Usuários Java da Sucesu-SP 
dúvidas mais comuns: http://www.soujava.org.br/faq.htm
regras da lista: http://www.soujava.org.br/regras.htm
historico: http://www.mail-archive.com/java-list%40soujava.org.br
para sair da lista: envie email para [EMAIL PROTECTED] 
-------------------------------------------------------------------------

Responder a