Criando, Importando e Configurando Projetos Java - Tutorial do NetBeans IDE

Este guia fornece uma visão geral das principais funcionalidades 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.

Conteúdo

Conteúdo nesta página se aplica ao NetBeans IDE  7.0, 7.1, 7.2 e 7.3

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

Software ou Recurso Versão Necessária
NetBeans IDE versão 7.0, 7.1, 7.2 ou 7.3
Java Development Kit (JDK) versão 6 ou 7

Conceitos Básicos do Projeto

Esta seção fornece uma visão geral de algumas informações detalhadas 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 definições de execução e um arquivo project.xml que mapeia os destinos do Ant com comandos do IDE.

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

Ant

O Apache Ant é uma ferramenta de construção utilizada para padronizar e automatizar a construção, além de executar ambientes para desenvolvimento. O sistema do projeto do IDE tem base direta no Ant. Todos os comandos do projeto, como Limpar e Construir Projeto e Depurar, chamam destinos no script do Ant do projeto. Portanto, é possível 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. É possível definir todas as opções básicas de compilação e runtime 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 no Windows, Cmd-Shift-N no OS X).

Quando o assistente para Novo Projeto aparecer, selecione o modelo correto para seu projeto e complete as etapas restantes do assistente. 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 funcionalidade será ativada no IDE.

O IDE contém os seguintes modelos de projeto padrão para aplicações Java e Java Web:

Além disso, o IDE também contém modelos para módulos EJB, aplicações corporativas, aplicações Java ME e muito 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 um script do Ant existente para um projeto, mas requerem a configuração manual. Consulte Projetos de Formato Livre abaixo.

Quando você finaliza a criação de 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 os códigos-fonte do projeto. Ela mostra uma view lógica do conteúdo importante do projeto como pacotes Java e páginas Web. É possível clicar com o botão direito do mouse em qualquer nó do projeto para acessar um menu pop-up 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 no Windows/Cmd-1 no OS X).
  • A janela Arquivos mostra uma view 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, é possível abrir e editar os arquivos de configuração do projeto, como o script de construção do projeto e o arquivo de propriedades. Também é possível exibir 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 no Windows/Cmd-2 no OS X).

Janelas Arquivos e Projetos

Observação: se for necessário acessar os arquivos e diretórios que estejam fora dos diretórios do projeto, é possível utilizar a janela Favoritos. Para abrir a janela Favoritos, escolha Janela > Favoritos (Ctrl-3 no Windows/Cmd-3 no OS X). É possível 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 manipular a importação inicial de projetos para o IDE.

Importando um Espaço de Trabalho do Eclipse

Para projetos Eclipse, é possível utilizar o assistente Importar Projeto Eclipse para ajudá-lo a criar projetos NetBeans de projetos em um espaço de trabalho Eclipse e para importar classpaths do projeto e outras definições. Quando o assistente Importar Projeto Eclipse é utilizado, não é necessário utilizar manualmente criar e configurar o projeto NetBeans. Abra o assistente selecionando 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ódigos-fonte Existentes

Para outros projetos Java desenvolvidos fora do NetBeans, é possível utilizar o modelo "Código-fonte Existente" no assistente Novo Projeto para criar um projeto NetBeans. No assistente, você identifica a localização dos códigos-fonte e especifica a localização para os metadados do projeto NetBeans. Em seguida, você usa a caixa de diálogo Propriedades do Projeto para configurar o projeto.

Para configurar um projeto NetBeans para uma aplicação Java existente:

  1. Escolha Arquivo > Novo Projeto (Ctrl-Shift-N no Windows, Cmd-Shift-N no OS X).
  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 as etapas seguir:
    • Digite um nome de projeto.
    • (Opcional) Altere a localização da pasta do projeto.
    • (Opcional) Altere o nome do script de construção utilizado pelo IDE. Isso pode ser desejável se já houver um script denominado como build.xml que é utilizado para construir os códigos-fonte.
    • (Opcional) Marque a caixa de seleção Utilizar 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) Marque a caixa de seleção Definir como Projeto Principal. Quando esta opção for selecionada, os atalhos de teclado para os comandos como Limpar e Construir Projeto Principal (Shift-F11) se aplicam a este projeto.
  4. Clique em Próximo para avançar para a página Códigos-fonte Existentes do assistente.
  5. No painel Pasta de Pacotes de Código-fonte, clique em Adicionar Pasta. Depois navegue para seus códigos-fonte, selecione as raízes do código-fonte e clique em Abrir.

    Quando uma pasta contendo o código-fonte é adicionada, é necessário 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 que contém as pastas do pacote JUnit.
  7. Clique em Próximo para avançar para a página Inclusões e Exclusões do assistente.
  8. (Opcional) Na página Inclusões e Exclusões do assistente, insira os padrões do nome do arquivo somente para os arquivos que deveriam ser incluídos ou excluídos do projeto. Todos os arquivos em suas raízes de código-fonte são incluídos por default.
  9. Clique em Finalizar.

Configurando um Projeto Web com Base em Códigos-fonte Existentes

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

Observação: se o projeto foi originalmente desenvolvido no Eclipse, é possível economizar tempo ao utilizar o assistente Importar Projeto Eclipse ao invés do assistente Novo Projeto. O assistente Importar Projeto Eclipse permite importar simultaneamente vários projetos, incluindo suas configurações. Consulte Importando Projetos Eclipse no NetBeans IDE.

Para configurar um projeto NetBeans para uma aplicação Web existente:

  1. Escolha Arquivo > Novo Projeto (Ctrl-Shift-N no Windows, Cmd-Shift-N no OS X).
  2. Escolha a Aplicação Web Java Web > com Códigos-fonte Existentes. Clique em Próximo.
  3. Na página Nome e Localização do assistente, siga as etapas seguir:
    • No campo Localização, insira a pasta que contém as pastas raízes do código-fonte da aplicação Web e as pastas da página Web.
    • Digite um nome de projeto.
    • (Opcional) Altere a localização da pasta do projeto.
  4. (Opcional) Marque a caixa de seleção Utilizar 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 essa opção.
  5. (Opcional) Marque a caixa de seleção Definir como Projeto Principal. Quando esta opção for selecionada, os atalhos de teclado para os comandos como Limpar e Construir Projeto Principal (Shift-F11) se aplicam a este projeto.
  6. Clique em Próximo para avançar para a página Servidor e Definições do assistente.
  7. (Opcional) Adicione o projeto a uma aplicação corporativa existente.
  8. Selecione um servidor a ser implantado. Se o servidor que você deseja não aparece, clique em Adicionar para registrar o servidor no IDE.
  9. Defina o nível do código-fonte para a versão Java na qual deseja que a aplicação seja executada.
  10. (Opcional) Ajuste o caminho do contexto. O caminho do contexto tem base no nome do projeto por default.
  11. Clique em Próximo para avançar para a página Códigos-fonte existentes e Bibliotecas do assistente.
  12. Verifique todos os campos na página, como os valores para a Pasta das Páginas Web e Pastas do Pacote do Código-fonte.
  13. Clique em Finalizar.

Projetos de Forma Livre

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

Em geral, é melhor utilizar modelos padrão de projeto "Com Códigos-fonte Existentes" para importar projetos. Para projetos Eclipse, é melhor utilizar a funcionalidade Importar Projeto, que cria e configura um projeto padrão por você. Os projetos padrão são mais fáceis para manter a longo prazo. No entanto, os modelos de projeto de formato livre são úteis se você possuir um projeto existente com base no Ant com uma configuração complexa ou idiossincrática, que não pode ser duplicado dentro de um projeto padrão. Por exemplo, se um projeto com múltiplas raízes de código-fonte estiver sendo importado, 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 utilizar um modelo de projeto de formato livre.

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 definição do JDL de destino do projeto, a definiçã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 é desenvolvido uma aplicação 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 sua aplicação. Para informar ao IDE qual projeto é o ponto de entrada principal da aplicação, 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 Projeto Principal constroi o projeto principal e todos os 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 e escolha Definir como o Projeto Principal.

Somente um projeto por vez pode ser o projeto principal.

Definindo o JDK de Destino de um Projeto

No IDE, é possível 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 a funcionalidade autocompletar código.
  • Se disponível, exibe o código-fonte do JDK de destino e a documentação do Javadoc.
  • Utiliza 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.

O IDE utiliza a versão da plataforma Java SE (JDK), na qual o IDE é executado como a plataforma Java default para projetos IDE por default. Você pode exibir a versão do JDK do IDE escolhendo Ajuda > Sobre. 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 chave a seguir a partir da linha de comandos.
    --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 > Plataformas Java no menu principal.
  2. Especifique a pasta que contém a plataforma Java, assim como os códigos-fonte e o Javadoc necessários para a depuração.

Gerenciador de Plataforma Java

Para alternar o JDK de destino 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 um 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 utiliza definições de classpath para ativar a funcionalidade autocompletar código, o realce automático de erros de compilação e a refatoração. É possível editar todas as instruçõ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 aplicações Java SE). O IDE adiciona automaticamente tudo no classpath de compilação do projeto ao classpath do runtime do projeto.

É possível modificar o classpath do projeto de uma das formas a seguir:

  • 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 código-fonte anexados a um arquivo JAR no Gerenciador de Bibliotecas, o IDE adicionará automaticamente os arquivos de Javadoc e os arquivos de código-fonte ao projeto quando o arquivo JAR for registrado em um classpath do projeto. É possível fazer step into nas classes e procurar as páginas de Javadoc das classes sem configurar nada mais.

Caixa de diálogo Propriedades do Projeto

Gerenciando Dependências entre Projetos

Se sua aplicação 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 você limpa e constrói um projeto, o IDE também limpa e constrói os projetos necessários. O projeto do Javadoc necessário e os códigos-fonte também são disponibilizados para o projeto recebedor.

É possível adicionar quaisquer projetos necessários para o projeto ao clicar com o botão direito do mouse no nó Bibliotecas ou adicioná-los ao especificá-los na guia Bibliotecas na caixa de diálogo Propriedades do Projeto. Quando quiser adicionar um projeto obrigatório, selecione a pasta do projeto cujos arquivos JAR você deseja adicionar ao classpath (o seletor de arquivos exibe o ícone para pastas do projeto IDE (Ícone Pasta do Projeto). Ao adicionar projetos na caixa de diálogo Propriedades do Projeto, certifique-se de que a caixa de seleção Construir Projetos no classpath esteja marcada.

Se quiser 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 classpath do projeto padrão. Para fazer isso, é preciso primeiro 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 possui base em Ant, os projetos do NetBeans já são geralmente transferíveis entre usuários diferentes, independentemente de eles utilizarem o IDE ou não. Entretanto, por default, 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 é possível colocar um projeto em um arquivo zip e fornecer o arquivo para que outro usuário descompacte-o e execute-o. Mas se o projeto depende de uma biblioteca personalizada especificada na caixa de diálogo Gerenciador de Bibliotecas, outros podem inicialmente ter 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 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 esses problemas, é possível especificar uma pasta dedicada para bibliotecas do projeto. Além disso, você decide entre utilizar um caminho relativo ou caminho absoluto ao se referir a essas bibliotecas.

Essa flexibilidade torna mais fácil manipular as situações a seguir:

  • Você cria um projeto e precisa torná-lo disponível e capaz de ser construído para outros usuários, independentemente de eles utilizarem o IDE ou não. Eles devem acessar o projeto por meio de um check-out de controle de versão ou descompactando um arquivo zip que você forneceu a eles. Em seguida, eles devem ser capazes de construir a aplicação sem configuração extra.
  • Você deve começar trabalhando em um projeto existente e aderir a um conjunto estrito de convenções relacionadas ao lugar 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).

É possível definir uma pasta de bibliotecas dedicadas para projetos padrão Java SE, Web e Corporativo. É possível definir a pasta de bibliotecas ao criar o projeto (no assistente para Novo Projeto) ou depois na guia 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 seleção Utilizar Pasta Dedicada para Armazenar Bibliotecas.
  4. No campo Pasta de Bibliotecas, selecione o local onde as bibliotecas serão armazenadas.

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

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 seleção Utilizar Pasta Dedicada para Armazenar Bibliotecas.
  4. No campo Pasta de Bibliotecas, selecione o local onde as bibliotecas serão armazenadas.

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

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, marque o nó Bibliotecas.
  3. No painel Bibliotecas, clique em Procurar para abrir o assistente pasta Novas Bibliotecas.
  4. Na página Pasta Biblioteca do assistente, insira uma localização para as bibliotecas e clique em Próximo.
    É possível inserir 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 a seguir estão disponíveis:

    • copiar Arquivos JAR da Biblioteca para Nova Pasta de Bibliotecas. Use esta opção se a biblioteca não estiver na pasta que você selecionou e você deseja ter os arquivos JAR da biblioteca colocados nela.
    • Usar Caminho Relativo para Arquivos JAR da Biblioteca. Use esta opção se a biblioteca não estiver na pasta de bibliotecas e você precisar acessar a biblioteca em seu local existente usando um caminho relativo. Uma entrada com uma referência relativa é adicionada para a biblioteca no arquivo nblibraries.properties da pasta de bibliotecas.
    • Usar Caminho Absoluto para Arquivos JAR da Biblioteca. Use esta opção se a biblioteca não estiver na pasta de bibliotecas e você precisar acessar a biblioteca em seu local 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 esta 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 Finalizar para sair do assistente Tornar Projeto Compartilhável.
  7. Clique em OK para sair da caixa de diálogo Propriedades do Projeto.

Observação: também é possível utilizar o nó Bibliotecas da caixa de diálogo Propriedades do Projeto para alterar a localização da pasta de bibliotecas. Caso você já tenha especificado uma pasta Bibliotecas, clicar em Procurar abre um seletor de arquivos em vez do assistente para Pasta Nova Biblioteca.

Tornando o Javadoc Disponível no IDE

Para exibir a documentação da API Java SE no NetBeans IDE, utilize o comando Código-fonte > Exibir documentação ou escolha Janela > Outro > Javadoc no menu principal para exibir 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. Nesses casos, os recursos do Javadoc devem ser associados manualmente ao IDE.

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

  1. Faça 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á utilizando.
  4. Clique na guia Javadoc.
  5. Clique no botão Adicionar ZIP/Pasta e navegue até o arquivo zip ou à 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 OK.

Ativando o Java Web Start para a Aplicação

É possível configurar sua aplicação para ser executada por meio do Java Web Start no IDE. Para isso, utilize a categoria Java Web Start na janela Propriedades do Projeto. Para obter informações detalhadas sobre como ativar o Java Web Start, consulte o tutorial Ativando o Java Web Start no NetBeans IDE.

Para Configurar o Java Web Start para a aplicação:

  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ó Aplicação > Web Start.
  3. Marque a caixa de seleção Ativar Web Start e configure as definições do Java Web Start como explicado em Ativando o Java Web Start no NetBeans IDE.

Construindo Aplicações

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.

Construindo Projetos, Pacotes e Arquivos

A compilação no IDE é simples. Assumindo que seu classpath de compilação do projeto está corretamente definido, será necessário somente 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 a funcionalidade Compilar ao Salvar estiver ativada para um projeto Java (ou a funcionalidade Implantar ao Salvar está ativada para um projeto Java WEB ou corporativo), o IDE compila automaticamente os arquivos quando estes são salvos. Consulte Compilar ao Salvar abaixo, para mais informações.

Para construir sua aplicação para implantação:

  • Escolha Executar > Limpar e Construir Projeto.

    Todos os arquivos previamente compilados e as saídas distribuíveis como arquivos JAR são deletados. 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. É possível ver as saídas construídas ao abrir a janela Arquivos.

Sempre que comandos de compilação são chamados, 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

A funcionalidade Compilar ao Salvar do IDE permite economizar tempo quando você estiver executando e depurando projetos no IDE. Quando a funcionalidade Compilar ao Salvar estiver ativada para um projeto, os arquivos são compilados ao serem salvos. Os arquivos compilados são armazenados em um cache que o IDE utiliza quando o projeto no IDE é executado, testado, depurado e perfilado. Isso permite testar e depurar a aplicação sem ter que esperar que a aplicação seja construída primeiro.

Quando ativada, a funcionalidade 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 é desativado. Desative a funcionalidade Salvar ao Compilar se quiser reconstruir o arquivo JAR sem ter de utilizar o comando Limpar e Construir.
  • O script do Ant do projeto não é utilizado quando os comandos Executar, Depurar, Perfilar ou Testar são utilizados. Se o script de construção foi personalizado 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 quiser construir ou reconstruir o arquivo JAR, utilize o comando Limpar e Construir. O comando Limpar e Construir sempre utiliza o script Ant do seu projeto, independentemente de a funcionalidade Compilar ao Salvar estar ou não ativada.

Compilar ao Salvar é ativado por default para novos projetos que você cria. Para projetos existentes, Compilar ao Salvar é desativado.

Para ativar ou desativar 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 uma funcionalidade Implantar ao Salvar para as aplicações Java Web e corporativas. Quando a funcionalidade Implantar ao Salvar está ativada para um projeto e ele foi implantado por meio do IDE, os arquivos alterados são reimplantados imediatamente no servidor. Para que Implantar ao Salvar funcione no GlassFish V2, a instância Glassfish precisa ter a opção Implantação de diretório ativada selecionada.

Para ativar ou desativar Implantar ao Salvar para um projeto Java Web ou corporativo:

  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 Implantar ao Salvar.

Para ativar a implantação do diretório Glassfish V2:

  1. Escolha Ferramentas > Servidores.
  2. Selecione o servidor.
  3. Selecione a guia Opções.
  4. Selecione opção Implantação do Diretório Ativada.

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 guias é exibida automaticamente quando você encontra erros de compilação, depura o programa, gera documentação Javadoc, e assim por diante. Também é possível abrir manualmente essa janela escolhendo Janela > Saída (Ctrl-4 no Windows/Cmd-4 no OS X).

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 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 de Código-fonte salta automaticamente para a linha que contém o erro.

Janela de saída que mostra erros de compilação

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. Se for necessário salvar as mensagens exibidas na janela Saída, é possível copiar e colar as mensagens em um arquivo separado. Também é possível definir que o Ant imprima a saída do comando para cada novo destino em uma nova guia da janela Saída ao escolher Ferramentas > Opções, selecionando a categoria Diversos, clicando na guia Ant e desmarcando a caixa de seleção para Reutilizar Guias de Saída da propriedade Processos Finalizados.

Filtrando Arquivos de Saída

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

É possível criar filtros adicionais utilizando 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 Encapsulamento. No painel direito, insira expressões regulares na caixa de texto para especificar os arquivos a serem excluídos ao encapsular os arquivos JAR ou WAR. Além das expressões default, aqui estão algumas expressões regulares adicionais que podem ser utilizadas:

Expressão Regular Descrição
\.html$ Exclui todos os arquivos HTML
\.java$ Exclui todos os arquivos Java
(\.html$)|(\.java$) Exclui todos os arquivos HTML e Java
(Chave)|(\.gif$) Exclui todos os arquivos GIF e quaisquer arquivos com Key em seu nome

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

Executando Aplicações

Esta seção mostra como executar projetos no IDE e como configurar a classe principal do projeto, os argumentos de runtime, 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 programa como o projeto principal. Para projetos Web, o projeto principal é o projeto que foi implantado primeiro. Para executar um projeto, pacote ou arquivo, escolha uma das opções a seguir:

  • No menu principal, escolha Executar > Executar Projeto Principal (F6) para executar o projeto principal. Alternativamente, é possível utilizar 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 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.

Observação: se Compilar ao Salvar estiver ativado para um projeto, o comando Executar o projeto opera em arquivos de classe que foram criados quando estes arquivos foram salvos. O script de construção do Ant não é utilizado. Se etapas personalizadas foram definidas no script de construção, estas etapas não são seguidas. Se desejar que o processo de construção completo ocorra ao utilizar Executar o Projeto, Depurar o Projeto e Perfilar o Projeto, desative Compilar ao Salvar.

Personalizando as Opções de Runtime

Como default, o IDE não especifica uma classe principal, argumentos do runtime ou argumentos JVM. O classpath do runtime de cada projeto padrão contém as classes compiladas do projeto e tudo o que houver no classpath de compilação do projeto. É possível exibir o classpath de compilação do projeto ao abrir a caixa de diálogo Propriedades do projeto, selecionar o nó Bibliotecas no painel Categorias e, em seguida, clicar na guia Compilar no painel direito.

Para alterar as opções do runtime, 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. Em seguida, selecione o nó Bibliotecas no painel Categorias e clique na guia Executar no painel direito da caixa de diálogo. Observe que para acessar as definições para a classe principal, argumentos do programa, 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 classpath de runtime.

Especificando as definições de runtime na caixa de diálogo Propriedades do Projeto

Definindo o Classpath de Runtime

Para adicionar projetos, bibliotecas, arquivos JAR e pastas para o classpath de runtime, utilize os botões no lado direito da lista Bibliotecas de Runtime na caixa de diálogo Propriedades do Projeto.

Se o projeto utilizar dinamicamente bibliotecas especiais no runtime por meio de uma interface indireta ou reflexão (como drivers JDBC ou implementações JAXP), será necessário adicionar essas bibliotecas ao classpath de runtime. Também será necessário ajustar o classpath de runtime se as dependências de runtime entre os projetos não corresponderem às dependências de compilação dos projetos. Por exemplo, imagine que o projeto A compila o projeto B, e o projeto B compila o projeto C, mas um projeto A não compila o projeto C. Isso significa que o projeto A tem Projeto B em seu classpath de runtime. Se o projeto A necessitar do projeto B e do projeto C durante a execução, será preciso adicionar o projeto C ao classpath de runtime do projeto A.

Definindo a Classe Principal e os Argumentos de Runtime

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 precisa existir no projeto ou em um dos arquivos ou bibliotecas JAR no classpath de runtime do projeto. Após isso, digite quaisquer argumentos de runtime necessários no campo Argumentos.

Se você utiliza o botão Procurar para escolher a classe principal do projeto, o seletor de arquivos só mostrará classes no diretório de código-fonte do projeto. Se desejar especificar uma classe em uma das bibliotecas no classpath, precisará digitar o nome totalmente qualificado da classe no campo Classe Principal.

Definindo os Argumentos JVM

É possível especificar os argumentos JVM para o projeto na caixa de diálogo Propriedades do Projeto. Abra a caixa de diálogo Propriedades do Projeto, clique em Executar no painel Categorias e, em seguida, digite uma lista de argumentos JVM separada por espaço no campo Opções VM.

É possível 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. É possível definir todas as opções básicas de compilação e runtime na caixa de diálogo Propriedades do projeto no projeto e o IDE atualiza automaticamente o script do Ant do projeto. Se você possuir requisitos adicionais para o processo de construção, que não podem ser manipulados 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 em build.xml sempre que os comandos do IDE são executados. Esse arquivo possui uma instruçã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, é possível substituir qualquer destino de nbprojetc/build-impl.xml ou gravar novos destinos. Não edite diretamente o nbproject/build-impl.xml, porque aquele arquivo é gerado novamente com base nas alterações feitas na caixa de diálogo Propriedades do Projeto.

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

Com projetos padrão, é possível personalizar o processo de construção adotando um dos procedimentos a seguir:

  • inserindo opções básicas, como as definiçõ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. Esse 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. É possível substituir as propriedades nesse arquivo. Tenha cuidado ao editar este arquivo. Por exemplo, a pasta de saída é deletada 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 limpo para não deletar a pasta de saída.
  • Personalizando destinos de Ant existentes ou criar 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 possui um destino -pre e -post que você substitui 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. Também é possível adicionar o novo destino nas dependências dos destinos existentes do IDE. Substitua o destino existente em build.xml e, em seguida, 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 de execução:
      <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:

Para executar essa tarefa Siga estas etapas
Especifique quais arquivos são adicionados ao arquivo JAR. Clique com o botão direito do mouse no nó do projeto na janela Projetos e escolha Propriedades. Clique no subnó Encapsulamento (em Construção) e configure as definições do filtro e compressão utilizando o campo Excluir do arquivo JAR. Para mais informações, consulte Filtrando os Arquivos de Saída
Altere o nome e a localização do arquivo JAR. Na janela Arquivos, clique duas vezes no arquivo nbproject/project.properties do projeto no Editor de Código-fonte. Insira o caminho completo para o arquivo JAR na propriedade dist.jar .
Especifique o arquivo manifesto para o arquivo JAR. Em project.properties, digite o nome do arquivo manifesto na propriedade manifest.file. O nome do arquivo deve ser especificado em relação ao arquivo build.xml do projeto. Observe que se você estiver utilizando o modelo de Aplicação Java, o IDE cria um arquivo manifest.
Desative a geração de um arquivo JAR para um projeto. Na janela Arquivos, 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 ao build.xml:
<target name="jar" />

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

Editando e Executando Scripts do Ant

O IDE reconhece automaticamente scripts Ant e as exibe como nós de script Ant (Ícone do nó do script Ant) em vez de como arquivos XML normais. Para acessar um menu pop-up de comandos é possível clicar com o botão direito do mouse nos scripts do Ant na janela Projetos, janela Arquivos ou na janela Favoritos. Também é possível expandir o nó do script do Ant para visualizar uma lista alfabética de subnós representando os destinos do script do Ant. Cada um desses subnós também possuem um menu pop-up de comandos.

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

Ícone Significado
Ícone de destino do Ant enfatizado

Alvo Ant Enfatizado. Esses 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.

Ícone Destino Ant Normal Alvo Ant normal. Um destino sem um atributo de descrição.

Clique duas vezes nos subnós do script 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 funcionalidade autocompletar código para todas as tarefas padrão do Ant.

Ao criar um destino que deseja executar a partir da linha de comandos, forneça um atributo de descrição para o alvo. 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 comandos. 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 utilizados e os que são utilizados com menor frequência.

O estilo da fonte do label do subnó nas janelas Projetos, Arquivos e Favoritos indicam o seguinte:

  • Normal. Um destino que está definido dentro do script Ant atual.
  • Itálico. Um destino importado de outro script Ant.
  • Acinzentado. Um destino interno que não pode ser executado diretamente. Os destinos internos possuem nomes começando por '-'.
  • Negrito. O destino default para o script, se houver. O destino default é declarado como um atributo para o projeto, junto com outros atributos do projeto, como seu nome. Você define o atributo default do projeto no Editor de Código-fonte.

Os destinos que são importados de outro script mas que são sobrescritos no script de importação não são listados. Somente o destino substituído é listado.

É possível executar destinos em um script do Ant a partir do nó do script do Ant na janela Projetos, Arquivos ou 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 Alvo. Os destinos são classificados alfabeticamente. 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 dessas listas porque eles não podem ser executados independentemente.

Em vez de executar um destino utilizando o menu pop-up do nó do script do Ant, basta clicar com o botão direito do mouse no nó do destino e escolher Executar Destino.

Executando um destino de Ant

Escrevendo Tarefas Personalizadas do Ant

É possível utilizar tarefas personalizadas do Ant para expandir a funcionalidade fornecida por tarefas embutidas do Ant. As tarefas personalizadas são utilizadas com frequência para definir propriedades, para criar elementos aninhados ou para escrever texto diretamente entre marcadores utilizando o método addText.

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 utilizar a tarefa em um script do Ant.



Consulte Também


get support for the NetBeans

Support


By use of this website, you agree to the NetBeans Policies and Terms of Use. © 2013, Oracle Corporation and/or its affiliates. Sponsored by Oracle logo