NetBeans 6.0 – Swing Application Framework

Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Para efetuar o download você precisa estar logado. Clique aqui para efetuar o login
Confirmar voto
0
 (1)  (0)

Crie aplicações desktop Java em poucos minutos usando o novo Swing Aplication Framework com o Netbeans 6.0

Por:Antonio Peixoto da Cunha Junior e Marcos Alberto Lopes da Silva

Tradicionalmente um dos maiores entraves para se desenvolver aplicações JAVA com vínculo a banco de dados é sem dúvida o tempo gasto. Para se criar formulários e fazer conexões com bancos é necessário criar códigos e alterá-los sempre que precisar alterar alguma tabela no banco. Todo este processo pode gerar insatisfação quanto ao uso da ferramenta propriamente dita, bem como este tempo gasto poderia estar sendo utilizado para outros fins. Além disso, é necessário que o desenvolvedor esteja familiarizado com a utilização de plugins.

Em face destes “obstáculos” é que se propõe a utilização de uma ferramenta que facilite a vida do desenvolvedor proporcionando maior rapidez e conforto quanto ao desenvolvimento de aplicações desktop Java. O novo SWING APLICATION FRAMEWORK com o NETBEANS 6.0 surge como alternativa para evitar esta perda de tempo.

Configurando o ambiente

O NetBeans é uma IDE, ou seja, é um ambiente integrado de desenvolvimento que possibilita ao programador criar programas utilizando recursos gráficos.

Para utilizar o Netbeans é necessário já ter instalado o Java JDK na máquina, preferencialmente uma versão igual ou superior a J2SDK 5.0.

Para instalar o JDK basta acessar o seguinte endereço: http://java.sun.com/, escolher a versão desejada e fazer o download.

O Netbeans 6.0 pode ser baixado do endereço: www.netbeans.org, onde pode-se optar por três versões: Basic, Standard e Full. Para a confecção deste artigo está sendo usada a versão Standard, visto que esta já vem com um Banco (Derby) integrado. Porém a ferramenta suporta qualquer banco, bastando ao programador fornecer o driver do banco com o qual se deseja trabalhar.

O Swing Aplication Framework vem como uma ferramenta integrada ao NetBeans 6.0, e é especificado pela JSR 296 (Java Specification Request), prevista para ser integrada a próxima versão do Java (Java 7 Dolphin).

Criando uma aplicação Java com acesso a Banco de Dados

Ao iniciar o Netbeans 6.0 o primeiro passo é escolher o banco com o qual se deseja trabalhar. A ferramenta já vem com um banco integrado (Derby), porém pode-se conectar com uma variedade de bancos bastando fornecer o driver correspondente. Para este trabalho foi utilizado o DERBY, conforme ilustra a Figura 1.

apmanasap1fig01.jpg

Figura 1. Cenário de conexão com banco

Após conectar ao banco pode-se criar as tabelas necessárias, utilizando o banco de dados de exemplo, conforme mostra a Figura 2. As chaves, os atributos da tabela, bem como o tipo dos mesmos, entre outras opções, são definidas nesse momento.

apmanasap1fig02.jpg

Figura 2. Criando uma tabela

Uma vez feitas as tabelas, é hora de criar o projeto da aplicação. É na aba “Projects” do aplicativo que são criados os projetos. Na seqüência, escolhe-se o tipo de projeto, o banco com o qual se queira relacionar, bem como os campos de edição que se deseja mostrar no formulário. Ao final o que se apresenta é um formulário já criado com os campos selecionados e botões padrão, conforme mostra a Figura 3.

apmanasap1fig03.jpg

Figura 3. Ambiente de trabalho do Netbeans 6.0

Ao executar a aplicação é gerado o formulário conforme as configurações pré-estabelecidas pelo programador. A aparência do formulário pode ser alterada, assim como inserção e remoção de componentes com o simples arrastar do mouse. Tornando o formulário com a aparência que se deseja. Para essa aplicação além dos botões padrão já pré-estabelecidos, foi adicionado um botão “Detalhe” que apenas irá retornar o nome da pessoa selecionada da tabela. Para configurar o botão basta escolher a opção “Action” ao clicar no mesmo com o botão direito e seguir as opções apresentadas nas caixas de diálogo. O resultado do formuário pode ser visto na Figura 4.

apmanasap1fig04.jpg

Figura 4. A aplicação em modo de execução.

Toda “action”, que é tratada por um método no código necessita ser anotada com anotação “@application.Action”. A parte do código que implementa o botão que foi criado pode ser observada a seguir. A ação é batante simples com foco didático, mostrando apenas uma caixa de diálogo.

@application.Action
     public void Detalhe() {
         JOptionPane.showMessageDialog (this, nomeField.getText());       
     }

Listagem 1. Fragmento de código

Ao clicar no botão “Detalhe” tem-se a caixa de diálogo, conforme mostra a Figura 5.

apmanasap1fig05.jpg

Figura 5. Caixa de diálogo.

Por trás dos bastidores

O Netbeans 6.0 utiliza JPA (Java Persistence API) que é a especificação padrão para o gerenciamento de persistência e mapeamento objeto relacional, que vem para e simplificar o desenvolvimento de aplicações que utilizam persistência de dados. Um dos principais conceitos relacionados à API JPA é o de entidade. É bom lembrar que, uma entidade corresponde a um objeto que pode ser gravado na base de dados a partir de um mecanismo de persistência. O Netbeans 6.0 gera um arquivo “Persistence.xml”, responsável por fazer a conexão com o banco, criando assim uma camada de abstração entre o JDBC e o código. O uso dessa solução é bastante recomendada devido a sua estabilidade, boa documentação e facilidade de uso.

<?xml version="1.0" encoding="UTF-8"?>
<p margin:="" 0cm="" 0pt;"=""><persistence version="1.0" xmlns="http://java.sun.com/xml/ns/persistence" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:schemaLocation="http://java.sun.com/xml/ns/persistence http://java.sun.com/xml/ns/persistence/persistence_1_0.xsd">
<p margin:="" 0cm="" 0pt;"="">  <persistence-unit name="samplePU" transaction-type="RESOURCE_LOCAL">
<p margin:="" 0cm="" 0pt;"="">    <provider>oracle.toplink.essentials.PersistenceProvider</provider>
    <class>ppessoa.Pessoa</class>
    <properties>
      <property name="toplink.jdbc.url" value="jdbc:derby://localhost:1527/sample"/>
      <property name="toplink.jdbc.user" value="app"/>
      <property name="toplink.jdbc.driver" value="org.apache.derby.jdbc.ClientDriver"/>
      <property name="toplink.jdbc.password" value="app"/>
    </properties>
  </persistence-unit>
</persistence>

Listagem 2. Arquivo XML gerado no Netbeans 6.0

Nesta aplicação o framework gera uma classe persistente “Pessoa.java”. Tal persistência permite que um objeto continue a existir mesmo após a destruição do processo que o criou. Na verdade, o que continua a existir é seu estado, já que pode ser armazenado em disco. Além disso, são geradas várias Queries de consultas.

 @Entity
 @Table(name = "PESSOA")
 @NamedQueries( {@NamedQuery(name = "Pessoa.findByCodigo", query = "SELECT p FROM Pessoa p WHERE p.codigo = :codigo"), 
 @NamedQuery(name = "Pessoa.findByNome", query = "SELECT p FROM Pessoa p WHERE p.nome = :nome"), 
 @NamedQuery(name = "Pessoa.findByDataNascimento", query = "SELECT p FROM Pessoa p WHERE p.dataNascimento = :dataNascimento"), 
 @NamedQuery(name = "Pessoa.findBySexo", query = "SELECT p FROM Pessoa p WHERE p.sexo = :sexo")})
 public class Pessoa implements Serializable {
     @Transient
     private PropertyChangeSupport changeSupport = new PropertyChangeSupport(this);
     @Id
     @Column(name = "CODIGO", nullable = false)
     private Integer codigo;
     @Column(name = "NOME")
     private String nome;
     @Column(name = "DATA_NASCIMENTO")
     @Temporal(TemporalType.DATE)
     private Date dataNascimento;
     @Column(name = "SEXO")
     private String sexo;
  
     public Pessoa() {
     }
  
     public Pessoa(Integer codigo) {
         this.codigo = codigo;
     }
  
     public Integer getCodigo() {
         return codigo;
     }
  
     public void setCodigo(Integer codigo) {
         Integer oldCodigo = this.codigo;
         this.codigo = codigo;
         changeSupport.firePropertyChange("codigo", oldCodigo, codigo);
     }

Listagem 3. Fragmento da classe “Pessoa.java”

Uma vez gerada a classe persistente, existe a necessidade de que a aplicação interaja com uma camada de persistência. Isso é feito invocando o gerenciador de persistência, também conhecido como gerenciador de entidades (da classe EntityManager), responsável por quase todas as operações de persistência de objetos. A classe PPessoaFrame gerada pelo próprio NetBeans é responsável por gerenciar o ciclo de vida das entidades do formulário.

Assim, o objeto gerenciador de entidades (entityManager) é obtido nesse método invocando o método createEntityManagerFactory da classe Persistence passando como argumento o nome da unidade de persistência (declarado no arquivo Persistence.xml). O código da obtenção do objeto entityManager pode ser visto na Listagem 4.

private void initComponents() {
    bindingContext = new javax.beans.binding.BindingContext();
  
    taskMonitor = new application.TaskMonitor();
    entityManager = Persistence.createEntityManagerFactory("samplePU").createEntityManager();
      // código retirado para motivos de clareza do artigo
 }

Listagem 4. Fragmento do método initComponents da classe PPessoaFrame

Toda operação de manutenção do objeto no banco de dados (salvar, recuperar, atualizar e apagar) passa a ser executada e gerenciada pelo objeto gerenciador de persistência (entityManager). O código que demonstra a operação de persistir um novo objeto no banco (salvar) pode ser visto na Listagem 5.

    @Action public void newRecord() {
         ppessoa.Pessoa p = new ppessoa.Pessoa();
         entityManager.persist(p);
         list.add(p);
         int row = list.size()-1;
         masterTable.setRowSelectionInterval(row, row);
         masterTable.scrollRectToVisible(masterTable.getCellRect(row, 0, true));
     }
 
Você precisa estar logado para dar um feedback. Clique aqui para efetuar o login
Receba nossas novidades
Ficou com alguma dúvida?