Simplificando o Ant com o Eclipse

Escrever, desenvolver e depurar código no editor Ant facilmente

O Eclipse facilita o trabalhar com o Apache Ant. Descubra os recursos de integração do Ant no ambiente de desenvolvimento integrado (IDE) do Eclipse e saiba como compor, compilar e depurar código no Eclipse usando o editor Ant.

Prashant Deva, Founder, Placid Systems

Prashant DevaPrashant Deva é o fundador da Placid Systems e autor do plug-in ANTLR Studio para Eclipse. Fornece também consultoria relacionada ao ANTLR e ao desenvolvimento de plug-in do Eclipse. Escreveu vários artigos referentes ao ANTLR e aos plug-ins do Eclipse e, frequentemente, contribui ideias e relatórios de erro às equipes de desenvolvimento do Eclipse. Está atualmente ocupado com a criação da próxima ferramenta notável de desenvolvedor.



06/Fev/2012

Antes de iniciar

Sobre este tutorial

O Apache Ant é considerado o Santo Graal das ferramentas de criação no mundo de desenvolvimento Java™. A maioria dos projetos Java que valem a pena tem algum tipo de processo de criação customizado associado a ele na forma de um script de criação do Ant. Consequentemente, cada ferramenta Java de mérito tem algum tipo de suporte integrado para Ant. O Eclipse, um IDE favorito, não desaponta: fornece suporte integrado extensivo para Ant.

Saiba como fazer uso dos recursos presentes no Eclipse para compor e depurar arquivos do Ant, e como usar tais arquivos como construtores.

Pré-requisitos

Este tutorial pressupõe conhecimento básico em criação de scripts do Ant e trabalhar com a plataforma Eclipse.

Requisitos do Sistema

Para tentar os exemplos, é necessário ter o Eclipse SDK da Eclipse.org executando no Java Virtual Machine (JVM) V1.4 ou posterior. Faça download da tecnologia Java da Sun Microsystems ou da IBM.


Trabalhando com Ant

Criar um novo arquivo de criação Ant

Comece por incluir um novo arquivo Ant no seu projeto, que você usará para o resto do tutorial:

  1. Abra o Package Explorer
  2. Clique com o botão direito do mouse em um projeto Java e clique em New > File
  3. Na janela New File, digite build.xml como o nome do arquivo

O arquivo é criado e o editor Ant é aberto. Agora, inclua algum conteúdo no arquivo. Clique em qualquer parte no editor e pressione Ctrl+Barra de espaço. Uma proposta de conclusão contendo uma opção denominada Buildfile template -- é exibido um arquivo de criação simples com dois destinos (veja a Figura 1). Clique nesse arquivo para incluir um projeto de amostra contendo dois destinos no arquivo.

Figura 1. Usando o modelo de arquivo de criação

Agora que temos algum conteúdo, vamos examinar mais de perto o editor Ant.


O editor Ant

Descubra os melhores recursos do editor Ant: destaque, conclusão de código, compactação, renomeação e marcação de ocorrências e problemas.

Destaque

Para simplificar o uso, o editor mostra cada elemento do arquivo de criação em uma cor diferente. Os comentários aparecem em uma cor diferente dos atributos, e assim por diante. É possível customizar a cor de cada tipo de elemento.

Para alterar as cores de destaque, execute estas etapas:

  1. Clique em Window > Preferences > Ant > Editor
  2. Clique na guia Syntax
  3. Na página de resultado, selecione as cores de cada tipo de elemento

Conclusão de código

O editor Ant fornece funcionalidade de conclusão de código abrangente para ajudá-lo a digitar nos arquivos de criação Ant rapidamente. Clique em uma definição de destino, e pressione Ctrl+Barra de espaço para ver uma lista de todas as tarefas disponíveis. Depois de selecionar uma tarefa, o editor insere as tags de abertura e fechamento automaticamente (veja a Figura 2).

Figura 2. A lista de tarefas

Mas isso não é tudo. A capacidade de conclusão do código do editor do Ant vai bem mais além do que a inserção automática de tag. O editor está ciente dos destinos definidos no arquivo de criação. Assim, por exemplo, quando queremos inserir o nome de um destino -- digamos, digitar o atributo default de um projeto ou o atributo depends de um destino, pressionar Ctrl+Barra de espaço mostrará uma lista de destinos disponíveis que pode ser preenchido (veja a Figura 3).

Figura 3. Destinos disponíveis

O editor conhece as propriedades definidas no arquivo de criação. Assim quando estamos digitando o valor de um atributo, depois de digitar o $ (cifrão) inicial, é possível pressionar Ctrl+Barra de espaço para obter uma lista de todas as propriedades definidas no arquivo de criação e todas as prioridades do sistema (veja a Figura 4).

Figura 4. Lista das propriedades disponíveis

Outro recurso de conclusão de código no editor Ant são os Modelos de Código (veja a Figura 5). Usamos isso quando usamos o modelo de arquivo de criação para incluir conteúdo de amostra no arquivo de criação. Vários modelos estão disponíveis no editor Ant e, com eles, é possível inserir rapidamente definições de destino, definições de propriedade e mais. Observe que depois de aplicarmos um modelo, uma caixa aparecerá nas partes de texto em que o editor preencheu automaticamente (veja a Figura 6). Essas caixas são essencialmente para executar um tipo de preenchimento nos espaços em branco. Eles nos permitem digitar o texto, como o nome de um destino e sua dependência. É possível usar a tecla Tab para alternar entre os espaços em branco no modelo.

Figura 5. Modelos de código em ação
Figura 6. Aplicando modelos

Compactação

O editor Ant pode compactar todos os elementos Extensible Markup Language no arquivo de criação. Simplesmente, clique nos botões + ou - à esquerda para expandir ou reduzir os diversos elementos. Essa funcionalidade é útil porque com ela, podemos obter uma visão geral rápida do conteúdo do arquivo. Se passar o mouse sobre o ícone +, uma janela de contexto exibirá o conteúdo do elemento.

Renomeação

Um recurso realmente grande do editor Ant é o recurso Rename in File. Com tal recurso, é possível renomear os nomes de destino e de propriedade por todo o arquivo (veja a Figura 7). Digamos, por exemplo, que desejemos renomear um destino. Clique com o botão direito do mouse no nome e selecione Rename in file. Surgem caixas quadradas em todo o arquivo onde o nome de destino foi referenciado. Agora, podemos editar o nome do destino e a alteração será refletida em todo o arquivo. Esse recurso funciona igualmente para nomes de propriedades.

Figura 7. Renomeando um destino

Marcar ocorrências

Clicar no botão Toggle mark occurrences no alto ativa ou desativa o recurso Mark Occurrences. Com o recurso ativado, ao clicarmos no nome de qualquer destino ou propriedade, todas as ocorrências do destino ou propriedade em todo o arquivo são destacadas (veja a Figura 8).

Figura 8. Marcando ocorrências de um destino

Mostrando apenas os elementos selecionados

Clicar no botão Show selected elements only (veja a Figura 9) mostra apenas o elemento clicado. Essa funcionalidade é especialmente útil quanto temos de compor uma grande definição de destino, e não queremos nos deparar com nenhuma confusão. Podemos clicar nesse botão para fazer com que o resto dos elementos do arquivo desapareça -- permitindo, desse modo, que o enfoque fique no destino apenas.

Figura 9. Destino atual apenas

Marcando problemas

O editor Ant pode mostrar erros e avisos no nosso arquivo de criação enquanto digitamos. Isso ajuda a identificar precocemente erros e enganos potenciais em um arquivo de criação, em vez de descobrir posteriormente o porquê estamos obtendo erros misteriosos durante a compilação.

Para ver esse recurso em ação, acesse a tag project em build.xml. No valor do destino default, digite o nome de um destino que não exista no arquivo de criação. Uma tag project aparece sublinhada com um marcador de rabisco vermelho (veja a Figura 10). Passe o mouse sobre o marcador e uma janela aparecerá, declarando que o destino padrão não existe no projeto. Um ícone, um X vermelho, aparece à esquerda do marcador.

Figura 10. O editor Ant mostrando um erro

Observe também a barra no lado direito da janela do editor. Essa mostra todos os erros e avisos no arquivo. Assim que um erro ou aviso aparece no arquivo, um marcador vermelho ou amarelo correspondente é colocado no local aproximado na barra. Clique no marcador para navegar ao local do erro. Isso nos dará uma boa visão geral de onde e de quantos erros ou avisos estão presentes no arquivo, e poderemos navegar para eles facilmente. Há também um quadrado no alto da barra que fica vermelho quando há erros presentes no arquivo. Assim, apenas olhando para o quadrado, é possível determinar imediatamente se o arquivo está correto.

Podemos alterar o modo como o editor Ant manipula problemas executando estas etapas:

  1. Clique em Window > Preferences
  2. Expanda Ant e expanda o Editor
  3. Na janela Preferences, clique na guia Problems (veja a Figura 11).
    Figura 11. Configurando como os problemas aparecem no Ant
  4. Selecione nossas opções. Marcar a caixa de seleção Ignore all buildfile problems desativa a marcação de erro completamente. Por padrão, o Eclipse considera cada arquivo XML como um arquivo de criação Ant, assim ele tenta procurar erros neles. No entanto, se tiver alguns arquivos XMLs que não deseja que tenham seus erros verificados, especifique seus nomes em Names .

    Abaixo da caixa Names, veremos os tipos de erros que o editor Ant pode detectar, e é possível definir o nível de gravidade para cada um deles: Ignore, Warning e Error. Escolher Warning na lista ao lado do tipo de erro significa que o código pode criar problemas potenciais. Escolher Error indica tipos de problemas em que há definitivamente algum problema com o código. Se encontrar alguns problemas um pouco mais restritivos para o modo como você compõe código, poderá escolher Ignore, embora eu não recomende fazer isso.

OBSERVAÇÃO: A barra também funciona com o recurso Mark Occurrences. Ative Mark Occurrences e clique em qualquer nome de destino. A barra tem pequenos marcadores amarelos que correspondem ao local de cada referência. Clique nos marcadores para navegar para a referência.


Navegando no arquivo de criação

O Eclipse oferece vários métodos para ajudá-lo a navegar facilmente em grandes arquivos de criação. Os exemplos incluem navegação por hyperlink e tecla de função, além de duas visualizações: Outline e Ant.

Navegação por hyperlink e tecla de função

Pressione a tecla Ctrl e passe o mouse sobre o nome de qualquer destino ou propriedade. O nome se transforma em um hyperlink (veja a Figura 12). Clicar nesse hyperlink nos leva à declaração do destino ou propriedade.

Figura 12. A referência de destino se transforma em hyperlink

Também é possível pressionar F3 para acessar a declaração do destino ou propriedade. É possível mudar a tecla de atalho expandindo General e expandindo as teclas para acessar a página Keys preferences.

A visualização Outline

Como o nome sugere, a visualização Outline mostra a inteira estrutura de tópicos do arquivo de criação (consulte Figura 13). É possível ver facilmente todos os destinos e propriedades definidos no arquivo. Destinos internos e destinos públicos têm ícones diferentes, o que os torna fáceis de diferenciar. Inclusive o destino padrão está destacado. Expandir qualquer destino mostra todas as tarefas dentro dele. Clique em qualquer elemento na visualização Outline para navegar para ela diretamente. A visualização tem alguns botões no alto pelos quais é possível filtrar -- classificando os itens ou ocultando destinos internos, propriedades, elementos importados e elementos de nível superior.

Figura 13. A visualização Outline

É possível executar e depurar destinos corretamente na visualização Outline. Para fazer isso, clique com o botão direito do mouse em um destino na visualização Outline e clique em Run As (ou Debug As) > ANT Build.

A visualização Ant

Muitas vezes, você se pega a si mesmo trabalhando com vários scripts em vários projetos. Em vez de procurar arquivos de criação na visualização Navigator ou Package Explorer, ou vasculhar a lista de barras de ferramentas do External Tools, a equipe do Eclipse criou a visualização Ant para manter toda a confusão sob controle (veja a Figura 14).

Figura 14. A visualização Ant

Primeiro, abra a visualização Ant clicando em Window > Show View > Other > Ant > Ant. Quando é aberta pela primeira vez, a visualização está em branco, assim é necessário incluir alguns arquivos de criação nela. Clicar no botão + abre uma janela em que podemos selecionar nossos arquivos de criação entre os projetos abertos na área de trabalho. Execute um destino selecionando-o e clicando em Run ou clicando com o botão direito do mouse no destino e selecionando Run as > Ant Build.

Também é possível incluir arquivos de criação usando o recurso de procura do Ant. Clique no ícone Flashlight na barra de ferramentas, e uma janela aparecerá em que podemos especificar o nome do arquivo a ser procurado. Use caracteres especiais como * (asterisco) ou ? (ponto de interrogação) no nome do arquivo que representa qualquer cadeia de caractere ou qualquer caracter, respectivamente. Por exemplo, digitar build*.xml corresponde a todos os nomes de arquivos XML que começam com a palavra build. Se não selecionarmos a caixa de seleção Include buildfile containing errors, os arquivos que contêm erros não serão selecionados. Finalmente, podemos optar por procurar em todo o espaço de trabalho ou apenas dentro de um conjunto de trabalho.

Para remover um arquivo da visualização Ant, selecione-o e clique em Remove. Clique em Remove All para limpar toda a visão.

A diferença entre a visualização Ant e a visualização Outline

Muitas pessoas, quando olham a visualização Ant pela primeira vez, a confundem com a visualização Outline com vários arquivos. Mas há várias diferenças sutis entre as visualizações. Ao passo que a visualização Outline foi projetada para ajudar-nos a navegar para o arquivo atual, a visualização Ant permite-nos gerenciar a execução e depuração de vários destinos em vários scripts de criação que podem ser espalhados pela área de trabalho.

Essa diferença fundamental torna-se mais evidente quando olhamos de perto os recursos fornecidos nas duas visualizações:

  • É possível incluir vários arquivos na visualização Ant, ao passo que a visualização Outline mostra apenas estrutura de tópicos do arquivo atual.
  • Clicar duas vezes em um destino na visualização Outline permite-nos navegar para declaração correspondente no editor, mas fazer isso na visualização Ant realmente executa o destino.
  • A visualização Ant não mostra nenhuma propriedade ou elementos de nível superior porque não é possível "executar" propriedades.
  • Ambas as visualizações, Outline e Ant, contêm o botão Hide internal targets, em que podemos clicar para ocultar todos os destinos que não são públicos, mas as visualizações fornecem para propósitos diferentes. Assim, ao passo que a visualização Outline apresenta esse botão simplesmente como outro caminho para filtrar a visualização, a visualização Ant o apresenta porque, como estaremos executando normalmente apenas destinos públicos, faz sentido ocultar na visualização os destinos internos.

Depurando arquivos Ant

Sim, você leu corretamente. É possível realmente depurar arquivos Ant no Eclipse do mesmo modo como você depura arquivos Java, e ter todos os recursos de depuração padrão disponíveis. Essa é, provavelmente, a melhor funcionalidade na integração do Eclipse Ant.

Colocar pontos de interrupção dentro dos destinos

Exatamente como é feito com os arquivos Java, coloque pontos de interrupção dentro dos destinos nas linhas que chamam a tarefa em que estamos interessados navegar. Para colocar um ponto de interrupção em uma linha, simplesmente clique duas vezes ao lado da linha na barra cinza, à esquerda. Uma bola verde aparece, indicando que um ponto de interrupção foi definido (veja a Figura 15). Ative ou desative temporariamente pontos de interrupção clicando neles ou desativando-os na visualização Breakpoints. Um ponto de interrupção desativado aparece como uma bola branca. Observe que, diferente dos pontos de interrupção Java, não é possível definir contagem de ocorrência ou condições nos pontos de interrupção -- não que isso seja necessário durante a depuração dos arquivos Ant.

Figura 15. Definição de ponto de interrupção em uma linha no arquivo de criação

Depurar o arquivo de criação

Agora, iniciemos a depuração. Clique com o botão direito do mouse em um destino na visualização Ant ou na visualização Outline, e clique em Debug As > Ant Build. Exatamente como com os arquivos Java, o arquivo de criação pausa quando a execução atinge a linha em que configuramos o ponto de interrupção.

Esta é a grande parte: clique no botão Step Over na visualização Debug para navegar pelas linhas no arquivo de criação, assim como navegamos nas instruções Java (veja a Figura 16). À medida que avançarmos em cada tarefa, ela será executada e produzirá sua saída, o que poderemos examinar para ver o que está saindo de errado no processo de criação. A funcionalidade Run to Line também está disponível, assim é possível clicar com o botão direito do mouse em uma linha e selecionar Run to Line para fazer com que a execução do arquivo de criação continue até essa linha específica. O processo é similar a configurar um ponto de interrupção temporário em uma linha que seja removida assim que a linha for atingida.

Figura 16. Navegando linhas em um arquivo de criação

A visualização Debug mostra a pilha de chamadas das tarefas que atualmente estão sendo executadas. Se uma tarefa chamar outro destino -- digamos, antcall -- esse destino aparecerá acima da tarefa atual na pilha de chamadas.

A visualização Variables também está disponível (veja a Figura 17). Abra esta visualização para ver todas as propriedades do Ant, que são equivalentes às variáveis do Ant. As propriedades são mostradas agrupadas nas três partes:

  • System properties: propriedades definidas no sistema para a criação
  • User properties: propriedades como as definidas usando a opção -D
  • Runtime properties: propriedades definidas em um arquivo de criação que estão definidas durante o tempo de execução
Figura 17. A visualização Variables mostra todas as propriedades

Observe que diferente do depurador Java, o depurar Ant não permite a alteração do valor das propriedades mostradas na visualização Variables.


Usando o arquivo de criação Ant como um construtor de projeto

Ao usarmos o Eclipse Java IDE, usando o Java Builder inconscientemente. O Java Builder é um animal de carga silencioso que executa em segundo plano cada vez que salvamos os arquivos, e eles são compilados instantaneamente.

Embora pareça não ser um grande negócio, ele é um dos recursos mais surpreendentes do Eclipse: o Java Builder permite ignorar o processo de compilação no geral porque o programa está sempre em um estado compilado, embora possa estar cheio de erros. Assim, é possível executar nossos programas Java imediatamente depois de digitá-los, sem passar primeiro por uma etapa de compilação longa e tediosa. Essa funcionalidade economiza um monte de tempo e aborrecimento para os usuários do Eclipse e é um dos motivos da grande popularidade do Eclipse entre programadores.

Mas e se quisermos fazer algo mais do que simplesmente compilar arquivos? E se quisermos criar um arquivo jar para o projeto inteiro e copiá-lo para determinado diretório cada vez que fizermos alterações em um projeto? E se quisermos que tudo isso aconteça em segundo plano, sem ter que informar isso ao Eclipse cada vez? Podemos simplesmente sentar, relaxar, compor algum código, dar um gole no café e permitir que o Eclipse gerencie o complexo processo de criação no segundo plano, sem a necessidade de sabermos o que realmente está acontecendo.

Parece um sonho? Não é. Podemos realmente fazer com que isso aconteça. Simplesmente precisamos incluir um arquivo de criação do Ant, que tem toda a complexidade do processo de criação definido nele, em nosso projeto como um "construtor". Faça isso, e a mágica se iniciará.

Por que usar o Ant como um construtor de projeto?

Suponha que tenhamos um arquivo de criação Ant que crie um arquivo jar fora dos arquivos de classe no projeto e o coloque na raiz do projeto. (O conteúdo exato do arquivo de criação é irrelevantes por ora.) Queremos que o arquivo de criação execute cada vez que um arquivo Java for modificado, de modo que o arquivo jar sempre permaneça atualizado. Execute estas etapas:

  1. Clique com o botão direito do mouse na visualização Package Explorer e clique em Properties.
  2. Expanda Builders e clique em New para incluir um novo construtor no projeto.
  3. Na janela resultante, selecione Ant Build e clique em OK.
  4. A janela Properties do construtor aparecerá (veja a Figura 18). Aqui, configure um construtor.
    Figura 18. A janela de configuração do construtor
  5. Na caixa Name, digite MyBuilder.
  6. Clique em Browse Workspace abaixo de Buildfile e selecione o projeto de criação do projeto.
  7. Clique em Browse Workspace abaixo de Base Directory e selecione o projeto que contém o arquivo de criação. Forneça argumentos no arquivo de criação, mas porque não precisamos fornecer nenhum direito agora, deixe o arquivo em branco.
  8. Clique na guia Refresh (veja a Figura 19).
    Atualizar um projeto instrui o Eclipse Workbench a procurar qualquer atualização feita no sistema de arquivos local por ferramentas externas como o Ant. Assim, aqui, informe ao Eclipse se deseja executar uma atualização depois de um script de criação terminar e, se desejar, que partes da área de trabalho devem ser atualizadas.
    Figura 19. Guia Refresh
  9. Selecione a caixa de seleção Refresh resources upon completion. Isso habilitará as opções debaixo dela na guia. Informe ao Eclipse quanto da área de trabalho atualizar. Selecione a menor entidade suficiente para que nosso ambiente de trabalho continue a executar rapidamente. Para este exemplo, precisamos apenas atualizar o projeto atual, assim, selecione a opção The project containing the selected resource.
  10. Clique no ícone Targets .
    Figura 20. Guia Targets

    Aqui, escolhemos quando o arquivo de criação realmente executa e, mais especificamente, que destino está em execução. Quatro opções estão disponíveis:
    • After a "Clean" -- O destino executa cada vez que executamos uma operação de limpeza no projeto.
    • Manual Build -- Esta opção é usada quando as construções automáticas estão desativadas. Sempre que executarmos uma criação manual, o destino especificado será executado.
    • Auto-Build -- O destino executa cada vez que uma autocriação é executada. Normalmente, isso ocorre cada vez que salvamos nossos arquivos Java.
    • During a "Clean" -- Esta opção é diferente de After a "Clean" em que o destino é chamado durante a operação de limpeza em si. Use esta opção para executar alguma limpeza customizada de arquivos durante a operação de limpeza.
  11. Defina o destino a ser executado. Cada uma das opções de destino tem um botão Set Targets ao lado com o qual é possível configurar o destino a ser executado durante cada operação. Geralmente, selecione o destino padrão aqui, mas é possível selecionar qualquer destino -- inclusive, vários destinos -- assim como a ordem em que devem executar.
  12. Defina os destinos a serem executados ao lado de qualquer operação que desejamos que o arquivo de criação execute.
    Neste caso, como desejamos que o arquivo jar esteja sempre atualizado, defina os destinos para as operações After a "Clean" e Auto Build. Para fazer isso, clique em Set Targets e selecione os destinos a serem executados. Se você vir destinos definidos para qualquer outra operação, com Manual Build, clique em Set Targets e desmarque as caixas de seleção dos destinos a serem desativados no arquivo de criação de executar durante tais operações.

    Observe também que, embora tenhamos optado, para este exemplo, executar o destino depois de cada operação Auto Build, devemos geralmente usar essa opção com cuidado porque o Workbench pode desacelerar até parar se o processo de criação demorar um longo tempo. Geralmente, defina apenas as opções Manual Build e After a "Clean".
  13. Clique em OK.

Agora, é o momento de testar nosso construtor recém-incluído. Abra qualquer arquivo Java no projeto, faça algumas modificações (por exemplo, insira um espaço) e salve. A Auto Build será executada e veremos no console que o arquivo de criação está executando no destino selecionado. O arquivo jar é construído e aparece na visualização Navigator e Package Explorer. Tudo isso acontece automaticamente, cada vez.


Conclusão

Você viu que o Eclipse fornece um ambiente sofisticado para composição, depuração e navegação de scripts de criação Ant. Permite inclusive que você use o Ant como um construtor de projeto de modo que os arquivos Ant possam executar automaticamente no segundo plano. Você está agora pronto para começar a produzir em grande escala scripts de criação no Eclipse.

É recomendável explorar por si mesmo os recursos descritos acima compondo um script de criação do Ant usando-o como um construtor de projeto. Além disso, não se esqueça de manter o manual de referência do Ant à mão para examinar as descrições de todas as tarefas disponíveis quando você compõe scripts de desenvolvimento.

Recursos

Aprender

Obter produtos e tecnologias

Discutir

Comentários

developerWorks: Conecte-se

Los campos obligatorios están marcados con un asterisco (*).


Precisa de um ID IBM?
Esqueceu seu ID IBM?


Esqueceu sua senha?
Alterar sua senha

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


A primeira vez que você entrar no developerWorks, um perfil é criado para você. Informações no seu perfil (seu nome, país / região, e nome da empresa) é apresentado ao público e vai acompanhar qualquer conteúdo que você postar, a menos que você opte por esconder o nome da empresa. Você pode atualizar sua conta IBM a qualquer momento.

Todas as informações enviadas são seguras.

Elija su nombre para mostrar



Ao se conectar ao developerWorks pela primeira vez, é criado um perfil para você e é necessário selecionar um nome de exibição. O nome de exibição acompanhará o conteúdo que você postar no developerWorks.

Escolha um nome de exibição de 3 - 31 caracteres. Seu nome de exibição deve ser exclusivo na comunidade do developerWorks e não deve ser o seu endereço de email por motivo de privacidade.

Los campos obligatorios están marcados con un asterisco (*).

(Escolha um nome de exibição de 3 - 31 caracteres.)

Ao clicar em Enviar, você concorda com os termos e condições do developerWorks.

 


Todas as informações enviadas são seguras.


static.content.url=http://www.ibm.com/developerworks/js/artrating/
SITE_ID=80
Zone=Software livre, Tecnologia Java
ArticleID=973493
ArticleTitle=Simplificando o Ant com o Eclipse
publish-date=02062012