Anda di halaman 1dari 17

Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Criando, importando e configurando projetos Java


Este guia fornece uma visão geral do principais recursos do NetBeans IDE para instalar e configurar projetos Java. Além disso, ele fornece
informações sobre como efetuar a configuração personalizada de scripts de construção gerados pelo IDE.

Para concluir este tutorial, você precisa dos seguintes recursos e softwares.

Conteúdo

Conceitos básicos do projeto

Projetos

Ant

Criando um projeto

Importando um projeto

Importando em espaço de trabalho Eclipse

Configurando um projeto Java com base em código-fonte existente

Configurando um projeto JavaFX com base em código-fonte existente

Configurando um projeto Web com base em código-fonte existente

Projetos de forma livre

Configurando o classpath e outras definições do projeto

Definindo o projeto principal

Configurando o JDK de destino de um projeto

Gerenciando o classpath do projeto

Gerenciando dependências entre projetos

Compartilhando bibliotecas do projeto

Tornando o Javadoc do JDK disponível no IDE

Habilitando o Java Web Start

Construindo aplicativos

Construindo projetos, pacotes e arquivos

Compilar ao salvar

Corrigindo erros de compilação

Filtrando arquivos de saída

Executando aplicativos

Executando projetos e arquivos

Personalizando as opções em tempo de execução

Definindo o classpath de tempo de execução

Definindo a classe principal e os argumentos de tempo de execução

Definindo os argumentos JVM

Personalizando o script de construção

Editando e executando scripts do Ant

Escrevendo tarefas personalizadas do Ant

Consulte também

Software ou recurso Versão necessária

NetBeans IDE versão 6.5, 6.7 ou 6.8

1 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

versão 6 ou
Java Development Kit (JDK)
versão 5

Conceitos básicos do projeto


Esta seção fornece uma visão geral de algumas informações de segundo plano sobre o sistema de projeto do IDE.

Projetos
No IDE, você sempre trabalha dentro de um projeto. Além dos arquivos de código-fonte, um projeto do IDE contém metadados que
pertencem no classpath, como construir e executar o projeto, e assim por diante. O IDE armazena as informações do projeto em uma
pasta do projeto que inclui um script de construção do ANT e um arquivo de propriedades que controla a construção e as configurações
de execução, e um arquivo project.xml que mapeia os alvos do Ant com comandos do IDE.

Nota: embora o IDE coloque diretórios de código-fonte na pasta de projeto por padrão, seus diretórios de código-fonte não
necessariamente precisam estar localizados na pasta do projeto.

Ant
Apache Ant é uma ferramenta de compilação usada para padronizar e automatizar compilação e executar ambientes para
desenvolvimento. O sistema do projeto do IDE tem base direta no Ant. Todos os comandos do projeto, como Limpar e construir o
projeto e Depurar, chamam alvos no script do Ant do projeto. Portanto, você pode construir e executar um projeto fora do IDE,
exatamente como é construído e executado dentro do IDE.

Não é necessário saber como trabalhar no Ant com o IDE. Você pode definir todas as opções básicas de compilação e tempo de
execução na caixa de diálogo Propriedades do projeto no projeto e o IDE atualiza automaticamente o script do Ant do projeto. Se você
está familiarizado com o Ant, poderá personalizar um script padrão do Ant do projeto ou escrever seu próprio script do Ant para um
projeto.

Criando um projeto
Para criar um novo projeto:

Escolha Arquivo > Novo projeto (Ctrl-Shift-N).

Quando o assistente para Novo projeto aparecer, selecione o modelo correto para seu projeto e complete as etapas restantes do
assistente. Na versões mais recentes do NetBeans IDE 6.7, o ícone do modelo do projeto pode ser exibido em cinza, o que significa que
este tipo de projeto não foi ativado. Prossiga com a criação do projeto e esta funcioncionalidade será ativada no IDE.

O IDE contém os seguintes modelos de projeto padrão para aplicativos Java da área de trabalho e da Web:

Aplicativo Java. Cria um projeto esqueleto Java SE com uma classe principal. Consulte Desenvolvendo e implementando
aplicativos Java gerais para obter um breve tutorial que usa este modelo.

Aplicativo Java da área de trabalho. Cria um aplicativo com base no Swing Application Framework. Os esqueletos são
oferecidos para aplicativos básicos da área de trabalho, que fazem uso das bibliotecas Beans Binding e Java Persistence API.
Consulte Construindo um aplicativo Java de banco de dados da área de trabalho para obter um exemplo que usa este modelo.

Biblioteca de classes Java. Cria uma biblioteca de classes esqueleto Java sem uma classe principal. Consulte Desenvolvendo e
implementando aplicativos Java gerais para obter um breve tutorial que usa este modelo.

Projeto Java com código-fonte existente. Cria um projeto Java SE com base em seu próprio código-fonte Java. Consulte
Configurando um projeto Java com base em código-fonte existente abaixo.

Aplicativo Web. Cria um aplicativo Web esqueleto, incluindo opções para adicionar diversos frameworks Web. Consulte
Introdução ao desenvolvimento de aplicativos Web para obter um exemplo que usa este modelo.

Aplicativo Web com código-fonte existente. Cria um projeto Web com base em seu próprio código-fonte Web e Java.
Consulte Configurando um projeto Web com base em código-fonte existente abaixo.

Além disso, o IDE também contém modelos para módulos EJB, aplicativos corporativos, aplicativos Java ME, e mais.

As categorias de projetos Java e Web também têm modelos de projeto de formato livre. Os modelos de formato livre permitem o uso de

2 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

um script do Ant existente para um projeto, mas requerem a configuração manual. Consulte Projetos de formato livre abaixo.

Quando você termina de criar um projeto, ele é aberto no IDE com sua estrutura lógica exibida na janela Projetos e sua estrutura de
arquivo exibida na janela Arquivos.

A janela Projetos é o ponto de entrada principal para as fontes do projeto. Ela mostra uma visualização lógica do conteúdo
importante do projeto como pacotes Java e páginas da Web. É possível clicar com o botão direito do mouse em qualquer nó do
projeto para acessar um menu suspenso de comandos para construir, executar e depurar o projeto, bem como abrir a caixa de
diálogo Propriedades do projeto. A janela Projetos pode ser aberta ao escolher Janela > Projetos (Ctrl-1)

A janela Arquivos mostra uma visualização de seus projetos com base em diretório, incluindo arquivos e pastas que não são
exibidos na janela Projetos. A partir da janela Arquivos, você pode abrir e editar seus arquivos de configuração do projeto, como o
script de construção do projeto e o arquivo de propriedades. Você também pode visualizar a saída da construção como classes
compiladas, arquivos JAR, arquivos WAR e documentação Javadoc gerada. A janela Arquivos pode ser aberta ao escolher Janela >
Arquivos (Ctrl-2)

Nota: se for necessário acessar os arquivos e diretórios que estejam fora de seus diretórios do projeto, é possível usar a janela
Favoritos. A janela Favoritos pode ser aberta ao escolher Janela > Favoritos (Ctrl-3). Você pode adicionar qualquer pasta ou
arquivo à janela Favoritos clicando com o botão direito do mouse na janela Favoritos e escolhendo Adicionar aos favoritos.

Importando um projeto
Esta seção mostra como manusear a importação inicial de projetos para o IDE.

Importando em espaço de trabalho Eclipse


Para projetos Eclipse, você pode usar o assistente Importar projeto Eclipse para ajudá-lo a criar projetos NetBeans a partir de projetos
em um espaço de trabalho Eclipse e para importar classpaths do projeto e outras configurações. Quando você usa o assistente
Importar projeto Eclipse, não é necessário usar manualmente criar e configurar o projeto NetBeans. Abra o assistente ao escolher
Arquivo > Importar projeto > Projeto Eclipse. Consulte Importando projetos Eclipse no NetBeans IDE. para obter informações sobre
como funciona o assistente e como você pode trabalhar simultaneamente em projetos Eclipse e NetBeans.

Configurando um projeto Java com base em código-fonte existente


Para outros projetos Java desenvolvidos fora do NetBeans, é possível usar o modelo "Código-fonte existente" no assistente Novo

3 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Projeto para criar um projeto NetBeans. No assistente, você identifica a localização do código-fonte e especifica a localização para os
metadados do projeto NetBeans. Você então usa a caixa de diálogo Propriedades do projeto para configurar o projeto.

Para configurar um projeto NetBeans para um aplicativo Java existente:

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N).

2. Escolha Java > Projeto Java com código-fonte existente. Clique em Próximo.

3. Na página Nome e Localização do assistente, siga estas etapas:


Digite um nome de projeto.

(Opcional) Altere a localização da pasta do projeto.

(Opcional) Altere o nome do script de construção usado pelo IDE. Isso pode ser desejável se já houver um script
denominado como build.xml que é usado para construir o código-fonte.

(Opcional) Selecione a caixa de verificação Usar pasta dedicada para armazenamento de bibliotecas e especifique o local
da pasta de bibliotecas. Consulte Compartilhando bibliotecas do projeto para obter mais informações sobre esta opção.

(Opcional) Selecione a caixa de seleção Definir como projeto principal. Quando você seleciona esta opção, os atalhos de
teclado para os comandos como Limpar e construir o projeto principal (Shift-F11) se aplicam à este projeto.

4. Clique em Próximo para avançar para a página Código-fonte existentes do assistente.

5. No painel Pasta de pacotes de código-fonte clique em Adicionar pasta. A seguir, navegue para seu código-fonte e selecione as
raízes do código-fonte.
Quando você adiciona uma pasta contendo o código-fonte, é preciso adicionar a pasta que contém a pasta mais alta em sua
árvore do pacote. Por exemplo, para o pacote com.mycompany.myapp.ui , você adiciona a pasta que contém a pasta com.

6. (Opcional) No painel Pastas de pacote de teste, clique em Adicionar pasta para selecionar a pasta contendo as pastas do pacote
JUnit.

7. (Opcional) Na página Inclui e exclui do assistente, insira os padrões do nome do arquivo somente para os arquivos que
deveriam ser incluídos ou excluídos do projeto. Por padrão, todos os arquivos em suas raízes de código-fonte são incluídos.

8. Clique em Terminar.
O projeto será exibido nas janelas Projetos e Arquivos.

Configurando um projeto JavaFX com base em código-fonte existente


Você cria uma projeto JavaFX a partir de um aplicativo JavaFX desenvolvido fora do NetBeans IDE. Esta opção funciona se você tem o
plug-in JavaFX instalado ou se está usando a opção de download do JavaFX do IDE.

Para configurar um projeto NetBeans para um aplicativo Java existente:

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N).

2. Escolha Java > Aplicativo de script JavaFX e clique em Próximo.

3. Na página Nome e Localização do assistente, siga estas etapas:


Digite um nome de projeto.

(Opcional) Especifique a localização da pasta do projeto.

Selecione o botão de opção De código-fonte.

Clique em Adicionar pasta e especifique a pasta que contém seus arquivos de código-fonte de aplicativo JavaFX
existente.

(Opcional) Selecione a caixa de seleção Definir como projeto principal. Quando você seleciona esta opção, os atalhos de
teclado para os comandos como Limpar e construir o projeto principal (Shift-F11) se aplicam à este projeto.

4. Clique em Terminar.
O projeto Java FX será exibido nas janelas Projetos e Arquivos.

4 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Configurando um projeto Web com base em código-fonte existente


Para projetos Web desenvolvidos fora do NetBeans, é possível usar o modelo "Código-fonte existente" no assistente Novo Projeto para
criar um projeto NetBeans. No assistente, você identifica a localização do código-fonte e especifica a localização para os metadados do
projeto NetBeans. Você então usa a caixa de diálogo Propriedades do projeto para configurar o projeto.

Nota: se o projeto foi originalmente desenvolvido no Eclipse, é possível economizar tempo ao usar o assistente Importar
projeto Eclipse ao invés do assistente Novo projeto. O assistente Importar projeto Eclipse permite importar simultaneamente
múltiplos projetos, incluindo suas configurações. Consulte Importando projetos Eclipse no NetBeans IDE.

Para configurar um projeto NetBeans para um aplicativo Web existente:

1. Escolha Arquivo > Novo projeto (Ctrl-Shift-N).

2. Escolha Java Web > Aplicativo Java com código-fonte existente. Clique em Próximo.

3. Na página Nome e Localização do assistente, siga estas etapas:


No campo Localização, insira a pasta que contém as pastas raízes do código-fonte do aplicativo Web e as pastas da
página Web.

Digite um nome de projeto.

(Opcional) Altere a localização da pasta do projeto.

4. (Opcional) Selecione a caixa de verificação Usar pasta dedicada para armazenamento de bibliotecas e especifique o local da
pasta de bibliotecas. Consulte Compartilhando bibliotecas do projeto no NetBeans IDE para obter mais informações sobre esta
opção.

5. (Opcional) Selecione a caixa de seleção Definir como projeto principal. Quando você seleciona esta opção, os atalhos de teclado
para os comandos como Limpar e construir o projeto principal (Shift-F11) se aplicam à este projeto.

6. Clique em Próximo para avançar para a página Servidor e configurações do assistente.

7. (Opcional) Adicione projeto em um projeto corporativo existente.

8. Selecione um servidor no qual implementar. Se o servidor que você deseja não aparece, clique em Adicionar para registrar o
servidor no IDE.

9. (Opcional) Selecione a pasta de biblioteca dedicada para a caixa de seleção Arquivos JAR do servidor. Esta opção somente está
disponível se você designou uma pasta dedicada para bibliotecas na página anterior do assistente.

10. Defina o nível do código-fonte para a versão Java na qual deseja que o aplicativo seja executado.

11. (Opcional) Ajuste o caminho do contexto. Por padrão, o caminho do contexto tem base no nome do projeto.

12. Clique em Próximo para avançar para a página Código-fonte existentes e bibliotecas do assistente.

13. Verifique todos os campos na página, como os valores para a Pasta de páginas Web e Pastas do pacote do código-fonte.

14. Clique em Terminar.


O projeto será exibido nas janelas Projetos e Arquivos.

Projetos de formato livre


Também há modelos de projeto disponíveis para projetos de formato livre. Em projetos de formato livre, o IDE usa alvos em um script
do Ant existente para construir, executar, limpar, testar e depurar seu aplicativo. Se um script do Ant não contém alvos para algumas
destas funções, as funções estão indisponíveis para o projeto. Para implementar estas funções, você escreve alvos em seu script do Ant
ou em um script secundário do Ant.

Em geral, é melhor usar modelos padrão de projeto "com códigos-fonte existentes" para importar projetos. Para projetos Eclipse, é
melhor usar o recurso Importar projeto, que cria e configura um projeto padrão por você. Os projetos padrão são mais fáceis de
serem mantidos no longo prazo. No entanto, os modelos de projeto de formato livre são úteis se você tiver um projeto existente com
base no Ant com uma configuração complexa ou idiosincrática, que não pode ser duplicado dentro de um projeto padrão. Por exemplo,
se você estiver importando um projeto com múltiplas raízes de código-fonte, cada um tendo um classpath diferente, e se não puder
dividir as raízes de código-fonte em diferentes projetos, pode ser necessário usar um modelo de projeto de formato livre.

5 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Este guia foca em projetos padrão. Para obter mais informações sobre como configurar projetos de formato livre, consulte
Configuração avançada de projeto de formato livre

Configurando o classpath e outras definições do projeto


Esta seção cobre as tarefas mais comuns para configurar um projeto, como a configuração do JDL alvo do projeto, a configuração do
classpath, a criação de dependências entre projetos, e o compartilhamento de bibliotecas entre projetos e usuários.

Definindo o projeto principal


Quando você desenvolve um aplicativo grande que consiste em diversas pastas de código-fonte, é comum dividir o seu código em
projetos separados. Normalmente, um destes projetos serve como o ponto de entrada para seu aplicativo. Para informar ao IDE qual
projeto é o ponto de entrada principal do aplicativo, defina um projeto como o projeto principal. O IDE fornece comandos que agem no
projeto principal. Por exemplo, a execução do comando Limpar e construir o projeto principal, constrói o projeto principal e todos os
seus projetos necessários.

Para definir um projeto como o projeto principal:

Clique com o botão direito do mouse no nó do projeto na janela Projetos, escolha Definir como o projeto principal.

Somente um projeto pode ser o projeto principal de cada vez.

Configurando o JDK de destino de um projeto


No IDE, você pode registrar várias plataformas Java e anexar Javadoc e código-fonte a cada plataforma. Alternar o JDK de destino de
um projeto padrão faz o seguinte:

Oferece as novas classes do JDK de destino para o auto-completar de código.

Se disponível, exibe o código-fonte do JDK de destino e a documentação do Javadoc.

Usa os executáveis do JDK de destino ( javac e java ) para compilar e executar a aplicação.

Compila o código-fonte nas bibliotecas do JDK de destino.

Por padrão, o IDE usa a versão da plataforma Java SE (JDK), na qual o IDE é executado como a plataforma Java padrão para
projetos IDE. Você pode visualizar a versão do JDK do IDE escolhendo Ajuda > Sobre e clicando na aba Detalhe. A versão do JDK é
listada no campo Java.

Para executar o IDE com uma versão diferente do JDK:

Inicie o IDE com a seguinte chave a partir da linha de comando.

--jdkhome jdk-home-dir

Alternativamente, defina o JDK no arquivo /etc/netbeans.conf que está localizado na pasta de instalação do IDE.

Para registrar uma nova plataforma Java:

1. Escolha Ferramentas > Gerenciador da plataforma Java, a partir do menu principal.

2. Especifique a pasta que contém a plataforma Java, assim como o código-fonte e o Javadoc necessário para a depuração.

6 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Para alternar o JDK alvo de um projeto padrão:

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.

2. Selecione o painel Bibliotecas.

3. Altere a propriedade Plataforma Java.

Gerenciando o classpath do projeto


A adição de um grupo de arquivos de classe a um classpath de projeto informa o IDE das classes a que o projeto deve ter acesso
durante a compilação e a execução. O IDE também use configurações de classpath para ativar o auto-completar de código, o realce
automático de erros de compilação e a refatoração. Você pode editar todas as declarações do classpath de um projeto existente na
caixa de diálogo Propriedades do projeto.

Em projetos padrão Java, o IDE mantém classpaths separados para compilar e executar seu projeto, assim como para compilar e
executar testes JUnit (para aplicativos Java SE). O IDE adiciona automaticamente tudo no classpath de compilação do projeto ao
classpath do tempo de execução do projeto.

Você pode modificar o classpath de seu projeto de uma das seguintes formas:

Clique com o botão direito do mouse no nó do projeto, selecione a categoria Bibliotecas, e modifique as entradas de classpath
listadas.

Clique com o botão direito do mouse no nó Bibliotecas na janela Projetos e escolha Adicionar projeto, Adicionar biblioteca ou
Adicionar JAR/Pasta.

Se houver arquivos de Javadoc e arquivos de origem anexados a um arquivo JAR no Gerenciador de bibliotecas, o IDE adicionará
automaticamente os arquivos de Javadoc e os arquivos de origem ao projeto, quando você registrar o arquivo JAR em um classpath do
projeto. Você pode entrar nas classes e procurar as páginas de Javadoc das classes sem configurar nada mais.

7 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Gerenciando dependências entre projetos


Se seu aplicativo consiste em múltiplos projetos, terá que configurar as dependências de classpath entre os projetos. Normalmente,
você configura um projeto principal contendo a classe do projeto principal (em projetos Java SE) e diversos projetos necessários. Um
projeto requerido é um projeto que foi adicionado a outro classpath de projeto. Toda vez que limpa e constrói um projeto, o IDE
também limpa e constrói os projetos necessários. O Javadoc e o código-fonte do projeto necessário também são disponibilizados para o
projeto recebedor.

Você pode adicionar quaisquer projetos necessários para eu projeto ao clicar com o botão direito do mouse no nó Bibliotecas, ou pode
adicioná-los ao especificá-los na aba Bibliotecas na caixa de diálogo Propriedades do projeto. Quando você deseja adicionar um projeto
necessário, selecione a pasta do projeto com os arquivos JAR que deseja adicionar ao classpath (o seletor de arquivos exibe o ícone
para as pastas do projeto IDE ( ). Ao adicionar projetos na caixa de diálogo Propriedades do projeto, assegure que a caixa de
seleção Construir projetos no classpath esteja selecionada.

Se você deseja adicionar um projeto de formato livre para o classpath de um projeto padrão, terá que adicionar o arquivo JAR do
projeto de formato livre para o classpatth do projeto padrão. Para fazer isso, primeiro é preciso declarar todos os arquivos de saída do
projeto de formato livre no painel Saída da caixa de diálogo Propriedades do projeto do projeto de formato livre.

Compartilhando bibliotecas do projeto


Como o sistema do projeto NetBeans IDE é baseado em Ant, os projetos do NetBeans já são geralmente transferíveis entre usuários
diferentes, independentemente de eles usarem o IDE ou não. Entretanto, por padrão, a forma pela qual o script de construção do
projeto se refere às bibliotecas depende de vários fatores específicos para cada usuário, particularmente no caso de bibliotecas
definidas na caixa de diálogo Gerenciador de bibliotecas.

Por exemplo, normalmente você pode colocar um projeto em um arquivo zip e dar o mesmo para que outro usuário o desempacote e
o execute. Mas se o projeto depende de uma biblioteca personalizada especificada na caixa de diálogo Gerenciador de bibliotecas,
outros podem ter inicialmente problemas para construir o projeto por causa das referências não solucionadas para a biblioteca
personalizada.

Outra inconveniência potencial é que as bibliotecas são armazenadas em uma variedade de locais, com base em sua origem. As

8 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

bibliotecas que vêm com o IDE são armazenadas em várias pastas diferentes na instalação do IDE. Os exemplos disso incluem as
bibliotecas das extensões de layout do Swing, vinculação de beans e drivers de banco de dados.

Para solucionar estes problemas, você pode especificar uma pasta dedicada para bibliotecas do projeto. Além disso, você decide entre
usar um caminho relativo ou caminho absoluto ao se referir a essas bibliotecas.

Essa flexibilidade torna mais fácil para você manipular as seguintes situações:

Você cria um projeto e precisa torná-lo disponibilizável e construível para outros usuários, independentemente de eles usarem o
IDE ou não. Eles precisam ser capazes de acessar o projeto através de um checkout de controle de versão ou descompactando
um arquivo zip que você forneceu para eles. Eles devem ser capazes de construir o aplicativo sem configuração extra.

Você deve começar a trabalhar em um projeto existente e aderir a um conjunto estrito de convenções relacionadas a onde as
bibliotecas do projeto são armazenadas (e se os seus scripts de construção os acessam com uma referência relativa ou
referência absoluta).

Você pode definir uma pasta de bibliotecas dedicadas para projetos padrão Java SE, Web e Corporativo. Você pode definir a pasta de
bibliotecas ao criar o projeto (no assistente para Novo projeto) ou depois na aba Bibliotecas da caixa de diálogo Propriedades do
projeto.

Para tornar as bibliotecas gerais do projeto Java compartilháveis durante a criação do projeto:

1. Escolha Arquivo > Novo projeto.

2. Na categoria Java do assistente, selecione um dos modelos padrão. Em seguida clique em Próximo.

3. Na página Nome e localização do assistente, marque a caixa de verificação Usar pasta dedicada para armazenar bibliotecas.

4. No campo Bibliotecas, selecione a localização das bibliotecas a serem compartilhadas.


Se as bibliotecas já estiverem incluídas no IDE, elas serão copiadas para a pasta que você designou.

Para tornar as bibliotecas do projeto Java EE ou da Web compartilháveis durante a criação do projeto:

1. Escolha Arquivo > Novo projeto.

2. Na categoria Web do assistente, selecione um dos modelos padrão. Em seguida clique em Próximo.

3. Na página Nome e localização do assistente, marque a caixa de verificação Usar pasta dedicada para armazenar bibliotecas.

4. No campo Bibliotecas, selecione a localização das bibliotecas a serem compartilhadas.


Se as bibliotecas já estiverem incluídas no IDE, elas serão copiadas para a pasta que você designou.

5. (Opcional) Na página Servidor e configurações, selecione o botão de opção Copiar arquivos JAR do servidor para a pasta
Bibliotecas.

Para tornar as bibliotecas de um projeto existente compartilháveis:

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.

2. Na caixa de diálogo Propriedades do projeto, selecione o nó Bibliotecas.

3. No painel Bibliotecas, clique em Procurar para abrir o assistente para Nova pasta Bibliotecas.

4. Na página Pasta Biblioteca do assistente, indique uma localização para as bibliotecas e clique em Próximo.
Você pode indicar a localização como uma referência relativa ou uma referência absoluta.

5. No painel Ações do assistente, verifique a ação selecionada para cada biblioteca listada. Na maioria dos casos, o IDE detecta a
ação mais apropriada para essa biblioteca.
As ações seguintes estão disponíveis:
Copiar arquivos JAR da biblioteca para a nova pasta de bibliotecas. Use esta opção se a biblioteca não estiver
na pasta que selecionou e você deseja colocar os arquivos JAR aí.

Usar caminho relativo para arquivos JAR da biblioteca. Use essa opção se a biblioteca não estiver na pasta de
bibliotecas e você precisa acessar a biblioteca em sua localização existente usando um caminho relativo. Uma entrada
com uma referência relativa é adicionada para a biblioteca no arquivo nblibraries.properties da pasta de bibliotecas.

9 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Usar caminho absoluto para arquivos JAR da biblioteca. Use essa opção se a biblioteca não estiver na pasta de
bibliotecas e você precisar acessar a biblioteca em sua localização existente usando um caminho absoluto. Uma entrada
com uma referência absoluta é adicionada para a biblioteca no arquivo nblibraries.properties da pasta das
bibliotecas.

Usar biblioteca existente na pasta de bibliotecas. Use essa opção se já houver uma cópia da biblioteca na pasta
de bibliotecas e você deseja usar essa cópia da biblioteca.

6. Clique em Terminar para sair do assistente para Tornar projeto compartilhável.

7. Clique em OK para sair da caixa de diálogo Propriedades do projeto.

Nota: você também pode usar o nó Bibliotecas da caixa de diálogo Propriedades do projeto para alterar a localização da pasta
Bibliotecas. Caso você já tenha especificado uma pasta Bibliotecas, clicar em Procurar abre um seletor de arquivos em vez do
assistente para Nova pasta Biblioteca.

Tornando o Javadoc do JDK disponível no IDE


I

Tornando o Javadoc disponível no IDE


Para visualizar a documentação da API JavaSE no NetBeans IDE, use o comando Código-fonte > Exibir documentação ou escolha
Janela > Outro > Javadoc no menu principal para visualizar a documentação da API em outra janela.

No entanto, em algumas bibliotecas de terceiros, a documentação da API não está disponível. Nestes casos, os recursos do Javadoc
devem ser associados manualmente ao IDE.

Para tornar a documentação da API Javadoc disponível para o comando Exibir Javadoc:

1. Faça o download do código-fonte da documentação da API Javadoc.

2. Escolha Ferramentas > Bibliotecas.

3. Na lista Bibliotecas, selecione a biblioteca que seu projeto está usando.

4. Clique na guia Javadoc.

5. Clique no botão Adicionar ZIP/pasta e navegue até o arquivo zip ou a pasta que contém a documentação da API Javadoc em
seu sistema. Selecione o arquivo zip ou a pasta e clique no botão Adicionar ZIP/pasta.

6. Clique em Fechar.

Habilitando o Java Web Start para o aplicativo


Você pode configurar seu aplicativo para ser executado através do Java Web Start no IDE. Para isso, use a categoria Java Web Start
na janela Propriedades do projeto. Para obter informações detalhadas sobre como habilitar o Java Web Start, consulte o tutorial
Habilitando o Java Web Start no NetBeans IDE.

Para configurar o Java Web Start para o aplicativo:

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.

2. Na caixa de diálogo Propriedades do projeto, selecione o nó Aplicativo > Web Start.

3. Selecione a caixa de seleção Habilitar o Enable Web Start e configure as definições do Java Web Start como explicado em
Habilitando o Java Web Start no NetBeans IDE.

Construindo aplicativos
Esta seção explica como construir os projetos padrão no IDE, como efetuar personalizações básicas para o processo de construção, e como
tratar os erros de compilação.

10 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Construindo projetos, pacotes e arquivos


A compilação no IDE é simples. Assumindo que seu classpath de compilação do projeto está corretamente definido, somente será
necessário selecionar o projeto ou o arquivo que deseja compilar e escolher o comando Construir ou Compilar apropriado no menu
Executar. O IDE então compila os arquivos.

Se o recurso Compilar ao salvar estiver habilitado para um projeto Java (ou o recurso Implementar ao salvar está habilitado para um
projeto WEB ou Corporativo Java), o IDE compila automaticamente seus arquivos quando estes são salvos. Consulte Compilar ao
salvar abaixo, para obter mais informações.

Para construir seu aplicativo para implementação:

Escolha Executar > Limpar e construir o projeto.


Quaisquer arquivos previamente compilados e as saídas distribuíveis como arquivos JAR são excluídos. Então os arquivos são
recompilados e novas saídas são produzidas. Uma pasta construir é criada para armazenar as classes compiladas. Um dist é
gerado para conter saídas distribuíveis como arquivos JAR e documentação Javadoc. Você pode ver as saídas construídas ao
abrir a janela Arquivos.

Sempre que você chama comandos de compilação, o IDE exibe a saída incluindo quaisquer erros de compilação encontrados na janela
Saída, como descrito em Corrigindo erros de compilação abaixo.

Compilar ao salvar
O recurso Compilar ao salvar do IDE permite economizar tempo quando você estiver executando e depurando projetos no IDE.
Quando o recurso Compilar ao salvar estiver habilitado para um projeto, os arquivos são compilados quando são salvos. Os arquivos
compilados são armazenados em um cache que o IDE usa quando você executa, testa, depura e perfila o projeto no IDE. Isso permite
testar e depurar seu aplicativo sem ter que esperar que o aplicativo seja primeiro construído.

Quando habilitado, o recurso Compilar ao salvar tem os seguintes efeitos:

O IDE compila seus arquivos quando estes são salvos, para que seu projeto sempre esteja pronto para ser executado ou
depurado no IDE.

O comando Construir é desabilitado. Se você deseja reconstruir o arquivo JAR sem ter que usar o comando Limpar e construir,
é preciso desabilitar o recursos Salvar ao compilar.

O script do Ant do projeto não é usado quando você usa os comandos Executar, Depurar, Perfilar ou Testar. Se você
personalizou seu script de construção para quaisquer destes comandos, estas personalizações serão desconsideradas.

O arquivo JAR que é construído a partir do projeto não é mantido atualizado quando você salva alterações em seus arquivos.
Se você deseja construir ou reconstruir o arquivo JAR, é preciso usar o comando Limpar e construir. O comando Limpar e
construir sempre usa o script do Ant de seu projeto, mesmo de Compilar ao salvar está habilitado ou não.

Por padrão, Compilar ao salvar é habilitado para novos projetos que você cria. Para projetos existentes, Compilar ao salvar é
desabilitado.

Para habilitar ou desabilitar Compilar ao salvar para um projeto Java:

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.

2. Selecione o nó Compilando e defina a propriedade Compilar ao salvar.

De forma similar, o IDE tem um recurso Implementar ao salvar para os aplicativos Web e Corporativo Java. Quando o recurso
Implementar ao salvar é habilitado para um projeto, e um projeto foi implementado através do IDE, os arquivos alterados são
reimplementados imediatamente no servidor. Para que Implementar ao salvar funcione no GlassFish V2, a instância Glassfish precisa
ter a opção Implementação de diretório habilitada selecionada.

Para habilitar ou desabilitar Implementar ao salvar para um projeto Web ou Corporativo Java:

1. Clique com o botão direito do mouse no nó do projeto e escolha Propriedades.

2. Selecione o nó Executar e defina a propriedade Implementar ao salvar.

11 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Para habilitar a implementação do diretório Glassfish V2:

1. Escolha Ferramentas > Servidores.

2. Selecione o servidor.

3. Selecione a aba Opções.

4. Selecione opção Implementação de diretório habilitada.

Corrigindo erros de compilação


O IDE exibe mensagens de saída e quaisquer erros de compilação na janela Saída. Essa janela com múltiplas abas é exibida
automaticamente quando você encontra erros de compilação, depura o programa, gera documentação Javadoc, e assim por diante.
Você também pode abrir manualmente essa janela escolhendo Janela > Saída (Ctrl-4).

Além disso, os erros de compilação são mostrados na janela Tarefas e marcados no editor de código-fonte.

Uma função importante da janela Saída é notificar você de erros encontrados enquanto compila o programa. A mensagem de erro é
exibida em texto sublinhado azul e está vinculada à linha no código-fonte que causou o erro, como ilustrado na imagem abaixo. A
janela Saída também fornece links para erros encontrados ao executar scripts de construção do Ant. Sempre que você clica em um link
de erro na janela Saída, o editor do código-fonte pula automaticamente para a linha que contém o erro. Você também pode usar os
atalhos do teclado F12 e Shift-F12 para mover para o erro seguinte ou anterior no arquivo.

Cada ação realizada por um script Ant, como compilar, executar e depurar arquivos, envia a saída para a mesma guia da janela Saída.
Caso seja necessário salvar as mensagens exibidas na janela Saída, é possível copiar e colar as mensagens em um arquivo separado.
Você também pode definir que o Ant imprima a saída do comando para cada novo alvo em uma nova aba da janela Saída, ao escolher
Ferramentas > Opções, selecionando a categoria Diversos, clicando na aba Ant, e cancelando a seleção da caixa de seleção para
Reutilizar abas de saída da propriedade Processos terminados.

Filtrando arquivos de saída


Quando você cria um arquivo JAR ou um arquivo WAR, normalmente deseja incluir apenas os arquivos .class compilados e quaisquer
outros arquivos de recursos localizados em seu diretório de código-fonte, como pacotes de recursos ou documentos XML. O filtro
padrão faz isso por você ao excluir todos os arquivos .java, .nbattrs e .form de seu arquivo de saída.

Você pode criar filtros adicionais usando expressões regulares para controlar os arquivos de saída. Para especificar quais arquivos
devem ser excluídos, clique com o botão direito do mouse em seu projeto na janela Projetos e escolha Propriedades para abrir a caixa
de diálogo Propriedades do projeto. No painel esquerdo clique em Empacotamento. No painel direito, insira expressões regulares na
caixa de texto para especificar os arquivos a serem excluídos ao empacotar os arquivos JAR ou WAR. Além das expressões padrão,
aqui estão algumas expressões regulares adicionais que podem ser usadas:

Expressão regular Descrição


\.html$ Exclui todos os arquivos HTML
\.java$ Exclui todos os arquivos Java

12 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

(\.html$)|(\.java$) Exclui todos os arquivos HTML e Java


(Key)|(\.gif$) Exclui todos os arquivos GIF e quaisquer arquivos com Key em seus nome

Para obter um guia para a sintaxe de expressões regulares consulte jakarta.apache.org.

Executando aplicativos
Esta seção mostra como executar projetos no IDE e como configurar a classe principal do projeto, os argumentos de tempo de execução,
os argumentos VM e o diretório de trabalho.

Executando projetos e arquivos


Para projetos Java, você normalmente define o projeto que contém a classe principal do projeto como o projeto principal. Para
projetos Web, o projeto principal é o projeto que foi implementado primeiro. Para executar um projeto, pacote ou arquivo, escolha um
dos seguintes:

No menu principal, escolha Executar > Executar projeto principal (F6) para executar o projeto principal. Alternativamente, você
pode usar o botão Executar o projeto principal na barra de ferramentas.

Na janela Projetos, clique com o botão direito do mouse no projeto e escolha Executar o projeto para executar um projeto.
Observe que para projetos Java, o projeto precisa ter uma classe principal.

Na janela Projetos, clique com o botão direito do mouse no arquivo e escolha Executar o arquivo (F6) para executar um
arquivo. Alternativamente, escolha Executar > Executar o arquivo > Executar nome do arquivo (Shift+F6) no menu principal
para executar uma classe executável.

Quando você executa o projeto, o IDE exibe quaisquer erros de compilação e a saída na janela Saída. Para saber mais, consulte
Corrigindo erros de compilação.

Nota: se Compilar ao salvar estiver habilitado para um projeto, o comando Executar o projeto opera em arquivos de classe
que forma criados quando estes arquivos foram salvos. O script do Ant não é usado. Se você definiu etapas personalizadas no
script de construção, estas etapas não são seguidas. Caso deseje que o processo de construção completo ocorra ao usar
Executar o projeto, Depurar o projeto e Perfilar o projeto, desabilite Compilar ao salvar.

Personalizando as opções em tempo de execução


Por padrão, o IDE não especifica uma classe principal, argumentos do tempo de execução ou argumentos JVM. O classpath do tempo
de execução de cada projeto padrão contém as classes compiladas do projeto e tudo o que houver no classpath de compilação do
projeto. Você pode visualizar o classpath de compilação do projeto ao abrir a caixa de diálogo Propriedades do projeto e ao selecionar
o nó Bibliotecas no painel Categorias e a seguir ao clicar na aba Compilar no painel direito.

Para alterar as opções do tempo de execução, abra a caixa de diálogo Propriedades do projeto ao clicar com o botão direito do mouse
no nó do projeto na janela Projetos e escolher Propriedades. A seguir, selecione o nó Bibliotecas no painel Categorias e clique na aba
Executar no painel direito da caixa de diálogo. Observe que para acessar as configurações para a classe principal, argumentos do
programa, o diretório de trabalho para a execução do programa e as opções VM, é preciso selecionar o nó Executar. Na próxima seção
iremos examinar mais de perto sobre como configurar o class path de tempo de execução.

13 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Definindo o classpath de tempo de execução


Para adicionar projetos, bibliotecas, arquivos JAT e pastas para o classpath de tempo de execução, use os botões no lado direito da lista
Bibliotecas de tempo de execução na caixa de diálogo Propriedades do projeto.

Se o projeto usar dinamicamente bibliotecas especiais no tempo de execução através de uma interface indireta ou reflexão (como
drivers JDBC ou implementações JAXP), você terá que adicionar essas bibliotecas ao classpath de tempo de execução. Você também
terá que ajustar o classpath de tempo de execução, se as dependências de tempo de execução entre os projetos não corresponderem
às dependências de compilação dos projetos. Por exemplo, imagine que o projeto A é compilado no projeto B e o projeto B é
compilado no projeto C, mas o projeto A não é compilado no projeto C. Isso significa que o projeto A possui somente o projeto B no
classpath de tempo de execução. Se o projeto A requerer o projeto B e o projeto C durante a execução, você terá que adicionar o
projeto C ao classpath de tempo de execução do projeto A.

Definindo a classe principal e os argumentos de tempo de execução


Para definir a classe principal do projeto, selecione o nó executar no painel Categorias da caixa de diálogo Propriedades do projeto, e
digite um nome completamente qualificado no campo Classe principal (por exemplo, org.myCompany.myLib.MyLibClass). A classe
principal tem que existir no projeto ou em um dos arquivos ou bibliotecas JAR no classpath de tempo de execução do projeto. Após
isso, digite quaisquer argumentos de tempo de execução necessários no campo Argumento.

Se você usa o botão Procurar para escolher a classe principal do projeto, o seletor de arquivos só exibirá classes no diretório de
código-fonte do projeto. Se você quiser especificar uma classe em uma das bibliotecas no caminho de classe, terá que digitar o nome
totalmente qualificado da classe no campo Classe principal.

Definindo os argumentos JVM


Você pode especificar os argumentos JVM para o projeto na caixa de diálogo Propriedades do projeto. Abra a caixa de diálogo
Propriedades do projeto e clique em Executar no painel Categorias, e a seguir digite uma lista separada por espaço de argumentos JVM
no campo Opções VM.

14 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Você pode definir as propriedades do sistema digitando o seguinte no campo Opções da VM:

-Dname=value

Personalizando o script de construção


Em projetos padrão o IDE gera o script de construção com base nas opções inseridas no assistente Novo projeto e na caixa de diálogo
Propriedades do projeto. Você pode definir todas as opções básicas de compilação e tempo de execução na caixa de diálogo Propriedades
do projeto no projeto e o IDE atualiza automaticamente o script do Ant do projeto. Se você tiver requisitos adicionais para o processo de
construção que não podem ser tratados na caixa de diálogo Propriedades do projeto, poderá modificar diretamente o script de construção.

O script principal do Ant para projetos padrão é o build.xml. O IDE chama os destinos no build.xml sempre que você executa comandos
do IDE. Este arquivo tem uma declaração de importação que importa o nbproject/build-impl.xml, que contém destinos de construção
que são gerados pelo IDE. No build.xml, você pode sobrepor qualquer destino de nbprojetc/build-impl.xml ou gravar novos destinos.
Não edite diretamente o nbproject/build-impl.xml , porque aquele arquivo é regerado com base nas alterações feitas na caixa de
diálogo Propriedades do projeto.

Além disso, o script de construção usa o nbproject/project.properties que pode ser manualmente editado.

Com projetos padrão, você pode personalizar o processo de construção adotando um dos procedimentos seguintes:

Inserindo opções básicas, como as configurações do classpath e filtros JAR, no assistente Novo projeto, quando você cria um
projeto ou posteriormente na caixa de diálogo Propriedades do projeto.

Editando propriedades no nbproject/project.properties. Este arquivo armazena propriedades do Ant com informações
importantes sobre seu projeto, como a localização de seu código-fonte e as pastas de saída. Você pode substituir as propriedades
nesse arquivo. Tenha cuidado ao editar este arquivo. Por exemplo, a pasta de saída é excluída sempre que você limpa seu projeto.
Portanto, nunca defina a pasta de saída para o mesmo local da pasta de código-fonte sem primeiro configurar o destino clean para
não excluir a pasta de saída.

Personalize destinos Ant existentes ou crie novos ao executar quaisquer um dos seguintes:

Adicione instruções a serem processadas antes ou depois de um destino do Ant ser executado. Cada um dos destinos
principais no nbproject/build-impl.xml também tem um destino -pre e -post que você sobrepõe no build.xml. Por
exemplo, para que o RMI funcione com projetos regulares, digite o seguinte no build.xml:

<target name="-post-compile">
<rmic base="${build.classes.dir}" includes="**/Remote*.class"/>
</target>

Altere as instruções em um destino do Ant. Copie o destino de nbproject/build-impl.xml para o build.xml e faça
quaisquer alterações no destino.

Crie novos destinos no build.xml. Você também pode adicionar o novo destino nas dependências dos destinos existentes do
IDE. Substitua o destino existente em build.xml , e a seguir adicione o novo destino na propriedade depends do destino
existente. Por exemplo, a instrução a seguir adiciona o destino new-target nas dependências do destino run:

<target name="new-target">
<!-- target body... -->
</new-target>

<target name="run" depends="new-target,myprojname-impl.run"/>

Não é preciso copiar o corpo do destino de execução no build.xml.

A tabela a seguir lista algumas tarefas comuns que você pode considerar útil para redefinir um arquivo JAR:

15 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Para desempenhar esta


Siga estas etapas
tarefa

Especifique quais arquivos Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades. Clique no
são adicionados ao arquivo nó Empacotamento (em Construção) e configure as definições do filtro e compressão usando o campo
JAR. Excluir do arquivo JAR. Para obter mais informações, consulte Filtrando os arquivos de saída

Altere o nome e a Na janela Arquivos, clique duas vezes no arquivo nbproject/project.properties do projeto no editor de
localização do arquivo JAR. código-fonte. Insira o cominho completo para o arquivo JAR na propriedade dist.jar .

Especifique o arquivo Em project.properties, digite o nome do arquivo manifesto na propriedade manifest.file. O nome do
manifesto para o arquivo arquivo deve ser especificado em relação ao arquivo build.xml do projeto. Observe que se você estiver
JAR. usando o modelo de aplicativo Java, o IDE cria um arquivo manifest para você.

Na janela "Files", abra a pasta do projeto e, em seguida, abra build.xml. Substitua o destino jar para ter
conteúdo e não dependências. Por exemplo, adicione o seguinte a build.xml:
Desabilite a geração de um
arquivo JAR para um
projeto. <target name="jar" />

Se você estiver procurando por recursos de aprendizado do Ant, visite http://ant.apache.org/resources.html. Você também pode instar o
manual do Ant no sistema de ajuda do IDE ao utilizar o Gerenciador de plug-in. Escolha Ferramentas > Plug-ins e instale o módulo
Documentação do Ant.

Editando e executando scripts do Ant


O IDE reconhece automaticamente os scripts do Ant e os exibe como nós do Ant ( ) ao invés de arquivos XML normais. Você pode
clicar com o botão direito do mouse nos scripts do Ant na janela Projetos, janela Arquivos ou na janela Favoritos, para acessar um
menu suspenso de comandos. Você também pode expandir o nó do script do Ant para visualizar uma lista alfabética de sub-nós
representando os destinos do script do Ant. Cada um destes sub-nós também têm um menu suspenso de comandos.

Nas janelas Projetos, Arquivos e Favoritos, os sub-nós do script do Ant são marcados nas seguintes formas:

Ícone Significado

Destino enfatizado do Ant. Estes destinos incluem um atributo de descrição, que é exibido como uma dica de
ferramenta. Você define o atributo de descrição do destino no editor de código-fonte.

Destino normal do Ant. Um destino sem um atributo de descrição.

Clique duas vezes nos sub-nós do Ant para ir direto para o local do destino no editor de código-fonte. Todas as ferramentas normais de
pesquisa XML, ferramentas de seleção e atalhos de teclado, estão disponíveis para editar scripts do Ant, e o IDE fornece a conclusão do
código para todas as tarefas padrão do Ant.

Quando você cria um destino que deseja executar a partir da linha de comando, forneça um atributo de descrição para o destino.
Então, se você se esquecer dos nomes dos destinos ou o que eles fazem, poderá executar o comando -projecthelp <script> do Ant
na linha de comando. Com este comando, o Ant lista somente os destinos que tenham um atributo de descrição, junto com suas
descrições. Especialmente quando há muitos destinos em seu script de construção do Ant, enfatizar alguns e não enfatizar outros, pode
ser uma forma útil de distinguir entre os que são muito usados e os que são usados com menor frequência.

O estilo da fonte da legenda do sub-nó nas janelas Projetos, Arquivos e Favoritos, indicam o seguinte:

Normal. Um destino que é definido dentro do script do Ant atual.

Itálico. Um destino que é importado de outro script do Ant.

Acinzentado. Um destino interno que não pode ser diretamente executado. Os destinos internos têm nomes começando por
'-'.

Negrito. O destino padrão para o script, caso haja algum. O destino padrão é declarado como um atributo para o projeto,
junto com outros atributos do projeto, como seu nome. Você define o atributo padrão do projeto no editor de código-fonte.

Os destinos que são importados de outro script mas que são sobrepostos no script de importação não são listado. Somente o destino
que sobrepõe é listado.

Você pode executar destinos em um script do Ant a partir do nó do script do Ant na janela Projetos, janela Arquivos ou na janela

16 de 17 02-03-2010 17:34
Criando, importando e configurando projetos Java ... http://netbeans.org/kb/docs/java/project-setup_pt_...

Favoritos. Para fazer isso, clique com o botão direito do mouse no nó do script do Ant e escolha um destino a partir do submenu
Executar destino. Os destinos são alfabeticamente ordenados. Somente os destinos enfatizados são listados. Escolha Outros destinos
para executar um destino que não foi enfatizado com um atributo de descrição. Os destinos internos são excluídos destas listas porque
eles não podem ser executados independentemente.

Ao invés de executar um destino usando o menu suspenso do nó do script do Ant, basta clicar com o botão direito do mouse no nó do
destino e escolher Executar destino.

Escrevendo tarefas personalizadas do Ant


Você pode usar tarefas personalizadas do Ant para expandir a funcionalidade fornecida por tarefas embutidas do Ant. As tarefas
personalizadas são usadas com frequência para definir propriedades, para criar elementos aninhados, ou para escrever texto
diretamente entre identificadores usando o método addText method.

Para criar uma tarefa personalizada do Ant no IDE:

1. Clique com o botão direito do mouse no pacote onde gostaria de colocar a tarefa e escolha Novo > Outro.

2. Selecione a categoria Outro e o tipo de arquivo da tarefa personalizada do Ant.

3. Conclua o assistente.

Quando você cria o arquivo da tarefa personalizada do Ant, o modelo é aberto no editor de código-fonte. O modelo contém código de
amostra para muitas das operações comuns executadas por tarefas do Ant. Após cada seção do código, o modelo também mostra
como usar a tarefa em um script do Ant.

Envie-nos seus comentários

Consulte também
Escrevendo testes JUnit.

Depurando aplicativos multithreaded no NetBeans IDE

Ativando o Java Web Start no NetBeans IDE

17 de 17 02-03-2010 17:34