Google Git
Sign in
apache / netbeans-website / 1440e326c06ced8bea0220f3ea0061f5a974bba2 / . / netbeans.apache.org / src / old_content / content / tutorials / 74 / nbm-maven-quickstart_pt_BR.adoc
blob: 001d9913ea3badba42a37f92ce6ffcf8d34f1013 [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.
//
= Guia de início rápido da plataforma NetBeans utilizando o Maven
:jbake-type: platform_tutorial
:jbake-tags: tutorials
:jbake-status: published
:syntax: true
:source-highlighter: pygments
:toc: left
:toc-title:
:icons: font
:experimental:
:description: Guia de início rápido da plataforma NetBeans utilizando o Maven - Apache NetBeans
:keywords: Apache NetBeans Platform, Platform Tutorials, Guia de início rápido da plataforma NetBeans utilizando o Maven
Bem-vindo à link:https://netbeans.apache.org/platform/[*Plataforma NetBeans*]!
Este documento é uma demonstração rápida de como criar um simples aplicativo e módulo da plataforma NetBeans e utilizar o Maven para a estrutura da construção. Neste documento serão utilizados os arquétipos Maven para criar um aplicativo e módulo da plataforma NetBeans. Você utilizará o kit de ferramentas da interface de usuário Swing e o Construtor GUI "Matisse" para criar um componente de janela no módulo. O aspecto modular da plataforma NetBeans lhe possibilita desenvolver e expandir a funcionalidade do seu aplicativo, adicionando simplesmente novos módulos.
Este documento tem base no link:nbm-quick-start_pt_BR.html[Guia de início rápido da Plataforma NetBeans para Plataformas NetBeans] com base no Ant. e ilustra algumas das diferenças entre o uso do Ant e do Maven para desenvolver os aplicativos da plataforma NetBeans. Após ter entendido como o Maven é diferente do Ant, será possível prosseguir com facilidade através de outros tutoriais na link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[Trilha de aprendizado da Plataforma NetBeans].
Caso esteja utilizando o NetBeans IDE 6.8, consulte o link:68/nbm-maven-quickstart.html[Guia de início rápido para Plataforma NetBeans 6.8 utilizando o Maven].
Caso não tenha experiência com a plataforma NetBeans, recomenda com ênfase assistir à série de screencasts link:https://netbeans.apache.org/tutorials/nbm-10-top-apis.html[As 10 principais APIs do NetBeans].
*Para seguir este tutorial, são necessários os softwares e recursos listados na tabela a seguir.*
*Observação:* não é necessário baixar uma versão avulsa da plataforma NetBeans para desenvolver os aplicativos para a plataforma NetBeans. Normalmente, você desenvolve os aplicativos e módulos no NetBeans IDE e, a seguir, inclui somente os módulos necessários para executar a plataforma NetBeans e seu aplicativo.
Antes de começar este tutorial, talvez você queira se familiarizar com a documentação a seguir.
* link:http://wiki.netbeans.org/MavenBestPractices[Melhores práticas para o Apache Maven no NetBeans 6.x]
* link:http://www.sonatype.com/books/maven-book/reference/introduction.html[Capítulo 1. Introdução ao Apache Maven] (do link:http://www.sonatype.com/books/maven-book/reference/public-book.html[Maven: o guia definitivo])
* link:https://netbeans.apache.org/kb/docs/java/gui-functionality_pt_BR.html[Introdução à construção de GUIs]
== Configurando Maven
Se este for seu primeiro Projeto Maven, talvez você queira verificar as definições de configurações do Maven na janela Opções. Para completar este tutorial é preciso ter o Maven instalado no sistema local. É possível fazer o download do instalador no link:http://maven.apache.org/[site do Maven].
[start=1]
1. Selecione a categoria Diversos na janela Opções e clique na aba Maven.
[start=2]
1. Especifique a localização da instalação local do Maven (requer 2.0.9 ou mais recente).
[start=3]
1. Verifique se a localização do repositório local do Maven está correta.
[start=4]
1. Clique em OK.
Na maioria dos casos, se a configuração do Maven for normal, as informações na janela Opções já devem estar corretas.
*Observação.* O suporte do Maven é ativado como parte do conjunto dos recursos do Java SE. Caso a aba Maven não esteja disponível na janela Opções, confirme que o Java SE está ativado criando um aplicativo Java.
O IDE usa o Maven SCM para checkout dos artefatos Maven. Talvez você queira verificar se os clientes necessários para o checkout das fontes estão instalados na máquina local e configurados corretamente.
Para mais detalhes sobre o Maven SCM, consulte a link:http://maven.apache.org/scm/index.html[página Maven SCM].
=== Visualizando repositórios Maven
Os artefatos que são utilizados pelo Maven para construir todos os seus projetos são armazenados no repositório local Maven. Quando um artefato é declarado como uma dependência do projeto, o artefato é baixado para o repositório local a partir de um dos repositórios remotos registrados.
O repositório NetBeans e vários outros repositórios conhecidos Maven indexados são registrados e listados, por padrão, na janela Navegador do repositório. O repositório do NetBeans contém a grande maioria dos artefatos públicos necessários para a construção do projeto. É possível utilizar o navegador do repositório Maven para visualizar o conteúdo dos repositórios locais e remotos. É possível expandir o nó Repositório local para visualizar os artefatos que estão presentes localmente. Os artefatos listados sob os nós Repositório do NetBeans podem ser adicionados às dependências do projeto, mas nem todos eles estão presentes localmente. Eles são adicionados ao repositório local somente quando são declarados como dependências do projeto.
Para abrir o navegador do repositório Maven:
* Escolha Janela > Outro > Navegador do repositório Maven do menu principal.
image::images/maven-quickstart68_maven-nbm-netbeans-repo.png[title="Captura de tela do Navegador do repositório Maven"]
Quando o cursor estiver sobre um artefato, o IDE exibirá uma dica de ferramenta com as coordenadas do artefato. É possível visualizar detalhes adicionais sobre um artefato ao clicar duas vezes no arquivo JAR do artefato no navegador.
É possível pesquisar por um artefato ao clicar no botão Localizar da barra de ferramentas do navegador do repositório Maven ou ao utilizar o campo de texto Pesquisa rápida na barra de ferramentas principal.
Para saber mais sobre como gerenciar as dependências de classpath Maven e sobre como trabalhar com repositórios Maven no IDE, consulte a seção link:http://wiki.netbeans.org/MavenBestPractices#Dependency_management[Gerenciamento de dependência] em link:http://wiki.netbeans.org/MavenBestPractices[Melhores práticas para o Apache Maven no NetBeans 6.x].
Para assistir a uma demonstração sobre como utilizar o Visualizador de artefato, consulte o screencast link:https://netbeans.apache.org/kb/docs/java/maven-dependencies-screencast.html[ Trabalhando com dependências Maven].
== Criando projeto do aplicativo da plataforma NetBeans
Nesta seção será utilizado o assistente Novo projeto para criar um aplicativo NetBeans a partir de um arquétipo Maven. O assistente criará os projetos do módulo Maven necessários para desenvolver um aplicativo na plataforma NetBeans. O assistente fornece também a opção de criar um módulo NetBeans no projeto do aplicativo, mas neste tutorial será criado cada módulo individualmente.
=== Criando projeto
Execute as etapas a seguir, para criar o aplicativo da plataforma NetBeans utilizando o assistente Novo projeto.
[start=1]
1. Selecione Arquivo > Novo projeto (Ctrl-Shift-N) para abrir o assistente Novo projeto.
[start=2]
1. Selecione o aplicativo Netbeans Maven na categoria Maven. Clique em Próximo.
[start=3]
1. Digite *MavenPlatformWordApp* como o nome do projeto e defina a localização do projeto. Clique em Terminar.
image::images/maven-quickstart_maven-newproject.png[title="Captura de tela do assistente Novo projeto"]
*Observação.* Caso este seja o seu primeiro aplicativo da plataforma NetBeans utilizando o Maven, pode ser que leve mais tempo para criar os projetos, uma vez que o IDE precisa baixar todos os artefatos necessários a partir do repositório NetBeans.
Ao clicar em Terminar, por padrão, o IDE cria os seguintes tipos do projeto Maven.
* *Aplicativo da plataforma NetBeans.* Este projeto é um projeto recipiente para o aplicativo da plataforma e lista os módulos a serem incluídos e a localização dos repositórios do projeto. Este projeto não contém nenhuma origem. O IDE gera os módulos contendo as fontes e recursos nos subdiretórios deste projeto.
* *Aplicativo com base na plataforma NetBeans.* Este projeto especifica os artefatos (fontes) necessários para a compilação do aplicativo. As dependências exigidas (artefatos IDE, artefatos de módulos) são especificadas no arquivo ``pom.xml`` do projeto. Se expandir o nó Bibliotecas, poderá visualizar as bibliotecas necessárias para o aplicativo da plataforma NetBeans.
* *Recursos de marca do aplicativo da plataforma.* Este projeto contém os recursos utilizados para a marca do aplicativo.
Para todos os projetos Maven, o arquivo ``pom.xml`` (POM) está localizado sob o nó Arquivos do projeto na janela Projetos. Se observar o POM para o projeto do aplicativo da plataforma NetBeans, poderá notar que os outros dois módulos criados pelo assistente estão listados como módulos no aplicativo.
[source,xml]
----
<modules>
<module>branding</module>
<module>application</module>
</modules>
----
=== Modificando elementos da marca
O módulo da marca especifica os recursos da marca utilizados ao construir o aplicativo da plataforma. A caixa de diálogo da marca lhe permite modificar facilmente as propriedades do aplicativo para alterar o nome, a tela de splash e os valores dos elementos de texto.
Ao criar o aplicativo da plataforma NetBeans a partir do arquétipo, o nome padrão para o aplicativo é o artifactId do aplicativo. Neste exercício será utilizado o assistente de marca para modificar o nome do aplicativo e substituir a imagem padrão para a tela splash.
*Observação.* O IDE precisa construir o módulo de marca antes que você possa modificar os recursos da marca.
[start=1]
1. Clique com o botão direito no módulo *Recursos de marca do aplicativo da plataforma* e selecione Marca.
[start=2]
1. Na aba Básico, altere o título do aplicativo para *Aplicativo My Maven Platform Word*.
image::images/maven-quickstart_maven-branding1.png[title="Captura de tela do assistente Novo projeto"]
[start=3]
1. Clique na aba Tela splash e clique no botão Navegador ao lado da imagem da tela splash para localizar uma imagem diferente. Clique em OK.
É possível copiar a imagem abaixo para o seu sistema local e especificar a imagem como uma tela splash na caixa de diálogo Marca.
image::images/maven-quickstart68_splash.gif[title="Exemplo da imagem splash padrão"]
== Criando módulo Maven WordEngine
Nesta seção será criado um novo módulo chamado Maven WordEngine. Você modificará então o módulo para adicionar um componente de janela, um botão e uma área de texto.
=== Criando módulo
Neste exercício será criado um novo projeto de módulo no mesmo diretório que contém o módulo da marca e o módulo do aplicativo.
[start=1]
1. Selecione no menu principal Arquivo > Novo projeto.
[start=2]
1. Selecione Módulo NetBeans Maven na categoria Maven. Clique em Próximo.
[start=3]
1. Digite *Maven WordEngine* como o nome do projeto.
[start=4]
1. Clique em Navegador e localize o diretório MavenPlatformWordApp como a localização do projeto. Clique em Terminar.
image::images/maven-quickstart_maven-wizard-project-location.png[title="Captura de tela do assistente Novo projeto"]
Se observar o POM para o módulo MavenWordEngine notará que a ``artifactId`` do projeto é *MavenWordEngine*.
[source,xml]
----
<modelVersion>4.0.0</modelVersion>
<parent>
<groupId>com.mycompany</groupId>
<artifactId>MavenPlatformWordApp</artifactId>
<version>1.0-SNAPSHOT</version>
</parent>
<groupId>com.mycompany</groupId>
<artifactId>* MavenWordEngine *</artifactId>
<packaging>nbm</packaging>
<version>1.0-SNAPSHOT</version>
<name>MavenWordEngine NetBeans Module</name>
----
Para construir o módulo NetBeans é necessário utilizar o ``nbm-maven-plugin`` . Se observar o POM para o módulo, poderá notar que o IDE especificou automaticamente o ``nbm`` para o ``pacote`` e que o *nbm-maven-plugin* foi especificado como um plugin de construção.
[source,xml]
----
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>*nbm-maven-plugin*</artifactId>
<version>3.2-SNAPSHOT</version>
<extensions>true</extensions>
</plugin>
----
Se observar o POM para o aplicativo da plataforma NetBeans, você notará que o *MavenWordEngine* foi adicionado à lista de módulos no aplicativo.
[source,xml]
----
<modules>
<module>branding</module>
<module>application</module>
<module>*MavenWordEngine*</module>
</modules>
----
=== Tornando módulo uma dependência do MavenPlatformWordApp
Neste exercício será declarado o módulo MavenWordEngine como uma dependência do aplicativo com base na plataforma NetBeans adicionando a dependência no POM. O POM para o aplicativo declara as dependências a seguir.
[source,xml]
----
<dependencies>
<dependency>
<groupId>org.netbeans.cluster</groupId>
<artifactId>platform</artifactId>
<version>${netbeans.version}</version>
<type>pom</type>
</dependency>
<dependency>
<groupId>com.mycompany</groupId>
<artifactId>branding</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
</dependencies>
----
Se expandir o nó Bibliotecas para o aplicativo com base na plataforma NetBeans, notará que há uma dependência no módulo da marca e em outras bibliotecas que são dependências do cluster necessário para construir o aplicativo.
image::images/maven-quickstart_maven-projects-libraries.png[title="Captura de tela da caixa de diálogo Adicionar dependência"]
É possível expandir a lista de dependências não-classpath para visualizar a lista completa de dependências.
Para adicionar a dependência ao POM, é possível editar o POM diretamente no editor ou abrir a caixa de diálogo Adicionar dependência na janela Projetos.
[start=1]
1. Expanda o *Aplicativo com base na plataforma NetBeans-MavenPlatformAPP* na janela Projetos.
[start=2]
1. Clique com o botão direito no nó Bibliotecas e selecione Adicionar dependência.
[start=3]
1. Clique na aba Abrir projetos e selecione *MavenWordEngine*. Clique em OK.
image::images/maven-quickstart_maven-add-dependency1.png[title="Captura de tela da caixa de diálogo Adicionar dependência"]
*Observação.* O novo projeto aparecerá na caixa de diálogo após o IDE finalizar a análise e atualização dos índices.
Se expandir o nó Bibliotecas do MavenPlatformWordApp na janela Projetos, você notará que o MavenWordEngine está agora listado com uma dependência.
=== Adicionando componente de janela a um módulo
Neste exercício será utilizado um assistente para adicionar o componente de janela ao módulo MavenWordEngine.
[start=1]
1. Clique com o botão direito do mouse no *Módulo NetBeans MavenWordEngine* na janela Projetos e selecione Novo > Outro para abrir o assistente Novo arquivo.
[start=2]
1. Selecione Janela na categoria Desenvolvimento do módulo. Clique em Próximo.
[start=3]
1. Selecione *saída* na lista suspensa Posição da janela. Clique em Próximo.
image::images/maven-quickstart_maven-new-window.png[title="Captura de tela da página Componente de janela no assistente Novo arquivo"]
[start=4]
1. Digite *Texto* no campo Prefixo do nome da classe. Clique em Terminar.
O assistente exibe uma lista de arquivos que serão criados e dos arquivos que serão modificados.
Ao clicar em Terminar, na janela Projetos, poderá notar que o IDE gerou a classe ``TextTopComponent.java`` no ``com.mycompany.mavenwordengine`` sob os pacotes Origem. O IDE também gerou arquivos de recursos adicionais no ``com.mycompany.mavenwordengine`` sob Outras fontes. Neste exercício será editado somente o arquivo ``TextTopComponent.java`` .
É possível visualizar a estrutura do projeto na janela Arquivos. Para compilar um projeto Maven, somente arquivos de origem podem ser localizados sob os pacotes Origem (diretório ``src/main/java`` na janela Arquivos). Outros recursos (ex. arquivos XML) precisam ser localizados sob Outras fontes (diretório ``src/main/resources`` na janela Arquivos).
=== Modificando componente de janela
Neste exercício serão adicionados uma área de texto e um botão ao componente de janela. Você modificará então o método invocado pelo botão para mudar as letras na área de texto para letras maiúsculas.
[start=1]
1. Clique na aba Desenho do ``TextTopComponent.java`` no editor.
[start=2]
1. Arraste e solte um botão e uma área de texto da paleta na janela.
[start=3]
1. Clique com o botão direito na área de texto e selecione Alterar nome variável e, a seguir, digite *texto* como o nome. Você utilizará o nome ao acessar o componente do seu código.
[start=4]
1. Defina o texto do botão como "*Filtro!*".
image::images/maven-quickstart68_maven-nbm-textopcomponent.png[title="Captura de tela da página Componente de janela no assistente Novo arquivo"]
[start=5]
1. Clique duas vezes no elemento do botão Filtro! na visualização Desenho para abrir o método manipuladores de eventos para o botão no editor do código de origem. O método é criado automaticamente ao clicar duas vezes no elemento botão.
[start=6]
1. Modifique o corpo do método e adicione o código a seguir. Salve as alterações.
[source,java]
----
private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
*tring s = text.getText();
s = s.toUpperCase();
text.setText(s);*}
----
É possível utilizar a conclusão do código no editor para ajudá-lo a digitar o código.
Se desejar testar se seus aplicativos estão funcionando corretamente, pode clicar com o botão direito do mouse no nó Projeto do *aplicativo com base na plataforma NetBeans mavenPlatformWordApp* e selecionar Construir com dependências.
A ação padrão mapeada para Construir com dependências é construir o projeto utilizando o plugin Reator. Ao construir um projeto utilizando o plugin Reator, as dependências dos subprojetos são construídas antes que o projeto recipiente seja construído. A janela Saída exibe a ordem de construção.
image::images/maven-quickstart_maven-buildwithdependencies1.png[title="Captura de tela da Ordem de construção do Reator na janela Saída"]
Os resultados da construção são mostrados também na janela Saída.
image::images/maven-quickstart_maven-buildwithdependencies2.png[title="Captura de tela da Construção bem sucedida do Reator na janela Saída"]
Se observar a janela Projetos, notará que os projetos não possuem mais distintivos porque os artefatos das dependências exigidas agora estão disponíveis no repositório local sob o nó ``com.mycompany`` .
image::images/maven-quickstart_maven-localrepo.png[title="Captura de tela do Repositório local"]
Para executar o projeto, clique com o botão direito no nó projeto do *aplicativo com base na plataforma NetBeans MavenPlatformWordApp* e selecione Executar. Após a ativação do aplicativo, é possível testá-lo executando as etapas a seguir.
[start=1]
1. Selecione Janela > Texto no menu principal do aplicativo da plataforma para abrir a janela Texto.
[start=2]
1. Digite algumas letras minúsculas na área de texto e clique em Filtro!
[start=3]
1. Saia do Maven Platform Word App.
Ao clicar em Filtro!, as letras que digitou serão alteradas para maiúsculas e exibidas na área de texto.
== Criando módulo TextFilter
Neste exercício será criado um módulo chamado *TextFilter* e adicionará o módulo como uma dependência ao aplicativo. O módulo TextFilter fornecerá um serviço e conterá somente uma interface. Então será possível acessar o serviço a partir de seus outros módulos utilizando o objeto Pesquisar.
=== Criando módulo
Neste exercício serão executados as etapas a seguir para criar o módulo TextFilter.
[start=1]
1. Selecione Arquivo > Novo projeto (Ctrl-Shift-N).
[start=2]
1. Selecione o arquétipo do módulo NetBeans Maven na categoria Maven. Clique em Próximo.
[start=3]
1. Digite *TextFilter* como o nome do projeto.
[start=4]
1. Clique no Navegador para definir a localização do projeto e localizar o diretório MavenPlatformWordApp. Clique em Terminar.
Ao clicar em Terminar, o IDE cria o módulo e abre o projeto do módulo *Módulo NetBeans TextFilter * na janela Projetos.
O IDE modifica o arquivo ``pom.xml`` do projeto POM aplicativo da plataforma NetBeans - MavenPlatformWordApp para adicionar o novo módulo à lista de módulos a ser incluída no projeto.
[source,xml]
----
<modules>
<module>branding</module>
<module>application</module>
<module>MavenWordEngine</module>
<module>TextFilter</module>
</modules>
----
Após criar o módulo será necessário adicionar o mesmo como uma dependência do aplicativo.
=== Adicionando Módulo TextFilter como uma dependência do MavenPlatformWordApp
Neste exercício será adicionado o módulo TextFilter como uma dependência do aplicativo com base na plataforma NetBeans MavenPlatformWordApp.
[start=1]
1. Clique com o botão direito do mouse no nó Bibliotecas do projeto*aplicativo com base na plataforma NetBeans - MavenPlatformWordApp* e selecione Adicionar dependência.
[start=2]
1. Clique na aba Abrir projetos na caixa de diálogo Adicionar dependência.
[start=3]
1. Selecione o módulo *Módulo TextFilterNetBeans*. Clique em OK.
Ao clicar em OK, o IDE adiciona o módulo como uma dependência do projeto. Se expandir o nó Biblioteca, poderá notar que o módulo foi adicionado à lista de dependências. No POM para o *aplicativo com base na plataforma NetBeans - MavenPlatformWordApp*, poderá notar que o IDE adicionou as linhas seguintes dentro do elemento ``dependências`` .
[source,xml]
----
<dependency>
<groupId>${project.groupId}</groupId>
<artifactId>TextFilter</artifactId>
<version>${project.version}</version>
</dependency>
----
=== Adicionando uma interface ao módulo TextFilter
Neste exercício será adicionado uma interface simples ao módulo TextFilter.
[start=1]
1. Clique com o botão direito do mouse no *Módulo NetBeans TextFilter* e selecione Nova > Interface Java.
[start=2]
1. Digite *TextFilter* como o nome da classe.
[start=3]
1. Selecione *com.mycompany.textfilter* na lista suspensa Pacote. Clique em Terminar.
[start=4]
1. Modifique a classe para adicionar o código a seguir. Salve as alterações.
[source,java]
----
package com.mycompany.textfilter;
public interface TextFilter {
*public String process(String s);*}
----
=== Tornando público o módulo TextFilter
Neste exercício você tornará público os conteúdos do pacote ``com.mycompany.textfilter`` , de forma que outros módulos possam acessar os métodos. Para declarar um pacote como público, modifique o elemento da ``configuração`` do ``nbm-maven-plugin`` no POM para especificar os pacotes exportados como público pelo plugin. É possível fazer as alterações ao POM no editor ou selecionar os pacotes a se tornarem públicos na caixa de diálogo Propriedades.
[start=1]
1. Clique com o botão direito no *Módulo NetBeans TextFilter* e selecione Propriedades.
[start=2]
1. Selecione a categoria Pacotes públicos na caixa de diálogo Propriedades do projeto.
[start=3]
1. Selecione o pacote *com.mycompany.textfilter*. Clique em OK.
image::images/maven-quickstart_maven-public-packages.png[title="Captura de tela da caixa de diálogo Propriedades"]
Ao clicar em OK, o IDE modifica o projeto POM para modificar o elemento da ``configuração`` do artefato ``nbm-maven-plugin`` para adicionar as seguintes entradas.
[source,xml]
----
<publicPackages>
<publicPackage>com.mycompany.textfilter</publicPackage>
</publicPackages>
----
Agora a entrada do POM contém as seguintes entradas.
[source,xml]
----
<plugin>
<groupId>org.codehaus.mojo</groupId>
<artifactId>nbm-maven-plugin</artifactId>
<version>3.2</version>
<extensions>true</extensions>
<configuration>
<publicPackages>
<publicPackage>com.mycompany.textfilter</publicPackage>
</publicPackages>
</configuration>
</plugin>
----
Para mais informações, consulte link:http://bits.netbeans.org/mavenutilities/nbm-maven-plugin/manifest-mojo.html#publicPackages[manifesto nbm-maven-plugin]
== Criando módulo MyFilter
Neste exercício será criado o módulo *MyFilter* e adicionado como uma dependência do TextFilter. É possível então chamar os métodos no MyFilter pesquisando o serviço TextFilter.
=== Criando módulo
Neste exercício será criado o módulo chamado *MyFilter*. Para criar o módulo, você seguirá os mesmas etapas que executou ao criar o módulo TextFilter.
[start=1]
1. Selecione Arquivo > Novo projeto (Ctrl-Shift-N).
[start=2]
1. Selecione Módulo NetBeans Maven na categoria Maven. Clique em Próximo.
[start=3]
1. Digite *MyFilter* como o nome do projeto.
[start=4]
1. Clique no Navegador para definir a localização do projeto e localizar o diretório *MavenPlatformWordApp*. Clique em Terminar.
[start=5]
1. Adicione o módulo MyFilter como uma dependência do projeto do *aplicativo com base na plataforma NetBeans - MavenPlatformWordApp*.
=== Adicionando módulo TextFilter como uma dependência
Neste exercício será adicionado o módulo TextFilter como uma dependência do módulo MyFilter.
[start=1]
1. Clique com o botão direito do mouse no nó Bibliotecas do projeto *MyFilter* e selecione Adicionar dependência.
[start=2]
1. Clique na aba Abrir projetos na caixa de diálogo Adicionar dependência.
[start=3]
1. Selecione o módulo *TextFilter*. Clique em OK.
=== Modificando módulo MyFilter
Neste exercício será adicionada uma classe Java com um método simples chamado ``processo`` que converte uma string para letra maiúscula. Você também especificará que a classe implementará a interface TextFilter. Você utilizará também uma anotação ``@ServiceProvider`` para especificar que o TextFilter é um serviço que será registrado no tempo de compilação.
[start=1]
1. Clique com o botão direito no módulo *MyFilter* e selecione Nova > Classe Java.
[start=2]
1. Digite *UpperCaseFilter* como o nome da classe.
[start=3]
1. Selecione*com.mycompany.myfilter* na lista suspensa Pacote. Clique em Terminar.
[start=4]
1. Modifique a classe para adicionar o código a seguir. Salve as alterações.
[source,java]
----
package com.mycompany.myfilter;
import com.mycompany.textfilter.TextFilter;
import org.openide.util.lookup.ServiceProvider; *@ServiceProvider(service=TextFilter.class)* public class UpperCaseFilter *implements TextFilter {
public String process(String s) {
return s.toUpperCase();
}*}
----
Observe como a anotação é usada para especificar o provedor do serviço. Para mais informações sobre a anotação do ``@ServiceProvider`` e sobre o funcionamento do mecanismo ServiceceLoader no JDK 6, consulte a documentação dos utilitários API.
=== Modificando módulo MavenWordEngine
Neste exercício será modificado o manipulador de eventos no componente de janela Texto para utilizar um objeto pesquisar para chamar a interface TextFilter e acessar o método no MyFilter. Antes de adicionar o código ao manipulador de eventos é necessário declarar uma dependência no módulo TextFilter.
[start=1]
1. Clique com o botão direito do mouse no nó Bibliotecas no módulo *MavenWordEngine* e adicione uma dependência no módulo TextFilter.
[start=2]
1. Expanda os pacotes Origem do módulo *MavenWordEngine* e abra o ``TextTopComponent`` no editor de origem.
[start=3]
1. Modifique o método manipulador do botão ``jButton1ActionPerformed`` para adicionar o código a seguir. Salve as alterações.
[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);
}
----
É possível utilizar a conclusão do código para obter ajuda com o código.
Nesta fase você pode verificar se seu aplicativo está funcionando corretamente. A seguir, você adicionará um novo componente de janela que exibirá um histórico do texto que processou utilizando o filtro.
== Adicionando objetos LookupListener e InstanceContent para o componente de janela Texto
Neste exercício serão adicionados um listener e um campo para armazenar os conteúdos da área de texto ao clicar no botão "Filtro!".
[start=1]
1. No módulo *MavenWordEngine* adicione o objeto ``InstanceContent`` e modifique o construtor do ``TextTopComponent`` adicionando o código a seguir.
[source,java]
----
public final class TextTopComponent extends TopComponent {
*private InstanceContent content;* public 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. Modifique o método ``jButton1ActionPerformed`` para adicionar um valor antigo do texto ao objeto ``InstanceContent`` quando o botão for clicado.
[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);
}
----
== Criando módulo Histórico
Nesta seção será criado um módulo chamado *Histórico* que exibirá o valor do ``InstanceContent`` . Para criar o módulo, você seguirá os mesmas etapas que executou ao criar os módulos TextFilter e MyFilter.
[start=1]
1. Selecione Arquivo > Novo projeto (Ctrl-Shift-N).
[start=2]
1. Selecione Módulo NetBeans Maven na categoria Maven. Clique em Próximo.
[start=3]
1. Digite *Histórico* como o nome do projeto.
[start=4]
1. Clique no Navegador para definir a localização do projeto e localizar o diretório MavenPlatformWordApp. Clique em Terminar.
[start=5]
1. Adicione o módulo Histórico como uma dependência do projeto do *aplicativo com base na plataforma NetBeans - MavenPlatformWordApp*.
=== Criando um componente de janela no módulo Histórico
Neste exercício será utilizado um assistente para adicionar um componente de janela ao módulo.
[start=1]
1. Clique com o botão direito em *Módulo NetBeans Histórico* na janela Projetos e selecione Novo > Outro para abrir a caixa de diálogo Novo Arquivo.
[start=2]
1. Selecione Janela na categoria Desenvolvimento do módulo. Clique em Próximo.
[start=3]
1. Selecione *editor* na lista suspensa Posição da janela. Clique em Próximo.
[start=4]
1. Digite *Histórico* no campo Prefixo do nome da classe. Clique em Terminar.O assistente exibe uma lista de arquivos que serão criados e dos arquivos que serão modificados.
=== Modificando componente de janela Histórico
Você agora adicionará um elemento da área de texto ao componente de janela que será exibido nas strings filtradas.
[start=1]
1. Clique na aba Desenho do arquivo ``HistoryTopComponent.java`` no editor.
[start=2]
1. Arraste e solte uma área de texto a partir da paleta na janela.
[start=3]
1. Clique com o botão direito do mouse na área de texto e selecione Alterar nome da variável e, a seguir, digite *historyText* como o nome.
[start=4]
1. Adicione o campo ``resultado`` ``privado`` e o código seguinte ao construtor do ``HistoryTopComponent`` de maneira que este observe o objeto pesquisar da classe String da janela ativa atual e exiba todos os objetos String recuperados nesta área de texto.
[source,java]
----
*private Lookup.Result result;* public HistoryTopComponent() {
initComponents();
...
*result = org.openide.util.Utilities.actionsGlobalContext().lookupResult(String.class);
result.addLookupListener(new LookupListener() {
public void resultChanged(LookupEvent e) {
historyText.setText(result.allInstances().toString());
}
});* }
----
== Construindo e Executando aplicativo
Agora é possível testar o aplicativo.
[start=1]
1. Clique com o botão direito no nó Projeto no *aplicativo com base na plataforma NetBeans mavenPlatformWordApp* e selecione Limpar.
[start=2]
1. Clique com o botão direito no nó Projeto no *aplicativo com base na plataforma NetBeans mavenPlatformWordApp* e selecione Construir com dependências.
[start=3]
1. Clique com o botão direito no nó Projeto no *aplicativo com base na plataforma NetBeans mavenPlatformWordApp* e selecione Executar.
Ao clicar em Executar, o IDE ativa o aplicativo da plataforma NetBeans. É possível abrir as janelas Histórico e Texto a no menu Janela.
image::images/maven-quickstart_maven-final-app.png[title="Captura de tela do aplicativo final da plataforma NetBeans"]
Ao digitar o texto na janela Texto e clicar no botão Filtro!, o texto é convertido em letra maiúscula e é adicionado ao conteúdo da janela Histórico.
Este Guia de início rápido demonstra que criar um aplicativo da plataforma NetBeans utilizando Maven, não é muito diferente de criar um aplicativo utilizando Ant. A principal diferença é entender como o POM Maven controla como o aplicativo é montado. Para mais exemplos sobre como construir os aplicativos e módulos da plataforma NetBeans, consulte os tutoriais listados na link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[Trilha de aprendizado da plataforma NetBeans].
== Veja também
Para mais informações sobre a criação e o desenvolvimento dos aplicativos, consulte os recursos a seguir.
* link:https://netbeans.apache.org/kb/docs/platform_pt_BR.html[Trilha de aprendizado da plataforma NetBeans]
* link:http://bits.netbeans.org/dev/javadoc/[Javadoc da API do NetBeans]
Caso tenha alguma dúvida referente á plataforma Netbeans, envie-nos um e-mail para dev@platform.netbeans.org, ou consulte o link:https://mail-archives.apache.org/mod_mbox/netbeans-dev/[arquivo de endereços da plataforma Netbeans].