blob: 1a744a2be2392aa2ad2fa2500eec51b4cc7540a0 [file] [log] [blame]
//
// 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!