| <!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" |
| "http://www.w3.org/TR/html4/loose.dtd"> |
| |
| <html> |
| <head> |
| <!-- -*- xhtml -*- --> |
| <title>Tutorial do aplicativo NetBeans CRUD para a plataforma NetBeans 6.5</title> |
| <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 guide describing how to create a CRUD application on |
| NetBeans Platform 6.5."> |
| <link rel="stylesheet" type="text/css" href="https://netbeans.org/netbeans.css"> |
| <!-- Copyright (c) 2009, 2010, Oracle and/or its affiliates. All rights reserved. --> |
| <!-- Use is subject to license terms.--> |
| </head> |
| |
| <body> |
| <h1><a name="top"></a>Tutorial do aplicativo CRUD para a plataforma NetBeans</h1> |
| |
| <p>Este tutorial mostra como integrar um banco de dados Java DB com um aplicativo da plataforma NetBeans. Começamos por explorar um banco de dados Java DB, do qual criamos uma classe de entidade. No entanto, observe que estas instruções não são aplicáveis somente ao Java DB. Ao invés disso, elas são relevantes para qualquer banco de dados relacional suportado pelo NetBeans IDE. A seguir, colocamos as classes da entidade em um módulo, junto com os módulos dos JPA JARS relacionados. |
| |
| <p>Uma vez que os módulos acima fizerem parte do nosso aplicativo, criamos um novo módulo que fornece a interface do usuário para o nosso aplicativo. O novo módulo fornece ao usuário uma hierarquia em árvore mostrando os dados do banco de dados. Nós então criamos outro módulo que permite que o usuário edite os dados exibidos pelo primeiro módulo. Ao separar o visualizador do editor em módulos distintos, permitimos que o usuário instale um editor diferente para o mesmo visualizador, já que editores diferentes poderiam ser criados por fornecedores externos, alguns comercialmente e alguns sem custo. É esta a flexibilidade que a arquitetura modular da plataforma NetBeans torna possível. |
| |
| <p>Uma vez que tivermos um editor, começamos a adicionar a funcionalidade CRUD. Primeiro, o "R" que indica "Read" (ler) é manipulado pelo visualizador acima descrito. A seguir, é manipulado o "U" para "Update" (atualizar), seguido pelo "C" para "Create" (criar) e pelo "D" para "Delete" (excluir). |
| |
| <p>Ao final do tutorial, você terá aprendido sobre a gama de recursos da plataforma NetBeans que lhe ajudam na criação de aplicativos deste tipo. Por exemplo, você aprendeu sobre o <tt><a href="http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/UndoRedo.Manager.html">UndoRedo.Manager</a></tt> e o <tt><a href="http://bits.netbeans.org/dev/javadoc/org-openide-explorer/org/openide/explorer/ExplorerManager.html">ExplorerManager</a></tt>, assim como sobre os componentes Swing da plataforma NetBeans, tais como <tt><a href="http://bits.netbeans.org/dev/javadoc/org-openide-windows/org/openide/windows/TopComponent.html">TopComponent</a></tt> e <tt><a href="http://bits.netbeans.org/dev/javadoc/org-openide-explorer/org/openide/explorer/view/BeanTreeView.html">BeanTreeView</a></tt>. |
| |
| <p><b class="notes">Nota:</b> este documento usa a versão NetBeans IDE 6.8. Se você estiver utilizando uma versão anterior, veja <a href="67/nbm-crud.html">a versão 6.7 deste documento</a>.</p> |
| |
| <p><b>Conteúdo</b></p> |
| |
| <p><img src="../images/articles/69/netbeans-stamp8-9.png" class="stamp" width="114" height="114" alt="O conteúdo desta página se aplica ao NetBeans IDE 6.5, 6.7, 6.8" title="O conteúdo desta página se aplica ao NetBeans IDE 6.5, 6.7, 6.8" /></p> |
| <ul class="toc"> |
| <li><a href="#creating-app">Configurando o aplicativo</a></li> |
| <li><a href="#integrating-database">Integrando o banco de dados</a> |
| <ul> |
| <li><a href="#creating-entity">Criando classes de entidade de um banco de dados</a></li> |
| <li><a href="#wrapping-entity">Colocando a classe da entidade JAR em um módulo</a></li> |
| <li><a href="#creating-other">Criando outros módulos relacionados</a></li> |
| <li><a href="#designing-ui">Projetando a interface do usuário</a></li> |
| <li><a href="#setting-dependencies">Configurando as dependências</a></li> |
| <li><a href="#running-prototype">Executando o protótipo</a></li> |
| </ul> |
| <li><a href="#integrating-crud">Integrando a funcionalidade CRUD</a> |
| <ul> |
| <li><a href="#read">Ler</a></li> |
| <li><a href="#update">Atualizar</a></li> |
| <li><a href="#create">Criar</a></li> |
| <li><a href="#delete">Excluir</a></li> |
| </ul> |
| </li> |
| </ul> |
| |
| <p><b>Para seguir este tutorial, os softwares e recursos listados na tabela seguinte são necessários.</b></p> |
| |
| <table> |
| <tbody> |
| <tr> |
| <th class="tblheader" scope="col">Software ou recurso</th> |
| <th class="tblheader" scope="col">Versão necessária</th> |
| </tr> |
| <tr> |
| <td class="tbltd1"><a href="https://netbeans.org/downloads/index.html">NetBeans IDE</a></td> |
| <td class="tbltd1">versão 6.8</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ão 6 ou<br/>versão 5</td> |
| </tr> |
| </tbody> |
| </table> |
| |
| <p>O aplicativo que você criará neste tutorial terá esta aparência:</p> |
| |
| <p><img alt="o estado final do aplicativo" src="http://netbeans.dzone.com/sites/all/files/customer-app-on-nb.png" /> </p> |
| |
| <p class="tips"> É aconselhável assistir à série de screencasts <a href="https://platform.netbeans.org/tutorials/nbm-10-top-apis.html">As 10 principais APIs do NetBeans</a> antes de começar a trabalhar neste tutorial. Muitos dos conceitos tratados neste tutorial são discutidos em maior detalhe dentro da série de screencasts. |
| |
| |
| <p> |
| <!-- ===================================================================================== --> |
| |
| <br> |
| <h2 class="tutorial"><a name="creating-app"></a>Configurando o aplicativo</h2> |
| |
| <p>Vamos começar criando um novo aplicativo NetBeans. |
| |
| <ol> |
| <li>Escolha Arquivo > Novo projeto (Ctrl-Shift-N). Em Categorias, selecione Módulos do NetBeans. Em Projetos, selecione Aplicativo da plataforma NetBeans. Clique em Próximo.</li> |
| <li>No painel Nome e localização, digite <tt>DBManager</tt> no campo Nome do projeto. Clique em Terminar.</li> |
| </ol> |
| |
| <p>O IDE cria o projeto <tt>DBManager</tt>. O projeto é um contêiner para todos os outros módulos que você criará. |
| |
| <p><img alt="Contêiner da plataforma NetBeans" src="../images/tutorials/crud/68dbmanager-1.png" /> </p> |
| |
| <br> |
| |
| <!-- ===================================================================================== --> |
| |
| <br> |
| <h2><a name="integrating-database"></a>Integrando o banco de dados</h2> |
| |
| <p>Para poder integrar o banco de dados, é preciso criar classes de entidades de seu banco de dados e integrar essas classes de entidades, junto com seus JARs relacionados, com os módulos que fazem parte de seu aplicativo da plataforma NetBeans.</p> |
| |
| <div class="indent"> |
| <h3 class="tutorial"><a name="creating-entity"></a>Criando as classes de entidade</h3> |
| <p>Nesta seção, você gera classes de entidade de um banco de dados selecionado. |
| <ol> |
| <li>Neste exemplo, utilize a janela Serviços para conectar-se ao banco de dados de amostra que está incluído no NetBeans IDE: |
| |
| <p><img alt="janela Serviços" src="../images/tutorials/crud/68dbmanager-2.png" /> </p> |
| |
| <p class="tips"> Alternativamente, use qualquer banco de dados que desejar e adapte as etapas que se seguem para seu caso particular. No caso do MySQL, consulte <a href="https://netbeans.org/kb/docs/ide/mysql_pt_BR.html">Conectando-se a um banco de dados MySQL</a>.</p> |
| <p><li>No IDE, escolha Arquivo | Novo projeto, seguido por Java | Biblioteca de classes Java, para criar uma nova biblioteca denominada <tt>CustomerLibrary</tt>. |
| <p><li>Na janela Projetos, clique com o botão direito do mouse no projeto da biblioteca e escolha Arquivo | Novo arquivo, seguido por Persistência | Classes de entidade do banco de dados. No assistente, selecione o banco de dados e as tabelas necessárias. Aqui, escolhemos "Customer" e, a seguir, "Discount Code" é adicionado automaticamente, dado que há uma relação entre estas duas tabelas. |
| |
| <p><img alt="adicionando tabelas" src="../images/tutorials/crud/68dbmanager-3.png" /> </p> |
| |
| |
| <p><li>Especifique a estratégia de persistência, que pode ser qualquer uma das opções disponíveis. Aqui, visto que precisamos escolher algo, escolheremos EclipseLink: |
| |
| <p><img alt="escolhendo eclipselink" src="../images/tutorials/crud/68dbmanager-4.png" /> </p> |
| |
| |
| <p><li>Especifique "demo" como o nome do pacote no qual as classes de entidade serão geradas. |
| <p><img alt="nome do pacote" src="../images/tutorials/crud/68dbmanager-5.png" /> </p> |
| |
| <p><li>Clique em Terminar. Após ter completado esta etapa, examine o código gerado e observe que, entre outras coisas, você agora tem um arquivo <tt>persistence.xml</tt> em uma pasta denominada META-INF, assim como as classes de entidade para cada uma de suas tabelas: |
| |
| <p><img alt="classes de entidade" src="../images/tutorials/crud/68dbmanager-7.png" /> </p> |
| |
| <p><li>Construa a biblioteca Java e você terá um arquivo JAR na pasta "dist" do projeto da biblioteca, a qual poderá visualizar na janela Arquivos: |
| |
| <p><img alt="pasta dist" src="../images/tutorials/crud/68dbmanager-8.png" /> </p> |
| |
| </li> |
| </ol> |
| |
| <h3 class="tutorial"><a name="wrapping-entity"></a>Colocando a classe da entidade JAR em um módulo</h3> |
| <p>Nesta seção, você adiciona seu primeiro módulo ao aplicativo! O novo módulo NetBeans conterá o arquivo JAR que você criou na seção anterior. |
| <ol> |
| <li>Clique com o botão direito do mouse no nó do módulo <tt>DBManager</tt> na janela Projetos e escolha Adicionar nova biblioteca. |
| <p><li>Selecione o JAR criado na subseção anterior e complete o assistente, especificando quaisquer valores que desejar. Vamos supor que o aplicativo destina-se a tratar com clientes no shop.org, em cujo caso um identificador único "org.shop.model" é apropriado para o nome de base do código: |
| |
| <p><img alt="id único do módulo" src="../images/tutorials/crud/68dbmanager-9.png" /> </p> |
| |
| </ol> |
| <p>Você agora tem seu primeiro módulo personalizado no novo aplicativo, contendo o JAR que contém as classes de entidade e o arquivo persistence.xml:</p> |
| |
| <p><img alt="persistence.xml" src="../images/tutorials/crud/68dbmanager-91.png" /> </p> |
| |
| <h3 class="tutorial"><a name="creating-other"></a>Criando outros módulos relacionados</h3> |
| <p>Nesta seção, você cria dois novos módulos, colocando o EclipseLinks JARs, assim como o JAR do conector do banco de dados. |
| <ol> |
| <li>Faça o mesmo que fez ao criar o wrapper de bibliotecas para a classe de entidade JAR, mas desta vez para os JARs de EclipseLink, que estão na biblioteca Java "CustomerLibrary" criada anteriormente: |
| |
| <p><img alt="empacotando um biblioteca" src="../images/tutorials/crud/68dbmanager-94.png" /></p> |
| |
| |
| <p class="tips"> No assistente para módulo de wrapper de bibliotecas, você pode usar Ctrl-clique para selecionar vários JARs.</p> |
| |
| <p><li>A seguir, crie outro módulo de wrapper de bibliotecas, desta vez para o JAR cliente do banco de dados Java DB, que está disponível na sua distribuição do JDK em <tt>db/lib/derbyclient.jar</tt>. |
| </ol> |
| |
| <h3 class="tutorial"><a name="designing-ui"></a>Projetando a interface do usuário</h3> |
| <p>Nesta seção, você cria um protótipo simples de interface do usuário, fornecendo uma janela que usa uma <tt>JTextArea</tt> para exibir os dados recuperados do banco de dados. |
| <ol> |
| <li>Clique com o botão direito do mouse no nó do módulo <tt>DBManager</tt> na janela Projetos e escolha Adicionar novo. Crie um novo módulo denominado <tt>CustomerViewer</tt>, com o nome de base de código <tt>org.shop.ui</tt>. |
| <p><li>Na janela Projetos, clique com o botão direito do mouse no novo módulo e escolha Novo | Componente de janela. Especifique que ele deve ser criado na posição do <tt>editor</tt> e que deve ser aberto quando o aplicativo for iniciado. Defina <tt>Customer</tt> como o prefixo do nome da classe da janela. |
| <p><li>Utilize a paleta (Ctrl-Shift-8) para arrastar e soltar uma <tt>JTextArea</tt> na nova janela: |
| |
| <p><img alt="JTextArea selecionado" src="../images/tutorials/crud/68dbmanager-93.png" /></p> |
| |
| <p><li>Adicione isso no fim do construtor TopComponent: |
| <pre class="examplecode">EntityManager entityManager = Persistence.createEntityManagerFactory("CustomerLibraryPU").createEntityManager(); |
| Query query = entityManager.createQuery("SELECT c FROM Customer c"); |
| List<Customer> resultList = query.getResultList(); |
| for (Customer c : resultList) { |
| jTextArea1.append(c.getName() + " (" + c.getCity() + ")" + "\n"); |
| }</pre> |
| |
| <p class="tips"> Como você não definiu dependências no módulo que fornece o objeto Customer e as JARS de persistência, as declarações acima serão marcadas com linhas sublinhadas em vermelho indicando o erro. Esses serão corrigidos na seção que segue.</p> |
| |
| <p>Acima, é possível ver as referências à unidade de persistência denominada "CustomerLibraryPU", que é o mesmo nome definido no arquivo <tt>persistence.xml</tt>. Além disso, há uma referência a uma das classes de entidade, denominada <tt>Customer</tt>, que está no módulo de classes de entidade. Adapte estas partes às suas necessidades caso sejam diferentes das de cima. |
| |
| </ol> |
| |
| <h3 class="tutorial"><a name="setting-dependencies"></a>Configurando as dependências</h3> |
| <p>Nesta seção, você habilita alguns dos módulos para utilizar o código de alguns dos outros módulos. Você faz isso de forma bem explícita ao definir contratos intencionais entre módulos relacionados, ou seja, o oposto à reutilização acidental e caótica do código, que tende a acontecer quando não há uma arquitetura modular estrita, como a fornecida pela plataforma NetBeans. |
| <ol> |
| <li>O módulo de classes de entidade precisa ter dependências no módulo Derby Client, assim como no módulo EclipseLink. Clique com o botão direito do mouse no módulo <tt>CustomerLibrary</tt>, escolha Propriedades e utilize a aba Bibliotecas para definir as dependências nos dois módulos que o módulo <tt>CustomerLibrary</tt> necessita. |
| <p><li>O módulo <tt>CustomerViewer</tt> precisa de uma dependência no módulo EclipseLink, assim como no módulo de classes de entidade. Clique com o botão direito do mouse no módulo <tt>CustomerViewer</tt>, escolha Propriedades e utilize a aba Bibliotecas para definir as dependências nos dois módulos que o módulo <tt>CustomerViewer</tt> necessita. |
| <p><li>Abra o <tt>CustomerTopComponent</tt> na visualização Código-fonte, clique com o botão direito do mouse no editor e escolha "Corrigir importações". O IDE agora é capaz de adicionar as declarações importadas, porque os módulos que fornecem as classes necessárias agora estão disponíveis no <tt>CustomerTopComponent</tt>. |
| </ol> |
| <p>Você agora definiu os contratos entre os módulos em seu aplicativo, fornecendo-lhe o controle sobre as dependências entre as distintas partes do código. |
| |
| <h3 class="tutorial"><a name="running-prototype"></a>Executando o protótipo</h3> |
| <p>Nesta seção, você executa o aplicativo para que possa ver se está acessando corretamente seu banco de dados. |
| <ol> |
| <li>Inicie seu servidor de banco de dados. |
| <p><li>Execute o aplicativo. O seguinte deverá ser exibido: |
| |
| <p><img alt="executando o protótipo" src="../images/tutorials/crud/68dbmanager-92.png" /></p> |
| </ol> |
| <p>Você agora tem um protótipo simples que compreende um aplicativo da plataforma NetBeans que exibe os dados do seu banco de dados, o qual será ampliado na próxima seção. |
| |
| </div> |
| |
| <br> |
| <h2><a name="integrating-crud"></a>Integrando a funcionalidade CRUD</h2> |
| |
| <p>Para poder criar a funcionalidade CRUD que se integra com suavidade à plataforma NetBeans, alguns padrões bem específicos de codificação da plataforma NetBeans precisam ser implementados. A seção que segue descreve esses padrões em detalhes.</p> |
| |
| <div class="indent"> |
| |
| <h3 class="tutorial"><a name="read"></a>Ler</h3> |
| <p>Nesta seção, você altera a <tt>JTextArea</tt>, apresentada na seção anterior, para uma visualização do explorador da plataforma NetBeans. As visualizações do explorador da plataforma NetBeans são componentes Swing que se integram melhor com a plataforma NetBeans do que os componentes padrão do Swing. Entre outras coisas, elas oferecem suporte à noção de um contexto, o que permite que elas detectem o contexto. |
| <p>Ao representar seus dados, você terá um modelo hierárquico genérico fornecido por uma classe <tt>Node</tt> da plataforma NetBeans, que pode ser exibido por quaisquer das visualizações do explorador da plataforma NetBeans. Esta seção termina com uma explicação de como sincronizar as visualizações do explorador com a janela Propriedades da plataforma NetBeans. |
| <ol> |
| <li>Em seu <tt>TopComponent</tt>, exclua a <tt>JTextArea</tt> na visualização Desenho e comente seu código relacionado na visualização Código-fonte: |
| |
| <pre class="examplecode">EntityManager entityManager = Persistence.createEntityManagerFactory("CustomerLibraryPU").createEntityManager(); |
| Query query = entityManager.createQuery("SELECT c FROM Customer c"); |
| List<Customer> resultList = query.getResultList(); |
| //for (Customer c : resultList) { |
| // jTextArea1.append(c.getName() + " (" + c.getCity() + ")" + "\n"); |
| //}</pre> |
| |
| <p><li>Clique com o botão direito do mouse no módulo <tt>CustomerViewer</tt>, escolha Propriedades e use a aba Bibliotecas para definir as dependências nos nós da API e a API do explorador e da folha de propriedades. |
| |
| <p><li>A seguir, altere a assinatura da classe para implementar o <tt>ExplorerManager.Provider</tt>: |
| |
| <pre class="examplecode">final class CustomerTopComponent extends TopComponent implements ExplorerManager.Provider</pre> |
| |
| <p>Será necessário sobrepor o <tt>getExplorerManager()</tt> |
| |
| <pre class="examplecode">@Override
|
| public ExplorerManager getExplorerManager() {
|
| return em;
|
| }</pre> |
| |
| <p>Acima da classe, declare e inicialize o <tt>ExplorerManager</tt>: |
| |
| <pre class="examplecode">private static ExplorerManager em = new ExplorerManager();</pre> |
| |
| <p class="tips"> Assista <a href="https://platform.netbeans.org/tutorials/nbm-10-top-apis.html">As 10 principais APIs do NetBeans</a> para obter os detalhes para o código acima, especialmente o screencast que trata dos nós da API e da API do explorador e da folha de propriedades. |
| |
| <p><li>Alterne para a visualização Desenho do <tt>TopComponent</tt> , clique com o botão direito do mouse na paleta, escolha Gerenciador de paleta | Adicionar do JAR. A seguir, vá a <tt>org-openide-explorer.jar</tt>, que está na pasta <tt>platform11/modules</tt>, dentro do diretório de instalação do NetBeans IDE. Feche a BeanTreeView e complete o assistente. Agora você deveria ver a <tt>BeanTreeView</tt> na paleta. Arraste-a da paleta e solte-a na janela. |
| |
| <p><li>Crie uma classe de fábrica que criará um novo <a href="http://bits.netbeans.org/dev/javadoc/org-netbeans-modules-db/org/netbeans/api/db/explorer/node/BaseNode.html">BeanNode</a> para cada cliente do seu banco de dados: |
| |
| <pre class="examplecode">import demo.Customer; |
| import java.beans.IntrospectionException; |
| import java.util.List; |
| import org.openide.nodes.BeanNode; |
| import org.openide.nodes.ChildFactory; |
| import org.openide.nodes.Node; |
| import org.openide.util.Exceptions; |
| |
| public class CustomerChildFactory extends ChildFactory<Customer> { |
| |
| private List<Customer> resultList; |
| |
| public CustomerChildFactory(List<Customer> resultList) { |
| this.resultList = resultList; |
| } |
| |
| @Override |
| protected boolean createKeys(List<Customer> list) { |
| for (Customer Customer : resultList) { |
| list.add(Customer); |
| } |
| return true; |
| } |
| |
| @Override |
| protected Node createNodeForKey(Customer c) { |
| try { |
| return new BeanNode(c); |
| } catch (IntrospectionException ex) { |
| Exceptions.printStackTrace(ex); |
| return null; |
| } |
| } |
| |
| }</pre> |
| <p><li>De volta ao <tt>CustomerTopComponent</tt>, utilize o <tt>ExplorerManager</tt> para passar a lista de resultados da consulta JPA para <tt>Node</tt>: |
| |
| <pre class="examplecode">EntityManager entityManager = Persistence.createEntityManagerFactory("CustomerLibraryPU").createEntityManager(); |
| Query query = entityManager.createQuery("SELECT c FROM Customer c"); |
| List<Customer> resultList = query.getResultList(); |
| <b>em.setRootContext(new AbstractNode(Children.create(new CustomerChildFactory(resultList), true)));</b> |
| //for (Customer c : resultList) { |
| // jTextArea1.append(c.getName() + " (" + c.getCity() + ")" + "\n"); |
| //}</pre> |
| |
| <p><li>Execute o aplicativo. Quando o aplicativo estiver sendo executado abra a janela Propriedades. Observe que embora os dados estejam disponíveis, exibidos em uma <tt>BeanTreeView</tt>, a <tt>BeanTreeView</tt> não está sincronizada com a janela Propriedades, que está disponível através de Janela | Propriedades. Em outras palavras, nada é exibido na janela Propriedades quando você move acima e abaixo na hierarquia da árvore. |
| |
| <p><li>Sincronize a janela Propriedades com <tt>BeanTreeView</tt> ao adicionar o seguinte construtor no <tt>TopComponent</tt>: |
| |
| <pre class="examplecode">associateLookup(ExplorerUtils.createLookup(em, getActionMap()));</pre> |
| |
| <p>Aqui adicionamos, do <tt>TopComponent</tt>, o <tt>ActionMap</tt> e o <tt>ExplorerManager</tt> ao <tt>Lookup</tt> do <tt>TopComponent</tt>. Uma consequência disso, é que a janela Propriedades começa a exibir o nome e o texto da dica de ferramenta do <tt>Node</tt> selecionado. |
| |
| <p><li>Execute novamente o aplicativo e observe que a janela Propriedades agora está sincronizada com a visualização do explorador: |
| |
| <p><img alt="sincronização" src="../images/tutorials/crud/68dbmanager-95.png" /> |
| |
| </ol> |
| <p>Agora você pode visualizar seus dados na hierarquia da árvore, assim como deveria ser capaz de fazer com um <tt>JTree</tt>. No entanto, também é possível alternar entre diferentes visualizações do explorador sem a necessidade de alterar nada no modelo porque o <tt>ExplorerManager</tt> faz a mediação entre o modelo e a visualização. Finalmente, agora também é possível sincronizar a visualização com a janela Propriedades. |
| |
| <h3 class="tutorial"><a name="update"></a>Atualizar</h3> |
| <p>Nesta seção, primeiramente é criado um editor. O editor será fornecido por um novo módulo do NetBeans. Portanto, primeiramente é criado um novo módulo. A seguir, dentro daquele novo módulo, criará um novo <tt>TopComponent</tt>, contendo dois <tt>JTextFields</tt>, em cada uma das colunas que deseja permitir que sejam editadas pelo usuário. Será necessário deixar que o módulo do visualizador se comunique com o módulo do editor. Sempre que um novo <tt>Node</tt> for selecionado no módulo do visualizador, você adicionará o objeto <tt>Customer</tt> atual ao <tt>Lookup</tt>. No módulo do editor, você ouvirá o <tt>Lookup</tt> para a apresentação dos objetos <tt>Customer</tt>. Sempre que um novo objeto <tt>Customer</tt> for introduzido no <tt>Lookup</tt>, você atualizará o <tt>JTextFields</tt> no editor. |
| <p>A seguir, você sincronizará seu <tt>JTextFields</tt> com a funcionalidade de Desfazer, Refazer e Salvar da plataforma NetBeans. Em outras palavras, quando o usuário faz alterações em um <tt>JTextField</tt>, você deseja que a funcionalidade existente da plataforma NetBeans se torne disponível para que, em vez de ter que criar uma nova funcionalidade, você tenha somente que utilizar o suporte da plataforma NetBeans. Para esse fim, será necessário usar o <tt>UndoRedoManager</tt> junto com o <tt>SaveCookie</tt>. |
| <ol> |
| <li>Crie um novo módulo denominado <tt>CustomerEditor</tt> com o <tt>org.shop.editor</tt> como o nome de base do código. |
| <p><li>Clique com o botão direito do mouse no módulo <tt>CustomerEditor</tt> e escolha Novo | Componente de janela. Certifique-se de especificar que a janela deve aparecer na posição do <tt>editor</tt> e que deve abrir quando o aplicativo for iniciado. No painel final do assistente, defina "Editor" como o prefixo do nome da classe. |
| <p><li>Utilize a paleta (Ctrl-Shift-8) para adicionar dois <tt>JLabels</tt> e dois <tt>JTextFields</tt> na nova janela. Defina os textos dos rótulos como "Nome" e "Cidade" e defina os nomes das variáveis dos dois <tt>JTextFields</tt> como <tt>jTextField1</tt> e <tt>jTextField2</tt>. |
| |
| <p>No construtor de GUI, a janela agora deve se parecer com a figura seguinte:</p> |
| |
| <p><img alt="projetando a interface do usuário" src="../images/tutorials/crud/68dbmanager-96.png" /></p> |
| |
| <p><li>Volte para o módulo <tt>CustomerViewer</tt> e altere o arquivo <tt>layer.xml</tt> para que especifique que a janela <tt>CustomerTopComponent</tt> aparecerá no modo <tt>explorer</tt>. |
| |
| <p class="tips"> Clique com o botão direito do mouse no projeto do aplicativo e escolha "Limpar", após alterar o arquivo <tt>layer.xml</tt>. Por que? Porque sempre que você executa o aplicativo e o fecha, as posições da janela são armazenadas no diretório do usuário. Portanto, se o <tt>CustomerViewer</tt> foi inicialmente exibido no modo <tt>editor</tt>, ele permanecerá no modo <tt>editor</tt> até que você faça "Limpar", redefinindo, assim, o diretório do usuário (ou seja, <i>excluindo</i> o diretório do usuário) e permitindo que o <tt>CustomerViewer</tt> seja exibido na posição definida atualmente no arquivo <tt>layer.xml</tt>.</p> |
| |
| |
| <p>Verifique também se <tt>BeanTreeView</tt> no <tt>CustomerViewer</tt> será ampliada na horizontal e na vertical quando o usuário redimensionar o aplicativo. Verifique isso abrindo a janela, selecionando <tt>BeanTreeView</tt> e clicando nos botões de seta na barra de ferramentas do construtor da GUI. |
| |
| <li>Execute o aplicativo e certifique-se de ver o seguinte quando o aplicativo se iniciar: |
| |
| <p><img alt="executando a nova UI" src="../images/tutorials/crud/68dbmanager-97.png" /></p> |
| |
| |
| <li>Agora podemos começar a adicionar alguns códigos. Primeiramente, precisamos mostrar no editor o objeto Customer atualmente selecionado: |
| <ul> |
| <li>Inicie por adaptar o módulo <tt>CustomerViewer</tt> para que o objeto <tt>Customer</tt> atual seja adicionado ao <tt>Lookup</tt> da janela do visualizador sempre que um novo <tt>Node</tt> for selecionado. Para isso, crie um <tt>AbstractNode</tt>, em vez de um <tt>BeanNode</tt>, na classe <tt>CustomerChildFactory</tt>. Isso permite adicionar o objeto <tt>Customer</tt> atual ao <tt>Lookup</tt> do Node, conforme ilustrado a seguir (observe a parte em negrito): |
| |
| <pre class="examplecode">@Override |
| protected Node createNodeForKey(Customer c) { |
| Node node = new AbstractNode(Children.LEAF, Lookups.singleton(c)); |
| node.setDisplayName(c.getName()); |
| node.setShortDescription(c.getCity()); |
| return node; |
| // try { |
| // return new BeanNode(c); |
| // } catch (IntrospectionException ex) { |
| // Exceptions.printStackTrace(ex); |
| // return null; |
| // } |
| }</pre> |
| |
| <p>Agora, sempre que um novo <tt>Node</tt> for criado, o que acontece sempre que o usuário seleciona um novo estado no visualizador, um novo objeto <tt>Customer</tt> é adicionado ao <tt>Lookup</tt> do <tt>Node</tt>. |
| |
| <p><li>Agora vamos alterar o módulo do editor de tal forma que sua janela detecte os objetos <tt>Customer</tt> que são adicionados ao <tt>Lookup</tt>. Primeiro, defina uma dependência no módulo do editor que fornece a classe da entidade, bem como o módulo que fornece os JARS de persistência. |
| |
| <p><li>A seguir, altere a assinatura da classe <tt>EditorTopComponente</tt> para implementar o <tt>LookupListener</tt>: |
| |
| <pre class="examplecode">public final class EditorTopComponent extends TopComponent implements LookupListener</pre> |
| |
| <p><li>Substitua o <tt>resultChanged</tt> para que os <tt>JTextFields</tt> sejam atualizados sempre que um novo objeto <tt>Customer</tt> for introduzido no <tt>Lookup</tt>: |
| |
| <pre class="examplecode">@Override |
| public void resultChanged(LookupEvent lookupEvent) { |
| Lookup.Result r = (Lookup.Result) lookupEvent.getSource(); |
| Collection<Customer> coll = r.allInstances(); |
| if (!coll.isEmpty()) { |
| for (Customer cust : coll) { |
| jTextField1.setText(cust.getName()); |
| jTextField2.setText(cust.getCity()); |
| } |
| } else { |
| jTextField1.setText("[no name]"); |
| jTextField2.setText("[no city]"); |
| } |
| }</pre> |
| |
| <p><li>Agora que o <tt>LookupListener</tt> está definido, precisamos adicioná-lo a algo. Aqui, nós o adicionamos ao <tt>Lookup.Result</tt> obtido do contexto global. Os proxies do contexto global do contexto do <tt>Node</tt> selecionado. Por exemplo, se "Ford Motor Co" for selecionado na hierarquia da árvore, o objeto <tt>Customer</tt> de "Ford Motor Co" é adicionado ao <tt>Lookup</tt> do <tt>Node</tt> que, por ser o <tt>Node</tt> atualmente selecionado, significa que o objeto <tt>Customer</tt> de "Ford Motor Co" agora está disponível no contexto global. Isso é, então, passado para o <tt>resultChanged</tt>, fazendo com que os campos de texto sejam preenchidos. |
| |
| <p>Todo o acima começa a acontecer, ou seja, o <tt>LookupListener</tt> se torna ativo sempre que a janela do editor for aberta, como pode ser visto abaixo:</p> |
| |
| <pre class="examplecode">@Override |
| public void componentOpened() { |
| result = Utilities.actionsGlobalContext().lookupResult(Customer.class); |
| result.addLookupListener(this); |
| resultChanged(new LookupEvent(result)); |
| } |
| |
| @Override |
| public void componentClosed() { |
| result.removeLookupListener(this); |
| result = null; |
| }</pre> |
| |
| <p>Como a janela do editor é aberta quando o aplicativo é iniciado, o <tt>LookupListener</tt> está disponível no momento da inicialização do aplicativo. |
| |
| <p><li>Finalmente, declare a variável do resultado acima da classe, como segue: |
| |
| <pre class="examplecode">private Lookup.Result result = null;</pre> |
| |
| <p><li>Execute novamente o aplicativo e observe que a janela do editor é atualizada sempre que você seleciona um novo <tt>Node</tt>: |
| |
| <p><img alt="janela do editor atualizada" src="../images/tutorials/crud/68dbmanager-98.png" /></p> |
| |
| |
| <p>No entanto, observe o que acontece quando você alterna o foco para a janela do editor:</p> |
| |
| <p><img alt="alternar foco" src="../images/tutorials/crud/68dbmanager-99.png" /></p> |
| |
| <p>Como o <tt>Node</tt> não é mais o atual, o objeto <tt>Customer</tt> não está mais no contexto global. Isto se deve, conforme mostrado acima, aos proxies do contexto global do <tt>Lookup</tt> do <tt>Node</tt> atual. Portanto, nesse caso, não podemos usar o contexto global. Em vez disso, usaremos o <tt>Lookup</tt> local fornecido pela janela Clientes.</p> |
| |
| <p>Reescreva esta linha: |
| |
| <pre class="examplecode">result = Utilities.actionsGlobalContext().lookupResult(Customer.class);</pre> |
| |
| <p>Para: |
| |
| <pre class="examplecode">result = WindowManager.getDefault().findTopComponent("CustomerTopComponent").getLookup().lookupResult(Customer.class);</pre> |
| |
| <p>A string "CustomerTopComponent" é a ID do <tt>CustomerTopComponent</tt>, que é uma constante da string que você pode encontrar no código-fonte do <tt>CustomerTopComponent</tt>. Uma desvantagem da abordagem acima é a de que seu novo <tt>EditorTopComponent</tt> funciona somente se ele puder encontrar um <tt>TopComponent</tt> com a ID "CustomerTopComponent". Isto precisa ser explicitamente documentado para que os desenvolvedores de editores alternativos possam saber que precisam identificar o visualizador <tt>TopComponent</tt> desta forma, ou é necessário reescrever o modelo de seleção, <a href="http://weblogs.java.net/blog/timboudreau/archive/2007/01/how_to_replace.html">conforme descrito aqui</a> por Tim Boudreau. |
| |
| <p>Se utilizar uma das abordagens acima, verificará que o contexto não se perde ao alternar o foco para o <tt>EditorTopComponent</tt>, conforme ilustrado abaixo:</p> |
| |
| <p><img alt="o contexto não se perde" src="../images/tutorials/crud/68dbmanager-991.png" /></p> |
| |
| <p class="tips"> Visto que agora você está utilizando <tt>AbstractNode</tt>, em vez de <tt>BeanNode</tt>, nenhuma propriedade é mostrada na janela Propriedades. Você mesmo precisa fornecê-las, conforme descrito no <a href="https://platform.netbeans.org/tutorials/nbm-nodesapi2.html">Tutorial da API de nós</a>. |
| </ul> |
| <li>Em segundo lugar, vamos trabalhar na funcionalidade Desfazer/Refazer. O que gostaríamos que acontecesse é que sempre que o usuário fizer uma alteração em um dos <tt>JTextFields</tt>, o botão "Desfazer" e o botão "Refazer", assim como os itens de menu relacionados no meu Editar, se tornassem habilitados. Para este fim, a plataforma NetBeans torna o <a href="http://bits.netbeans.org/dev/javadoc/org-openide-awt/org/openide/awt/UndoRedo.Manager.html">UndoRedo.Manager</a> disponível. |
| <ul> |
| <li>Declare e crie uma instância de um novo UndoRedoManager acima do <tt>EditorTopComponent</tt>: |
| |
| <pre class="examplecode">private UndoRedo.Manager manager = new UndoRedo.Manager();</pre> |
| |
| <p><li>A seguir, sobreponha o método <tt>getUndoRedo()</tt> no <tt>EditorTopComponent</tt>: |
| |
| <pre class="examplecode">@Override
|
| public UndoRedo getUndoRedo() {
|
| return manager;
|
| }</pre> |
| |
| <p><li>No construtor do <tt>EditorTopComponent</tt>, adicione um <tt>KeyListener</tt> ao <tt>JTextFields</tt> e, dentro dos métodos relacionados que você precisa implementar, adicione o <tt>UndoRedoListeners</tt>: |
| |
| <pre class="examplecode">jTextField1.getDocument().addUndoableEditListener(manager); |
| jTextField2.getDocument().addUndoableEditListener(manager); |
| </pre> |
| |
| <p><li>Execute o aplicativo e mostre a funcionalidade Desfazer e Refazer em ação, os botões e também os itens de menu. A funcionalidade funciona exatamente como esperado. Você pode desejar alterar o <tt>KeyListener</tt> para que nem TODAS as teclas causem a habilitação da funcionalidade Desfazer/Refazer. Por exemplo, quando Enter é pressionado, você provavelmente não deseja que a funcionalidade Desfazer/Refazer se torne disponível. Portanto, adapte o código acima para se adequar às suas necessidades administrativas. |
| |
| |
| </ul> |
| <li>Em terceiro lugar, precisamos integrar com a funcionalidade Salvar do NetBeans: |
| <ul> |
| <li>como padrão, o botão "Salvar todos" está disponível na barra de ferramentas da plataforma NetBeans. Em nosso cenário atual, não desejamos salvar "todos", porque "todos" se refere a vários documentos. Em nosso caso, temos somente um "documento", que é o editor que estamos reutilizando para todos os nós na hierarquia da árvore. Remova o botão "Salvar todos" e adicione "Salvar" em seu lugar, adicionando o seguinte arquivo de camada do módulo <tt>CustomerEditor</tt>: |
| |
| <pre class="examplecode"><folder name="Toolbars"> |
| <folder name="File"> |
| <file name="org-openide-actions-SaveAction.shadow"> |
| <attr name="originalFile" stringvalue="Actions/System/org-openide-actions-SaveAction.instance"/> |
| <attr name="position" intvalue="444"/> |
| </file> |
| <file name="org-openide-actions-SaveAllAction.shadow_hidden"/> |
| </folder> |
| </folder></pre> |
| |
| <p>Agora, quando você executar o aplicativo, verá um ícone diferente na barra de ferramentas. Em vez do botão "Salvar todos", agora o botão "Salvar" está disponível. |
| |
| <p><li>Defina as dependências na API das caixas de diálogo e na API dos nós. |
| |
| <p><li>No construtor <tt>EditorTopCompontn</tt>, adicione uma chamada para disparar um método (que será definido na etapa seguinte) sempre que uma alteração for detectada: |
| |
| <pre class="examplecode">public EditorTopComponent() { |
| |
| ... |
| ... |
| ... |
| |
| jTextField1.getDocument().addDocumentListener(new DocumentListener() { |
| public void insertUpdate(DocumentEvent arg0) { |
| fire(true); |
| } |
| public void removeUpdate(DocumentEvent arg0) { |
| fire(true); |
| } |
| public void changedUpdate(DocumentEvent arg0) { |
| fire(true); |
| } |
| }); |
| |
| jTextField2.getDocument().addDocumentListener(new DocumentListener() { |
| public void insertUpdate(DocumentEvent arg0) { |
| fire(true); |
| } |
| public void removeUpdate(DocumentEvent arg0) { |
| fire(true); |
| } |
| public void changedUpdate(DocumentEvent arg0) { |
| fire(true); |
| } |
| }); |
| |
| //Create a new instance of our SaveCookie implementation: |
| impl = new SaveCookieImpl(); |
| |
| //Create a new instance of our dynamic object: |
| content = new InstanceContent(); |
| |
| //Add the dynamic object to the TopComponent Lookup: |
| associateLookup(new AbstractLookup(content)); |
| |
| } |
| |
| ... |
| ... |
| ... |
| </pre> |
| |
| <p><li>Aqui estão os dois métodos mencionados acima. Primeiro, o método que é disparado sempre que uma alteração for detectada. Uma implementação do <tt>SaveCookie</tt> da API de nós é adicionada ao <tt>InstanceContent</tt> sempre que uma alteração for detectada: |
| |
| <pre class="examplecode"> public void fire(boolean modified) { |
| if (modified) { |
| //If the text is modified, |
| //we add SaveCookie impl to Lookup: |
| content.add(impl); |
| } else { |
| //Otherwise, we remove the SaveCookie impl from the lookup: |
| content.remove(impl); |
| } |
| } |
| |
| private class SaveCookieImpl implements SaveCookie { |
| |
| @Override |
| public void save() throws IOException { |
| |
| Confirmation message = new NotifyDescriptor.Confirmation("Do you want to save \"" |
| + jTextField1.getText() + " (" + jTextField2.getText() + ")\"?", |
| NotifyDescriptor.OK_CANCEL_OPTION, |
| NotifyDescriptor.QUESTION_MESSAGE); |
| |
| Object result = DialogDisplayer.getDefault().notify(message); |
| //When user clicks "Yes", indicating they really want to save, |
| //we need to disable the Save action, |
| //so that it will only be usable when the next change is made |
| //to the JTextArea: |
| if (NotifyDescriptor.YES_OPTION.equals(result)) { |
| fire(false); |
| //Implement your save functionality here. |
| } |
| } |
| } |
| </pre> |
| <p><li>Execute o aplicativo e observe a habilitação/desabilitação do botão Salvar: |
| |
| <p><img alt="botão salvar ativado" src="../images/tutorials/crud/68dbmanager-992.png" /></p> |
| |
| <p class="tips"> No momento, nada acontece quando você clica em OK na caixa de diálogo acima. Na próxima etapa, adicionamos alguns códigos JPA para manipular a persistências de nossas alterações. |
| |
| <p><li>A seguir, adicionamos o código JPA para manter nossa alteração. Faça isso substituindo o comentário "//Implement your save functionality here." (Implemente sua funcionalidade salva aqui). O comentário deveria ser substituído pelo código a seguir: |
| |
| <pre class="examplecode">EntityManager entityManager = Persistence.createEntityManagerFactory("CustomerLibraryPU").createEntityManager(); |
| entityManager.getTransaction().begin(); |
| Customer c = entityManager.find(Customer.class, customer.getCustomerId()); |
| c.setName(jTextField1.getText()); |
| c.setCity(jTextField2.getText()); |
| entityManager.getTransaction().commit();</pre> |
| |
| <p class="tips"> O "customer" de <tt>customer.getCustomerId()()</tt> não está definido no momento. Adicione a linha em negrito ao <tt>resultChanged</tt> abaixo, após declarar <tt>Customer customer;</tt> acima da classe, de modo que o objeto <tt>Customer</tt> atual defina o <tt>customer</tt>, o qual é então usado no código de persistência acima para obter a ID do objeto <tt>Customer</tt> atual. |
| |
| <pre class="examplecode">@Override |
| public void resultChanged(LookupEvent lookupEvent) { |
| Lookup.Result r = (Lookup.Result) lookupEvent.getSource(); |
| Collection<Customer> c = r.allInstances(); |
| if (!c.isEmpty()) { |
| for (Customer customer : c) { |
| <b>customer = cust;</b> |
| jTextField1.setText(customer.getName()); |
| jTextField2.setText(customer.getCity()); |
| } |
| } else { |
| jTextField1.setText("[no name]"); |
| jTextField2.setText("[no city]"); |
| } |
| }</pre> |
| |
| <p><li>Execute o aplicativo e altere alguns dados. No momento, não temos a funcionalidade "Atualizar" (que será adicionada na etapa seguinte), portanto, para ver os dados alterados, reinicie o aplicativo. Aqui, por exemplo, a hierarquia da árvore mostra o nome do cliente persistente "Toyota Motor Co": |
| |
| <p><img alt="banco de dados alterado" src="../images/tutorials/crud/68dbmanager-993.png" /></p> |
| |
| </ul> |
| |
| |
| <li>Em quarto lugar, precisamos adicionar a funcionalidade de atualização para o visualizador Customer. Você pode desejar adicionar um <tt>Temporizador</tt> que periodicamente atualiza o visualizador. No entanto, neste exemplo, nós adicionaremos um item de menu "Atualizar" no nó Raiz, para que o usuário seja capaz de atualizar manualmente o visualizador. |
| <ul> |
| <li>No pacote principal do módulo <tt>CustomerViewer</tt>, crie um novo <tt>Node</tt>, que substituirá o <tt>AbstractNode</tt> que estamos utilizando atualmente como a raiz dos filhos do visualizador. Observe que também vinculamos uma ação "Atualizar" com nosso novo nó raiz. |
| |
| <pre class="examplecode">public class CustomerRootNode extends AbstractNode { |
| |
| public CustomerRootNode(Children kids) { |
| super(kids); |
| setDisplayName("Root"); |
| } |
| |
| @Override |
| public Action[] getActions(boolean context) { |
| Action[] result = new Action[]{ |
| new RefreshAction()}; |
| return result; |
| } |
| |
| private final class RefreshAction extends AbstractAction { |
| |
| public RefreshAction() { |
| putValue(Action.NAME, "Refresh"); |
| } |
| |
| public void actionPerformed(ActionEvent e) { |
| CustomerTopComponent.refreshNode(); |
| } |
| } |
| |
| }</pre> |
| |
| <p><li>Adicione este método ao <tt>CustomerTopComponent</tt> para atualizar a visualização: |
| |
| <pre class="examplecode">public static void refreshNode() { |
| EntityManager entityManager = Persistence.createEntityManagerFactory("CustomerLibraryPU").createEntityManager(); |
| Query query = entityManager.createQuery("SELECT c FROM Customer c"); |
| List<Customer> resultList = query.getResultList(); |
| em.setRootContext(new <b>CustomerRootNode</b>(Children.create(new CustomerChildFactory(resultList), true))); |
| } </pre> |
| |
| |
| <p>Agora, substitua o código acima no construtor do <tt>CustomerTopComponent</tt> por uma chamada para código acima. Como você pode ver na parte realçada acima, agora estamos utilizando nosso <tt>CustomerRootNode</tt> ao invés do <tt>AbstractNode</tt>. O <tt>CustomerRootNode</tt> inclui a ação "Atualizar", que chama o código acima. |
| |
| <p><li>Na sua funcionalidade de salvar, adicione a chamada ao método acima para que, sempre que os dados forem salvos, ocorra uma atualização automática. É possível utilizar diferentes abordagens ao implementar esta extensão à funcionalidade de salvar. Por exemplo, você pode criar um novo módulo que contém a ação de atualização. Tal módulo é, então, compartilhado entre o módulo do visualizador e o módulo do editor, proporcionando a funcionalidade que é comum a ambos. |
| |
| <p><li>Execute novamente o aplicativo e observe que você tem um novo nó raiz com uma ação "Atualizar": |
| |
| <p><img alt="novo nó raiz" src="../images/tutorials/crud/68dbmanager-994.png" /></p> |
| |
| <p><li>Altere alguns dados, salve-os, chame a ação Atualizar e observe que o visualizador está atualizado. |
| |
| </ul> |
| </ol> |
| <p>Você agora aprendeu como a plataforma NetBeans tem a permissão de manipular as alterações no <tt>JTextFields</tt>. Sempre que o texto muda, os botões Desfazer e Refazer da plataforma NetBeans são habilitados ou desabilitados. O botão Salvar também é corretamente habilitado ou desabilitado, permitindo que o usuário salve os dados alterados no banco de dados. |
| |
| <h3 class="tutorial"><a name="create"></a>Criar</h3> |
| <p>Nesta seção, você permite que o usuário crie uma nova entrada no banco de dados. |
| <ol> |
| <li>Clique com o botão direito do mouse no módulo <tt>CustomerEditor</tt> e escolha "Nova ação". Utilize o assistente Nova ação para criar uma nova ação "Sempre habilitado". A nova ação deve ser exibida na barra de ferramentas ou na barra de menus. Na próxima etapa do assistente, chame a ação <tt>NewAction</tt>. |
| |
| <p class="tips">Certifique-se de ter disponível um ícone 16x16, que o assistente força que seja selecionado, se for indicado que deseja que a ação seja chamada da barra de ferramentas.</p> |
| <P><li>Na nova ação, deixe que o <tt>TopComponent</tt> seja aberto com <tt>JTextFields</tt> vazios: |
| |
| <pre class="examplecode">import java.awt.event.ActionEvent;
|
| import java.awt.event.ActionListener;
|
|
|
| public final class NewAction implements ActionListener {
|
|
|
| public void actionPerformed(ActionEvent e) {
|
| EditorTopComponent tc = EditorTopComponent.getDefault();
|
| tc.resetFields();
|
| tc.open();
|
| tc.requestActive();
|
| }
|
|
|
| }</pre> |
| |
| <p class="tips">A ação implementa a classe <tt>ActionListener</tt> que está vinculada ao aplicativo através de entradas no arquivo de camadas, colocado pelo assistente Nova ação. Imagine que fácil será quando transferir seu aplicativo Swing existente para a plataforma NetBeans, já que você simplesmente poderá utilizar as mesmas classes <tt>Action</tt> utilizadas em seu aplicativo original, sem a necessidade de reescrevê-las para estarem em conformidade com as classes <tt>Action</tt> fornecidas pela plataforma NetBeans!</p> |
| |
| |
| <p>No <tt>EditorTopComponent</tt>, adicione o seguinte método para redefinir o <tt>JTextFields</tt> e para criar um novo objeto <tt>Customer</tt>: |
| |
| <pre class="examplecode">public void resetFields() { |
| customer = new Customer(); |
| jTextField1.setText(""); |
| jTextField2.setText(""); |
| }</pre> |
| |
| <p><li>No <tt>SaveCookie</tt>, assegure que um retorno de <tt>null</tt> indique que a nova entrada está salva, em vez de uma entrada existente ser atualizada: |
| |
| <pre>public void save() throws IOException { |
| |
| Confirmation message = new NotifyDescriptor.Confirmation("Do you want to save \"" |
| + jTextField1.getText() + " (" + jTextField2.getText() + ")\"?", |
| NotifyDescriptor.OK_CANCEL_OPTION, |
| NotifyDescriptor.QUESTION_MESSAGE); |
| |
| Object result = DialogDisplayer.getDefault().notify(msg); |
| |
| //When user clicks "Yes", indicating they really want to save, |
| //we need to disable the Save button and Save menu item, |
| //so that it will only be usable when the next change is made |
| //to the text field: |
| if (NotifyDescriptor.YES_OPTION.equals(result)) { |
| fire(false); |
| EntityManager entityManager = Persistence.createEntityManagerFactory("CustomerLibraryPU").createEntityManager(); |
| entityManager.getTransaction().begin(); |
| <b>if (customer.getCustomerId() != null)</b> { |
| Customer c = entityManager.find(Customer.class, cude.getCustomerId()); |
| c.setName(jTextField1.getText()); |
| c.setCity(jTextField2.getText()); |
| entityManager.getTransaction().commit(); |
| } else { |
| <b>Query query = entityManager.createQuery("SELECT c FROM Customer c"); |
| List<Customer> resultList = query.getResultList(); |
| customer.setCustomerId(resultList.size()+1); |
| customer.setName(jTextField1.getText()); |
| customer.setCity(jTextField2.getText()); |
| //add more fields that will populate all the other columns in the table! |
| entityManager.persist(customer); |
| entityManager.getTransaction().commit();</b> |
| } |
| } |
| |
| }</pre> |
| |
| <p><li>Execute novamente o aplicativo e adicione um novo cliente no banco de dados. |
| |
| </ol> |
| |
| <h3 class="tutorial"><a name="delete"></a>Excluir</h3> |
| <p>Nesta seção, você permite que o usuário exclua uma entrada selecionada no banco de dados. Utilizando os conceitos e códigos acima descritos, implemente você mesmo a ação Excluir. |
| <ol> |
| <li>Crie uma nova ação, <tt>DeleteAction</tt>. Decida se deseja vinculá-la a um nó Customer ou se deseja vinculá-la à barra de ferramentas, à barra de menus, ao atalho do teclado ou a uma combinação destes. Dependendo de onde deseja vinculá-la, será necessário utilizar uma abordagem em seu código. Leia novamente o tutorial para obter ajuda, especialmente ao examinar como a ação "Novo" foi criada ao compará-la com a ação "Atualizar" no nó raiz. |
| <p><li>Obtenha o objeto <tt>Customer</tt> atual e retorne uma caixa de diálogo 'Tem certeza?'. e, em seguida, exclua a entrada. Para obter ajuda neste ponto, leia novamente o tutorial, focando na parte onde a funcionalidade "Salvar" é implementada. Ao invés de salvar, você agora deseja excluir uma entrada do banco de dados. |
| </ol> |
| |
| </div> |
| |
| |
| |
| <!-- ======================================================================================== --> |
| |
| |
| <h2><a name="nextsteps"></a>Consulte também</h2> |
| |
| <p>Isto conclui o tutorial CRUD da plataforma NetBeans. Este documento descreveu como criar um novo aplicativo na plataforma NetBeans com a funcionalidade CRUD para um determinado banco de dados. Para obter mais informações sobre a criação e o desenvolvimento de aplicativos, consulte os seguintes recursos: |
| <ul> |
| <li><a href="https://netbeans.org/kb/trails/platform_pt_BR.html">Trilha do aprendizado da plataforma NetBeans</a></li> |
| <li><a href="http://bits.netbeans.org/dev/javadoc/">Javadoc da API da NetBeans</a></li> |
| </ul> |
| |
| <!-- ======================================================================================== --> |
| |
| </body> |
| </html> |
