Início rápido da Plataforma NetBeans

Bem-vindo à Plataforma NetBeans!

O principal benefício da plataforma NetBeans é a sua arquitetura modular. O segunda benefício é a dependência da plataforma NetBeans do kit de ferramentas Swing UI, que é o kit de ferramentas oficial para criar interfaces do usuário no Java, em combinação com o premiado construtor de GUI "Matisse".

Nesta introdução, você é apresentado aos benefícios e ao uso da modularidade através de um exemplo bem simples, contribuído por Thomas Würthinger, que no momento é aluno PhD na Universidade Johannes Kepler em Linz, Áustria. Após ter compreendido os conceitos apresentados nesta introdução, você estará pronto para entrar na Trilha de aprendizado da plataforma NetBeans, que fornece uma rica variedade de tutoriais para muitos diferentes cenários relativos à plataforma NetBeans.

Se for novo na plataforma NetBeans, recomenda-se com ênfase que você assista à série de screencasts As 10 principais APIs do NetBeans.

Conteúdo

• Um módulo único do aplicativo da plataforma NetBeans
• Um aplicativo modular que utiliza pesquisa
• LookupListener e InstanceContent

Para seguir este tutorial, os softwares e recursos listados na tabela seguinte são necessários.

Nota: embora seja um produto separado, não é necessário baixar a plataforma NetBeans separadamente. Normalmente, você desenvolverá o aplicativo no IDE e, em seguida, excluirá os módulos específicos do IDE, mas que são supérfluos para a seu aplicativo.

Um módulo único do aplicativo da plataforma NetBeans

Começamos criando um novo aplicativo da plataforma NetBeans, contendo um único módulo.

1. Escolha Arquivo | Novo projeto e, em seguida, Módulos do NetBeans. Selecione "Aplicativo da plataforma NetBeans". O seguinte deverá ser exibido:

   

   Clique em Próximo.

2. Nomeie seu novo aplicativo como "WordApp" e o torne o projeto principal do IDE:

   

   O projeto principal do IDE é iniciado quando o comando "Executar projeto" do projeto global é chamado.

   Clique em Terminar.

3. Expanda o novo aplicativo na janela Projetos, clique com o botão direito do mouse no nó Módulos e escolha "Adicionar novo". Nomeie o novo módulo como "WordEngine":

   

   Clique em Próximo.

4. Especifique um nome único para o módulo, que é o nome do código-base, assim como um nome que será exibido na janela Projetos:

   

   Clique em Terminar. O novo módulo é criado e sua estrutura é mostrada na janela Projetos.

5. Clique com o botão direito no módulo "WordEngine" e escolha Novo | Outro. Na categoria Desenvolvimento de módulo selecione "Componente da janela":

   

   Clique em Próximo. O seguinte deverá ser exibido:

   

   Clique em Próximo.

6. Defina o prefixo do nome da classe como "Texto" e o pacote como "org.demo.wordengine":

   

   Clique em Terminar. A nova janela é adicionada na estrutura do código-fonte de seu módulo junto com alguns arquivos XML subjacentes.

7. Agora, clique duas vezes no arquivo "TextTopComponent.java" para abrir a visualização Projetar do construtor de GUI "Matisse". Use a Paleta (Ctrl-Shift-8) para arrastar e soltar um botão e uma área de texto na janela:

   

   Clique com o botão direito do mouse na área de texto, escolha "Alterar nome da variável" e, a seguir, a nomeie como "texto". Esse é o nome que permitirá o acesso ao componente de seu código. Selecione o texto do botão para "Filtrar".

8. Clique duas vezes no botão, fazendo com que um método de manipulação de eventos seja automaticamente criado no editor de código-fonte. Esse método é chamado sempre que se clica no botão. Substitua o corpo do método pelo seguinte código.

   private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
      String s = text.getText();
      s = s.toUpperCase();
      text.setText(s);
   }

9. Clique com o botão direito do mouse no aplicativo e escolha Executar. Fazendo isso, seu novo aplicativo da plataforma NetBeans será iniciado e o módulo será instalado. Seu novo aplicativo deveria se parecer com o seguinte:

   

10. Escolha Janela | Texto, insira um texto na área de texto e clique em "Filtrar!". Você deverá ver que o texto agora é mostrado em maiúsculas.

    

Você aprendeu como criar um novo aplicativo da plataforma NetBeans e como adicionar novos módulos no mesmo.

Um aplicativo modular utilizando a pesquisa

Criamos dois módulos adicionais. O primeiro novo módulo define um serviço, que o segundo módulo fornece para o módulo que definimos na seção anterior.

1. Expanda o novo aplicativo na janela Projetos, clique com o botão direito do mouse no nó Módulos e escolha "Adicionar novo". Nomeie o novo módulo como "TextFilter", com o nome de código-base "org.demo.textfilter", complete o assistente, que adiciona o módulo no aplicativo anteriormente criado, como fez na seção anterior.
2. Clique com o botão direito do mouse no módulo "TextFilter" e escolha Novo | Interface do Java. Nomeie a interface do Java como "TextFilter", no pacote "org.demo.textfilter", e utilize o editor para o definí-la da seguinte forma:

   package org.demo.textfilter;
   
   public interface TextFilter {
   
       String process(String s);
   
   }
       

3. Clique com o botão direito do mouse no módulo "TextFilter", escolha Propriedades e utilize a aba "Versão de API" para especificar que o pacote contendo a interface deveria estar disponível através do aplicativo:

   

4. Crie um terceiro módulo em seu aplicativo, o nomeie como "MyFilter", com "org.demo.myfilter" como o nome do código-base.
5. Adicione uma dependência na caixa de diálogo propriedades do projeto do módulo "MyFilter" recém-criado para o módulo "TextFilter":

   

6. Por causa da dependência acima definida, agora é possível implementar a interface definida no segundo módulo:

   package org.demo.myfilter;
   
   import org.demo.textfilter.TextFilter;
   
   @ServiceProvider(service=TextFilter.class)
   public class UpperCaseFilter implements TextFilter {
   
       public String process(String s) {
           return s.toUpperCase();
       }
   
   }

   No momento da compilação, a anotação @ServiceProvider criará uma pasta META-INF/services com um arquivo que registra a sua implementação da interface TextFilter, seguido do mecanismo ServiceLoader do JDK 6. É necessário definir uma dependência no módulo API de utilitários, que proporciona a anotação ServiceProvider.

7. O código que manuseia um clique no botão Filtrar agora precisa ser modificado, para que um implementador da interface "TextFilter" seja localizado e carregado. Quando tal implementador é encontrado, ele é chamado para filtrar o texto.

   Antes de poder fazer isso, precisamos adicionar uma dependência na caixa de diálogo Propriedades do projeto do módulo "WordEngine" para o módulo "TextFilter":

   

   Agora, é possível carregar as implementações da classe "TextFilter", conforme ilustrado abaixo:

   private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
       String s = text.getText();
       TextFilter filter = Lookup.getDefault().lookup(TextFilter.class);
       if (filter != null) {
   	 s = filter.process(s);
       }
       text.setText(s);
   }

   O acima deveria ser feito através da classe "ServiceLoader" do JDK 6, com exceção que a classe "Lookup" pode ser utilizada em JDK's anteriores ao JDK 6. Além disso, a classe "Lookup" tem um número de recursos adicionais, como será ilustrado na próxima seção.

Agora você está pronto para executar o código e verificar que tudo funciona como antes. Apesar da funcionalidade ser a mesma, o novo projeto modular oferece uma separação clara entre a interface gráfica do usuário e a implementação do filtro. O novo aplicativo também pode ser estendido com facilidade, basta adicionar novos provedores de serviços no classpath do aplicativo.

Como um exercício, o código é alterado para que todos os filtros de texto ALL encontrados (use o método "lookupAll") sejam aplicados consecutivamente no texto. Por exemplo, adicione uma implementação de filtro de texto que remove todos os espaços em branco e, em seguida, teste o aplicativo resultante.

LookupListener e InstanceContent

Criamos um quarto módulo que recupera de forma dinâmica o texto sempre que clicamos no botão "Filtrar!" botão no nosso primeiro módulo.

1. No primeiro módulo, altere o construtor do "TextTopComponent" como segue:

   private InstanceContent content;
   
   private TextTopComponent() {
       initComponents();
       setName(NbBundle.getMessage(TextTopComponent.class, "CTL_TextTopComponent"));
       setToolTipText(NbBundle.getMessage(TextTopComponent.class, "HINT_TextTopComponent"));
   //        setIcon(Utilities.loadImage(ICON_PATH, true));
   
       content = new InstanceContent();
       associateLookup(new AbstractLookup(content));
   
   }

2. Altere o código do botão filtro para que o valor antigo seja adicionado ao objeto InstanceContent ao clicar no botão.

   private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
       String s = text.getText();
       TextFilter filter = Lookup.getDefault().lookup(TextFilter.class);
       if (filter != null) {
           content.add(s);
           s = filter.process(s);
       }
       text.setText(s);
   }

3. Crie um novo módulo denominado "History" com o nome de código-base de "com.demo.history".
4. No módulo History, crie um novo componente da janela com o prefixo "History", no pacote "com.demo.history". Especifique que ele deveria aparecer na posição "editor". Após ter criado a janela, adicione uma área de texto nela. Altere o nome da variável da área de texto para "historyText".
5. Adicione o código ao construtor da classe HistoryTopComponent para que ouça a pesquisa da classe String da janela no momento ativa. Ele exibe todos os objetos String recuperados na área de texto:

   private Lookup.Result result;
   
   private HistoryTopComponent() {
   
       ...
   
       result = org.openide.util.Utilities.actionsGlobalContext().lookupResult(String.class);
       result.addLookupListener(new LookupListener() {
           public void resultChanged(LookupEvent e) {
               historyText.setText(result.allInstances().toString());
           }
       });
   }

6. É possível então iniciar o aplicativo e experimentá-lo. O resultado deveria parecer similar ao mostrado na captura de tela abaixo:

   

   Como um exercício, é possível alterar o tipo de resultado da pesquisa de String para Object e ver o que acontece ao selecionar diferentes janelas.

Parabéns! Neste estágio, com uma pequena codificação, um pequeno exemplo de um aplicativo modular foi criado:

O aplicativo consiste em 4 módulos. O código de um módulo pode ser utilizado por outro módulo se (1) o primeiro módulo explicitamente expõe pacotes e (2) o segundo módulo define a dependência sobre o primeiro módulo. Desta forma, a plataforma NetBeans ajuda a organizar o código em uma arquitetura modular estrita, assegurando que o código não seja reutilizado de forma aleatória, mas somente quando há contratos definidos entre os módulos que fornecem o código.

Em segundo lugar, a classe Lookup foi introduzida como um mecanismo para a comunicação entre os módulos, como uma extensão da abordagem JDK 6 ServiceLoader. As implementações são carregadas através de suas interfaces. Sem utilizar qualquer código de uma implementação, o módulo "WordEngine" é capaz de exibir o serviço fornecido pelo implementador. O acoplamento fraco é fornecido desta forma para a plataforma NetBeans.

Para saber mais sobre a modularidade e sobre a plataforma NetBeans, vá para a 4ª parte das séries "Gerenciamento de seleção da plataforma NetBeans", que começa aqui. Após isso, inicie com a Trilha de aprendizado da plataforma NetBeans, escolhendo os tutoriais que sejam mais relevantes para seu cenário administrativo particular. Além disso, sempre que tiver perguntas sobre a plataforma NetBeans, de qualquer tipo, sinta-se a vontade para escrever para a lista de correio dev@platform.netbeans.org; seu arquivo relacionado está aqui.

Divirta-se com a plataforma NetBeans e nos veremos na lista de correio!