| // |
| // Licensed to the Apache Software Foundation (ASF) under one |
| // or more contributor license agreements. See the NOTICE file |
| // distributed with this work for additional information |
| // regarding copyright ownership. The ASF licenses this file |
| // to you under the Apache License, Version 2.0 (the |
| // "License"); you may not use this file except in compliance |
| // with the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, |
| // software distributed under the License is distributed on an |
| // "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY |
| // KIND, either express or implied. See the License for the |
| // specific language governing permissions and limitations |
| // under the License. |
| // |
| |
| = Início rápido da Plataforma NetBeans |
| :jbake-type: platform_tutorial |
| :jbake-tags: tutorials |
| :jbake-status: published |
| :syntax: true |
| :source-highlighter: pygments |
| :toc: left |
| :toc-title: |
| :icons: font |
| :experimental: |
| :description: Início rápido da Plataforma NetBeans - Apache NetBeans |
| :keywords: Apache NetBeans Platform, Platform Tutorials, Início rápido da Plataforma NetBeans |
| |
| Bem-vindo à link:https://netbeans.apache.org/platform/[*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 link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[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 link:https://netbeans.apache.org/tutorials/nbm-10-top-apis.html[As 10 principais APIs do NetBeans]. |
| |
| |
| |
| |
| |
| |
| |
| NOTE: 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. |
| |
| |
| [start=1] |
| 1. Escolha Arquivo | Novo projeto e, em seguida, Módulos do NetBeans. Selecione "Aplicativo da plataforma NetBeans". O seguinte deverá ser exibido: |
| |
| |
| image::images/quickstart-platform_wordapp01.png[] |
| |
| Clique em Próximo. |
| |
| |
| [start=2] |
| 1. Nomeie seu novo aplicativo como "WordApp" e o torne o projeto principal do IDE: |
| |
| |
| image::images/quickstart-platform_wordapp02.png[] |
| |
| O projeto principal do IDE é iniciado quando o comando "Executar projeto" do projeto global é chamado. |
| |
| Clique em Terminar. |
| |
| |
| [start=3] |
| 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 "WordEngine": |
| |
| |
| image::images/quickstart-platform_wordapp03.png[] |
| |
| Clique em Próximo. |
| |
| |
| [start=4] |
| 1. 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: |
| |
| |
| image::images/quickstart-platform_wordapp04.png[] |
| |
| Clique em Terminar. O novo módulo é criado e sua estrutura é mostrada na janela Projetos. |
| |
| |
| [start=5] |
| 1. Clique com o botão direito no módulo "WordEngine" e escolha Novo | Outro. Na categoria Desenvolvimento de módulo selecione "Componente da janela": |
| |
| |
| image::images/quickstart-platform_wordapp05.png[] |
| |
| Clique em Próximo. O seguinte deverá ser exibido: |
| |
| |
| image::images/quickstart-platform_wordapp06.png[] |
| |
| Clique em Próximo. |
| |
| |
| [start=6] |
| 1. Defina o prefixo do nome da classe como "Texto" e o pacote como "org.demo.wordengine": |
| |
| |
| image::images/quickstart-platform_wordapp07.png[] |
| |
| Clique em Terminar. A nova janela é adicionada na estrutura do código-fonte de seu módulo junto com alguns arquivos XML subjacentes. |
| |
| |
| [start=7] |
| 1. 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: |
| |
| |
| image::images/quickstart-platform_wordapp15.png[] |
| |
| 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". |
| |
| |
| [start=8] |
| 1. 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. |
| |
| [source,java] |
| ---- |
| |
| private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) { |
| String s = text.getText(); |
| s = s.toUpperCase(); |
| text.setText(s); |
| } |
| ---- |
| |
| |
| [start=9] |
| 1. 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: |
| |
| |
| image::images/quickstart-platform_wordapp08.png[] |
| |
| |
| [start=10] |
| 1. 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. |
| |
| |
| image::images/quickstart-platform_wordapp09.png[] |
| |
| 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. |
| |
| |
| [start=1] |
| 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. |
| |
| [start=2] |
| 1. 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: |
| |
| [source,java] |
| ---- |
| |
| package org.demo.textfilter; |
| |
| public interface TextFilter { |
| |
| String process(String s); |
| |
| } |
| |
| ---- |
| |
| |
| [start=3] |
| 1. 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: |
| |
| |
| image::images/quickstart-platform_wordapp10.png[] |
| |
| |
| [start=4] |
| 1. Crie um terceiro módulo em seu aplicativo, o nomeie como "MyFilter", com "org.demo.myfilter" como o nome do código-base. |
| |
| [start=5] |
| 1. Adicione uma dependência na caixa de diálogo propriedades do projeto do módulo "MyFilter" recém-criado para o módulo "TextFilter": |
| |
| |
| image::images/quickstart-platform_wordapp11.png[] |
| |
| |
| [start=6] |
| 1. Por causa da dependência acima definida, agora é possível implementar a interface definida no segundo módulo: |
| |
| [source,java] |
| ---- |
| |
| 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. |
| |
| |
| [start=7] |
| 1. 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": |
| |
| |
| image::images/quickstart-platform_wordapp12.png[] |
| |
| Agora, é possível carregar as implementações da classe "TextFilter", conforme ilustrado abaixo: |
| |
| |
| [source,java] |
| ---- |
| |
| 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. |
| |
| |
| [start=1] |
| 1. No primeiro módulo, altere o construtor do "TextTopComponent" como segue:*private InstanceContent content;* |
| |
| [source,java] |
| ---- |
| |
| |
| 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));* |
| |
| } |
| ---- |
| |
| |
| [start=2] |
| 1. Altere o código do botão filtro para que o valor antigo seja adicionado ao objeto ``InstanceContent`` ao clicar no botão. |
| |
| [source,java] |
| ---- |
| |
| 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); |
| } |
| ---- |
| |
| |
| [start=3] |
| 1. Crie um novo módulo denominado "History" com o nome de código-base de "com.demo.history". |
| |
| [start=4] |
| 1. 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". |
| |
| [start=5] |
| 1. 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;* |
| |
| [source,java] |
| ---- |
| |
| |
| 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()); |
| } |
| });* |
| } |
| ---- |
| |
| |
| [start=6] |
| 1. É possível então iniciar o aplicativo e experimentá-lo. O resultado deveria parecer similar ao mostrado na captura de tela abaixo: |
| |
| |
| image::images/quickstart-platform_wordapp13.png[] |
| |
| 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: |
| |
| |
| image::images/quickstart-platform_wordapp14.png[] |
| |
| 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", link:https://netbeans.apache.org/tutorials/nbm-selection-1.html[que começa aqui]. Após isso, inicie com a link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[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 link:https://mail-archives.apache.org/mod_mbox/netbeans-dev/[está aqui]. |
| |
| Divirta-se com a plataforma NetBeans e nos veremos na lista de correio! |
| |