<!DOCTYPE html PUBLIC "-//W3C//DTD XHTML 1.0 Strict//EN" "http://www.w3.org/TR/xhtml1/DTD/xhtml1-strict.dtd">
<html xmlns="http://www.w3.org/1999/xhtml">
<head>
    <title>Introdu&ccedil;&atilde;o &agrave; Plataforma NetBeans para Plataformas NetBeans 6.8</title>
    <link rel="stylesheet" type="text/css" href="https://netbeans.org/netbeans.css"/>
    <meta name="AUDIENCE" content="NBUSER"/>
    <meta name="TYPE" content="ARTICLE"/>
    <meta name="EXPIRES" content="N"/>
    <meta name="developer" content="gwielenga@netbeans.org"/>
    <meta name="indexed" content="y"/>
   <meta http-equiv="Content-Type" content="text/html; charset=UTF-8">
    <meta name="description"
          content="A short guide to getting started with the NetBeans Platform."/>
       <!--      Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. -->
        <!--     Use is subject to license terms.-->
</head>
<body>

   <h1>In&iacute;cio r&aacute;pido da Plataforma NetBeans</h1>

   <p>Bem-vindo &agrave; <a href="https://platform.netbeans.org/"><b>Plataforma NetBeans</b></a>!</p>

   <p>O principal benef&iacute;cio da plataforma NetBeans &eacute; a sua arquitetura modular. O segunda benef&iacute;cio &eacute; a depend&ecirc;ncia da plataforma NetBeans do kit de ferramentas Swing UI, que &eacute; o kit de ferramentas oficial para criar interfaces do usu&aacute;rio no Java, em combina&ccedil;&atilde;o com o premiado construtor de GUI &quot;Matisse&quot;.</p>
   
   <p>Nesta introdu&ccedil;&atilde;o, voc&ecirc; &eacute; apresentado aos benef&iacute;cios e ao uso da modularidade atrav&eacute;s de um exemplo bem simples, contribu&iacute;do por Thomas W&uuml;rthinger, que no momento &eacute; aluno PhD na Universidade Johannes Kepler em Linz, &Aacute;ustria. Ap&oacute;s ter compreendido os conceitos apresentados nesta introdu&ccedil;&atilde;o, voc&ecirc; estar&aacute; pronto para entrar na <a href="https://netbeans.org/kb/trails/platform_pt_BR.html">Trilha de aprendizado da plataforma NetBeans</a>, que fornece uma rica variedade de tutoriais para muitos diferentes cen&aacute;rios relativos &agrave; plataforma NetBeans.</p>

<p class="tips"> Se for novo na plataforma NetBeans, recomenda-se com &ecirc;nfase que voc&ecirc; assista &agrave; s&eacute;rie de screencasts <a href="https://platform.netbeans.org/tutorials/nbm-10-top-apis.html">As 10 principais APIs do NetBeans</a>.</p>

   <p><b>Conte&uacute;do</b></p>
   <p><img  src="../../images/articles/69/netbeans-stamp7-8-9.png" class="stamp" width="114" height="114" alt="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 6.5, 6.7, 6.8" title="O conte&uacute;do desta p&aacute;gina se aplica ao NetBeans IDE 6.5, 6.7, 6.8" /></p>
      <ul class="toc">
        <li><a href="#single">Um m&oacute;dulo &uacute;nico do aplicativo da plataforma NetBeans</a></li>
        <li><a href="#lookup">Um aplicativo modular que utiliza pesquisa</a></li>
        <li><a href="#listener">LookupListener e InstanceContent</a></li>
      </ul>
         
<p><b>Para seguir este tutorial, os softwares e recursos listados na tabela seguinte s&atilde;o necess&aacute;rios.</b></p>

    <table>
        <tbody>
            <tr>
                <th class="tblheader" scope="col">Software ou recurso</th>
                <th class="tblheader" scope="col">Vers&atilde;o necess&aacute;ria</th>
            </tr> 
            <tr>
                <td class="tbltd1"><a href="https://netbeans.org/downloads/index.html">NetBeans IDE</a></td>
                <td class="tbltd1">vers&atilde;o 6.7 ou superior</td>
            </tr>
            <tr>
                <td class="tbltd1"><a href="http://java.sun.com/javase/downloads/index.jsp">Java Developer Kit (JDK)</a></td>
                <td class="tbltd1">Vers&atilde;o 6 ou<br/>vers&atilde;o 5</td>
            </tr>
        </tbody>
    </table>
 
    <p><b class="notes">Nota:</b> embora seja um produto separado, n&atilde;o &eacute; necess&aacute;rio baixar a plataforma NetBeans separadamente. Normalmente, voc&ecirc; desenvolver&aacute; o aplicativo no IDE e, em seguida, excluir&aacute; os m&oacute;dulos espec&iacute;ficos do IDE, mas que s&atilde;o sup&eacute;rfluos para a seu aplicativo.</p>
    
    <!-- ===================================================================================== -->
 
    <h2 class="tutorial"><a name="single"></a>Um m&oacute;dulo &uacute;nico do aplicativo da plataforma NetBeans</h2>
    
    <p>Come&ccedil;amos criando um novo aplicativo da plataforma NetBeans, contendo um &uacute;nico m&oacute;dulo.</p>
                
    <ol>

         <li>Escolha Arquivo | Novo projeto e, em seguida, M&oacute;dulos do NetBeans. Selecione &quot;Aplicativo da plataforma NetBeans&quot;. O seguinte dever&aacute; ser exibido:
          <p><img src="../../images/tutorials/quickstart-platform/wordapp01.png" alt="Fig 1" /></p>
          <p>Clique em Pr&oacute;ximo.</p></li>
         
         <li>Nomeie seu novo aplicativo como &quot;WordApp&quot; e o torne o projeto principal do IDE:
         <p><img src="../../images/tutorials/quickstart-platform/wordapp02.png" alt="Fig 2" /></p>
         <p class="tips"> O projeto principal do IDE &eacute; iniciado quando o comando &quot;Executar projeto&quot; do projeto global &eacute; chamado.</p>
         <p>Clique em Terminar.</p></li>

         <li>Expanda o novo aplicativo na janela Projetos, clique com o bot&atilde;o direito do mouse no n&oacute; M&oacute;dulos e escolha &quot;Adicionar novo&quot;. Nomeie o novo m&oacute;dulo como &quot;WordEngine&quot;:
         <p><img alt="criar novo m&oacute;dulo" src="../../images/tutorials/quickstart-platform/wordapp03.png" /></p>
              <p>Clique em Pr&oacute;ximo.</p></li>

         <li>Especifique um nome &uacute;nico para o m&oacute;dulo, que &eacute; o nome do c&oacute;digo-base, assim como um nome que ser&aacute; exibido na janela Projetos:
          <p><img alt="especifique um nome" src="../../images/tutorials/quickstart-platform/wordapp04.png" /></p>
          <p>Clique em Terminar. O novo m&oacute;dulo &eacute; criado e sua estrutura &eacute; mostrada na janela Projetos.</p></li>

         <li>Clique com o bot&atilde;o direito no m&oacute;dulo &quot;WordEngine&quot; e escolha Novo | Outro. Na categoria Desenvolvimento de m&oacute;dulo selecione &quot;Componente da janela&quot;:
         <p><img alt="criar nova janela" src="../../images/tutorials/quickstart-platform/wordapp05.png" /></p>

         <p>Clique em Pr&oacute;ximo. O seguinte dever&aacute; ser exibido:</p>
         <p><img alt="criar nova janela" src="../../images/tutorials/quickstart-platform/wordapp06.png" /></p>
         <p>Clique em Pr&oacute;ximo.</p></li>

         <li>Defina o prefixo do nome da classe como &quot;Texto&quot; e o pacote como &quot;org.demo.wordengine&quot;:
         <p><img alt="definir defini&ccedil;&otilde;es" src="../../images/tutorials/quickstart-platform/wordapp07.png" /></p>
         <p>Clique em Terminar. A nova janela &eacute; adicionada na estrutura do c&oacute;digo-fonte de seu m&oacute;dulo junto com alguns arquivos XML subjacentes.</p></li>

         <li>Agora, clique duas vezes no arquivo &quot;TextTopComponent.java&quot; para abrir a visualiza&ccedil;&atilde;o Projetar do construtor de GUI &quot;Matisse&quot;. Use a Paleta (Ctrl-Shift-8) para arrastar e soltar um bot&atilde;o e uma &aacute;rea de texto na janela:

         <p><img alt="paleta" src="../../images/tutorials/quickstart-platform/wordapp15.png" /></p>

         <p>Clique com o bot&atilde;o direito do mouse na &aacute;rea de texto, escolha &quot;Alterar nome da vari&aacute;vel&quot; e, a seguir, a nomeie como &quot;texto&quot;. Esse &eacute; o nome que permitir&aacute; o acesso ao componente de seu c&oacute;digo. Selecione o texto do bot&atilde;o para &quot;Filtrar&quot;.</p></li>
          
         <li>Clique duas vezes no bot&atilde;o, fazendo com que um m&eacute;todo de manipula&ccedil;&atilde;o de eventos seja automaticamente criado no editor de c&oacute;digo-fonte. Esse m&eacute;todo &eacute; chamado sempre que se clica no bot&atilde;o. Substitua o corpo do m&eacute;todo pelo seguinte c&oacute;digo.
<pre class="examplecode">private void jButton1ActionPerformed(java.awt.event.ActionEvent evt) {
   String s = text.getText();
   s = s.toUpperCase();
   text.setText(s);
}</pre></li>

         <li>Clique com o bot&atilde;o direito do mouse no aplicativo e escolha Executar. Fazendo isso, seu novo aplicativo da plataforma NetBeans ser&aacute; iniciado e o m&oacute;dulo ser&aacute; instalado. Seu novo aplicativo deveria se parecer com o seguinte:
         <p><img alt="mostrar novo aplicativo" src="../../images/tutorials/quickstart-platform/wordapp08.png" /></p></li>

         <li>Escolha Janela | Texto, insira um texto na &aacute;rea de texto e clique em &quot;Filtrar!&quot;. Voc&ecirc; dever&aacute; ver que o texto agora &eacute; mostrado em mai&uacute;sculas.
         <p><img alt="mai&uacute;scula" src="../../images/tutorials/quickstart-platform/wordapp09.png" /></p></li>

    </ol>

<p>Voc&ecirc; aprendeu como criar um novo aplicativo da plataforma NetBeans e como adicionar novos m&oacute;dulos no mesmo.</p>

    <!-- ===================================================================================== -->

    <h2 class="tutorial"><a name="lookup"></a>Um aplicativo modular utilizando a pesquisa</h2>

    <p>Criamos dois m&oacute;dulos adicionais. O primeiro novo m&oacute;dulo define um servi&ccedil;o, que o segundo m&oacute;dulo fornece para o m&oacute;dulo que definimos na se&ccedil;&atilde;o anterior.</p>

    <ol>
         <li>Expanda o novo aplicativo na janela Projetos, clique com o bot&atilde;o direito do mouse no n&oacute; M&oacute;dulos e escolha &quot;Adicionar novo&quot;. Nomeie o novo m&oacute;dulo como &quot;TextFilter&quot;, com o nome de c&oacute;digo-base &quot;org.demo.textfilter&quot;, complete o assistente, que adiciona o m&oacute;dulo no aplicativo anteriormente criado, como fez na se&ccedil;&atilde;o anterior.</li>

         <li>Clique com o bot&atilde;o direito do mouse no m&oacute;dulo &quot;TextFilter&quot; e escolha Novo | Interface do Java. Nomeie a interface do Java como &quot;TextFilter&quot;, no pacote &quot;org.demo.textfilter&quot;, e utilize o editor para o defin&iacute;-la da seguinte forma:

<pre class="examplecode">package org.demo.textfilter;

public interface TextFilter {

    String process(String s);

}
    </pre></li>

         <li>Clique com o bot&atilde;o direito do mouse no m&oacute;dulo &quot;TextFilter&quot;, escolha Propriedades e utilize a aba &quot;Vers&atilde;o de API&quot; para especificar que o pacote contendo a interface deveria estar dispon&iacute;vel atrav&eacute;s do aplicativo:

    <p><img src="../../images/tutorials/quickstart-platform/wordapp10.png"/></p></li>

         <li>Crie um terceiro m&oacute;dulo em seu aplicativo, o nomeie como &quot;MyFilter&quot;, com &quot;org.demo.myfilter&quot; como o nome do c&oacute;digo-base.</li>

         <li>Adicione uma depend&ecirc;ncia na caixa de di&aacute;logo propriedades do projeto do m&oacute;dulo &quot;MyFilter&quot; rec&eacute;m-criado para o m&oacute;dulo &quot;TextFilter&quot;:

         <p><img src="../../images/tutorials/quickstart-platform/wordapp11.png"/></p></li>
         
         <li>Por causa da depend&ecirc;ncia acima definida, agora &eacute; poss&iacute;vel implementar a interface definida no segundo m&oacute;dulo:

<pre class="examplecode">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();
    }

}</pre>
<p class="tips"> No momento da compila&ccedil;&atilde;o, a anota&ccedil;&atilde;o @ServiceProvider criar&aacute; uma pasta META-INF/services com um arquivo que registra a sua implementa&ccedil;&atilde;o da interface TextFilter, seguido do mecanismo ServiceLoader do JDK 6. &Eacute; necess&aacute;rio definir uma depend&ecirc;ncia no m&oacute;dulo API de utilit&aacute;rios, que proporciona a anota&ccedil;&atilde;o ServiceProvider.</p></li>
         
         <li>O c&oacute;digo que manuseia um clique no bot&atilde;o Filtrar agora precisa ser modificado, para que um implementador da interface &quot;TextFilter&quot; seja localizado e carregado. Quando tal implementador &eacute; encontrado, ele &eacute; chamado para filtrar o texto.
        <p>Antes de poder fazer isso, precisamos adicionar uma depend&ecirc;ncia na caixa de di&aacute;logo Propriedades do projeto do m&oacute;dulo &quot;WordEngine&quot; para o m&oacute;dulo &quot;TextFilter&quot;:</p>

    <p><img src="../../images/tutorials/quickstart-platform/wordapp12.png"/></p>

<p>Agora, &eacute; poss&iacute;vel carregar as implementa&ccedil;&otilde;es da classe &quot;TextFilter&quot;, conforme ilustrado abaixo:</p>

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

         <p class="tips"> O acima deveria ser feito atrav&eacute;s da classe &quot;ServiceLoader&quot; do JDK 6, com exce&ccedil;&atilde;o que a classe &quot;Lookup&quot; pode ser utilizada em JDK's anteriores ao JDK 6. Al&eacute;m disso, a classe &quot;Lookup&quot; tem um n&uacute;mero de recursos adicionais, como ser&aacute; ilustrado na pr&oacute;xima se&ccedil;&atilde;o.</p>
         </li>
    </ol>

     <p>Agora voc&ecirc; est&aacute; pronto para executar o c&oacute;digo e verificar que tudo funciona como antes. Apesar da funcionalidade ser a mesma, o novo projeto modular oferece uma separa&ccedil;&atilde;o clara entre a interface gr&aacute;fica do usu&aacute;rio e a implementa&ccedil;&atilde;o do filtro. O novo aplicativo tamb&eacute;m pode ser estendido com facilidade, basta adicionar novos provedores de servi&ccedil;os no classpath do aplicativo.</p>

<p>Como um exerc&iacute;cio, o c&oacute;digo &eacute; alterado para que todos os filtros de texto ALL encontrados (use o m&eacute;todo &quot;lookupAll&quot;) sejam aplicados consecutivamente no texto. Por exemplo, adicione uma implementa&ccedil;&atilde;o de filtro de texto que remove todos os espa&ccedil;os em branco e, em seguida, teste o aplicativo resultante.</p>
    
    <!-- ===================================================================================== -->

    <h2 class="tutorial"><a name="listener"></a>LookupListener e InstanceContent</h2>

    <p>Criamos um quarto m&oacute;dulo que recupera de forma din&acirc;mica o texto sempre que clicamos no bot&atilde;o &quot;Filtrar!&quot; bot&atilde;o no nosso primeiro m&oacute;dulo.</p>

    <ol>
         <li>No primeiro m&oacute;dulo, altere o construtor do &quot;TextTopComponent&quot; como segue:

<pre class="examplecode"><b>private InstanceContent content;</b>

private TextTopComponent() {
    initComponents();
    setName(NbBundle.getMessage(TextTopComponent.class, &quot;CTL_TextTopComponent&quot;));
    setToolTipText(NbBundle.getMessage(TextTopComponent.class, &quot;HINT_TextTopComponent&quot;));
//        setIcon(Utilities.loadImage(ICON_PATH, true));

    <b>content = new InstanceContent();
    associateLookup(new AbstractLookup(content));</b>

}</pre></li>

         <li>Altere o c&oacute;digo do bot&atilde;o filtro para que o valor antigo seja adicionado ao objeto <tt>InstanceContent</tt> ao clicar no bot&atilde;o.

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

         <li>Crie um novo m&oacute;dulo denominado &quot;History&quot; com o nome de c&oacute;digo-base de &quot;com.demo.history&quot;.</li>
         <li>No m&oacute;dulo History, crie um novo componente da janela com o prefixo &quot;History&quot;, no pacote &quot;com.demo.history&quot;. Especifique que ele deveria aparecer na posi&ccedil;&atilde;o &quot;editor&quot;. Ap&oacute;s ter criado a janela, adicione uma &aacute;rea de texto nela. Altere o nome da vari&aacute;vel da &aacute;rea de texto para &quot;historyText&quot;.</li>
         
         <li>Adicione o c&oacute;digo ao construtor da classe HistoryTopComponent para que ou&ccedil;a a pesquisa da classe <tt>String</tt> da janela no momento ativa. Ele exibe todos os objetos <tt>String</tt> recuperados na &aacute;rea de texto:

<pre class="examplecode"><b>private Lookup.Result result;</b>

private HistoryTopComponent() {

    ...

    <b>result = org.openide.util.Utilities.actionsGlobalContext().lookupResult(String.class);
    result.addLookupListener(new LookupListener() {
        public void resultChanged(LookupEvent e) {
            historyText.setText(result.allInstances().toString());
        }
    });</b>
}</pre></li>

     <li>&Eacute; poss&iacute;vel ent&atilde;o iniciar o aplicativo e experiment&aacute;-lo. O resultado deveria parecer similar ao mostrado na captura de tela abaixo:

    <p><img src="../../images/tutorials/quickstart-platform/wordapp13.png"/></p>

<p>Como um exerc&iacute;cio, &eacute; poss&iacute;vel alterar o tipo de resultado da pesquisa de <tt>String</tt> para <tt>Object</tt> e ver o que acontece ao selecionar diferentes janelas.</p></li>

 </ol>

     <p>Parab&eacute;ns! Neste est&aacute;gio, com uma pequena codifica&ccedil;&atilde;o, um pequeno exemplo de um aplicativo modular foi criado:</p>

     <p><img src="../../images/tutorials/quickstart-platform/wordapp14.png"/></p>

<p>O aplicativo consiste em 4 m&oacute;dulos. O c&oacute;digo de um m&oacute;dulo pode ser utilizado por outro m&oacute;dulo se (1) o primeiro m&oacute;dulo explicitamente exp&otilde;e pacotes e (2) o segundo m&oacute;dulo define a depend&ecirc;ncia sobre o primeiro m&oacute;dulo. Desta forma, a plataforma NetBeans ajuda a organizar o c&oacute;digo em uma arquitetura modular estrita, assegurando que o c&oacute;digo n&atilde;o seja reutilizado de forma aleat&oacute;ria, mas somente quando h&aacute; contratos definidos entre os m&oacute;dulos que fornecem o c&oacute;digo.</p>

     <p>Em segundo lugar, a classe <tt>Lookup</tt> foi introduzida como um mecanismo para a comunica&ccedil;&atilde;o entre os m&oacute;dulos, como uma extens&atilde;o da abordagem JDK 6 ServiceLoader. As implementa&ccedil;&otilde;es s&atilde;o carregadas atrav&eacute;s de suas interfaces. Sem utilizar qualquer c&oacute;digo de uma implementa&ccedil;&atilde;o, o m&oacute;dulo &quot;WordEngine&quot; &eacute; capaz de exibir o servi&ccedil;o fornecido pelo implementador. O acoplamento fraco &eacute; fornecido desta forma para a plataforma NetBeans.</p>

<p class="tips"> Para saber mais sobre a modularidade e sobre a plataforma NetBeans, v&aacute; para a 4&ordf; parte das s&eacute;ries &quot;Gerenciamento de sele&ccedil;&atilde;o da plataforma NetBeans&quot;, <a href="https://platform.netbeans.org/tutorials/nbm-selection-1.html">que come&ccedil;a aqui</a>. Ap&oacute;s isso, inicie com a <a href="https://netbeans.org/kb/trails/platform_pt_BR.html">Trilha de aprendizado da plataforma NetBeans</a>, escolhendo os tutoriais que sejam mais relevantes para seu cen&aacute;rio administrativo particular. Al&eacute;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 <a href="https://netbeans.org/projects/platform/lists/dev/archive">est&aacute; aqui</a>.</p>

 <p>Divirta-se com a plataforma NetBeans e nos veremos na lista de correio!</p>

 

</body>

</html>
