Persistência de Objetos no SGBD PostgresSQL Utilizando as APIs JDBC JDK Swing e Design Patteners DAO

Robson Adão Fagundes - http://robsonfagundes.blogspot.com/ - Página 1

Persistência de Objetos no SGBD PostgreSQL, Utilizando as APIs: JDBC, JDK,

Swing e Design Patteners DAO.

Robson Adão Fagundes http://robsonfagundes.blogspot.com/

Mini curso Desenvolvimento de aplicação Desktop, com Persistência em Banco de Dados com o Uso da

Linguagem de programação Java especificação J2SE.

Tecnologias e Ferramentas Envolvidas:

• J2SE, APIs: JDBC, JDK e Swing;

• IDE NetBeans 6.1;

• SGBD PosgresSQL 8.2;

• Design Patterns DAO;

Vamos Iniciar a Aplicação:

1º Passo:

Vamos Criar nossa base de dados, abra o PgAdmin III e crie uma base de dados chamada de:

MiniCurso

Clique com botão direito do mouse sobre Databases e clique em New Database de o nome para ela

de MiniCurso; e depois clique em OK.


De um duplo clique em cima da base Criada MiniCurso => Schemas => Public => Tables

Deixe a seguinte estrutura, como mostra figura abaixo:


Clique no botão SQL:

Agora vamos criar nossa tabela no banco de dados o script SQL é o

seguinte:

Cole o Código SQL dentro do pgAdmin Query e clique no botão

Criado o Banco partiremos para segundo passo;

Se a mensagem retornar

SUCCESSFULLY nossa tabela no

banco foi criado corretamente


2° Passo:

Inicie o NetBeans 6.1 crie um novo Java Application ou (Aplicação Java).

No nome do projeto coloque exemploJDBC; e desmarque a opção: Criar Classe Main depois em

finalizar para criar nosso projeto;


3º Passo:

Clique em “Pacotes de Código - Fonte” e Crie um pacote chamado beans


Clique no pacote beans e crie a Classe Java chamada de Pessoa;

A classe Pessoa.java representara o nosso modelo, ou seja, nossa tabela do banco de dados. Ela

devera ter atributos que representam as colunas da nossa tabela do banco de dados;

Note que elas possuem o mesmo nome.


4º Passo:

Criar os atributos da classe Pessoa.java que representaram as colunas da tabela pessoa,

Os nomes das colunas devem ser iguais nos atributos do bean Pessoa.java


Agora devemos criar os métodos Construtores da Classe, Seters e Geters do nosso bean;

Clique com botão direito do mouse e clique em Inserir Código e clique em Construtor não selecione

nada e clique em gerar.


Agora Clique novamente com botão direito do mouse e clique em Inserir Código e clique em

Construtor e selecione todas as opções e clique em gerar.

Pronto nossa Classe já possui seus atributos e os métodos construtores da classe sem parâmetros e

com parâmetros.

Ainda Faltam os métodos Seters e Geters;


Agora devemos criar os métodos Seters e Geters do nosso bean;

Clique com botão direito do mouse sobre os atributos da classe e selecione a opção:

Refatorar => Encapsular campos...

Marque todas as opções e clique em Refatorar;

Pronto já possuímos nossa classe que representara os dados da tabela Pessoa Criada no nosso banco

de dados. Você deve ter a seguinte estrutura;


6º Passo:

Pronto agora já temos o modelo de dados da nossa aplicação. Agora devemos criar uma conexão com

o banco de dados. Criaremos um pacote chamado conexão e uma classe também chamada de

Conexão.java; no src da aplicação.

Os comentários acima das linhas, explicam melhor o que cada linha da classe faz.

Copie e cole o código abaixo na sua classe Conexão.java

Os comentários acima das linhas, explicam melhor o que cada linha da classe faz.

package conexao; import java.sql.Connection; import java.sql.DriverManager; import java.sql.SQLException; public class Conexao { // atributos private static Connection conexao = null; //esta é a variável fonte recebe o mesmo nome d a base de dados //criada no postgresql private String fonte = "MiniCurso"; //Conexao Para a Base de Dados do PostgresSQL u tilizando JDBC private Conexao() {


try { //Driver para fazer conexao com um Banc o postgresql Class.forName("org.postgresql.Driver"); //comando para fazer conexao via JDBC c om um banco postgresql //sendo informado o servidor e sua port a, no caso localhost na porta 5432 // + o nome da base de dados, o usuario e a senha. conexao = DriverManager.getConnection("jdbc:postgre sql://127.0.0.1:5432/" + fonte, "usuario do banco", "senha do banco"); } catch (ClassNotFoundException e) { e.printStackTrace(); System.out.println("Ocorreu um erro de class não encontrada!!!"); } catch (SQLException e) { e.printStackTrace(); System.out.println("Ocorreu um erro na conexao com o banco de dados!!!"); } } public static Connection getInstance() { if (conexao == null) { new Conexao(); } return conexao; } }

Agora vamos adicionar para a biblioteca da nossa aplicação o Driver de conexão com o banco:

postgresql-8.2-XXX.jdbcXXX.jar


Clique em Projetos => Bibliotecas => Adicionar

JAR/pasta....

E especifique o caminho do seu Driver de conexão: postgresql-8.2-XXX.jdbcXXX.jar

Faça os imports e Compile a Classe Apertando a tecla F5 ou clicando com botão direito do mouse

sobre o projeto, Clique em Limpar e Construir


Faça os imports e Compile a Classe garanta que não haja erros !!!

7º Passo:

Agora vamos criar a classe Dao, Responsável pela Persistência dos dados no Banco.

Data Access Object: Dao é um modelo para persistir dados em aplicações é de banco de dados

relacional.

DAO (Data Access Object) é um padrão para persistência de dados que permite separar regras de

negócio das regras de acesso a banco de dados. Numa aplicação que utilize a arquitetura MVC, todas

as funcionalidades de bancos de dados, tais como obter as conexões, mapear objetos Java para tipos

de dados SQL ou executar comandos SQL, devem ser feitas por classes de DAO.


Seguindo... Criaremos um pacote chamado dao e uma classe também chamada de DaoPessoa.java

Copie e cole o código abaixo na sua classe DaoPessoa.java

package dao; import beans.Pessoa; import conexao.Conexao; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.ArrayList; import java.util.List; /** * * @author rafsantos */ public class DaoPessoa { public DaoPessoa() { } //GRAVAR //==================================== public boolean grava(Pessoa pessoa) { try { PreparedStatement comandoSQL; comandoSQL = Conexao.getInstance().prep areStatement("insert into Pessoa (id, nome, email, telefone) values(?,?,?,?)" ); comandoSQL.setLong(1, pessoa.getId()); comandoSQL.setString(2, pessoa.getNome( )); comandoSQL.setString(3, pessoa.getEmail ()); comandoSQL.setString(4, pessoa.getTelef one()); comandoSQL.execute(); Conexao.getInstance().commit(); return true; } catch (SQLException e) { e.printStackTrace(); } return false; } //ALTERAR //==================================== public boolean atualiza(Pessoa pessoa) { try { PreparedStatement comandoSQL; comandoSQL = Conexao.getInstance().prep areStatement("update Pessoa set nome = ? where id = ? "); comandoSQL.setString(1, pessoa.getNome( )); comandoSQL.setString(2, pessoa.getEmail ()); comandoSQL.setString(3, pessoa.getTelef one()); comandoSQL.execute(); Conexao.getInstance().commit(); } catch (SQLException e) {


e.printStackTrace(); } return false; } //DELETAR //===================================== public boolean deleta(Pessoa pessoa) { try { PreparedStatement comandoSQL; comandoSQL = Conexao.getInstance().prep areStatement("delete from Pessoa where id = ?"); comandoSQL.setLong(1, pessoa.getId()); comandoSQL.execute(); Conexao.getInstance().commit(); } catch (SQLException e) { e.printStackTrace(); } return false; } //LISTAR TODOS //===================================== public List lista() { try { PreparedStatement comandoSQL; comandoSQL = Conexao.getInstance().prep areStatement("select * from Pessoa"); ResultSet rs = comandoSQL.executeQuery( ); List arlPessoas = new ArrayList(); while (rs.next()) { Pessoa pess = new Pessoa(); pess.setId(rs.getLong("id")); pess.setNome(rs.getString("nome")); pess.setEmail(rs.getString("email") ); pess.setTelefone(rs.getString("tele fone")); arlPessoas.add(pess); } return arlPessoas; // conexao.commit(); } catch (SQLException e) { e.printStackTrace(); } return null; } //CONSULTA ESPECIFICA POR CAMPOS //===================================== public Pessoa consulta(int pk) { try { PreparedStatement comandoSQL; comandoSQL = Conexao.getInstance().prep areStatement("select * from


Pessoa where id=?"); comandoSQL.setInt(1, pk); ResultSet rs = comandoSQL.executeQuery( ); if (rs.next()) { Pessoa pess = new Pessoa(); pess.setId(rs.getLong("id")); pess.setNome(rs.getString("nome")); pess.setEmail(rs.getString("email") ); pess.setTelefone(rs.getString("tele fone")); return pess; } } catch (SQLException e) { e.printStackTrace(); } return null; } }

Faça os imports e Compile a Classe garanta que não haja erros !!!

Para que vocês entenderem o funcionamento da Classe Dao “DaoPessoa.java” Criada acima, farei o

comentário do que cada linha do código explicando o que cada linha faz no nosso programa ok.

Comentários do Código: Método Gravar(); //GRAVAR Cria o método do tipo boleean que retorna true se a operação for realizada com sucesso; e false se der algum erro de persistência no banco; Ele recebe o Bean no caso o Pessoa passado como parâmetro pela tela quando clicamos no botão gravar de nossa tela. O Bean Pessoa contem os dados digitados no JTEXTFIELD, passados a ele através dos Seters e Geters; public boolean grava(Pessoa pessoa) { // cria um try, catch para retornar o true ou false try { // crio uma instancia da Classe PreparedStatement chamada de comandoSQL, A classe PreparedStatement é reponsavel pela Query com a base de dados PreparedStatement comandoSQL; // a instancia de comandoSQL ira receber uma instancia da classe conexão passando o código SQL no caso o INSERT, observe que os campos dever ser iguais as tabelas do banco. Os VALUES serão passados nas linhas abaixo por isso os ????. A quantidade de ?, deve ser igual ao numero de campos da tabela. comandoSQL = Conexao.getInstance().prepareStatement ("insert into Pessoa (id, nome, email, telefone) values(?,?,?,?)"); // pega o valor do id do bean pessoa através do getId() e seto no comandoSQL com o

tipo Long; o numero 1 significa que eh o primeiro campo da nossa tabela comandoSQL.setInt(1, pessoa.getId());


// pega o valor do Nome do bean pessoa através do getNome() e seto no comandoSQL com o tipo String; o numero 2 significa que é o segundo campo da nossa tabela, os tipos Long , String , Date , estão definidos no nosso Beans o que o comandoSQL

não sabe que tipo que eh por isso definimos ele através do setString(2, pessoa.getNome()); comandoSQL.setString(2, pessoa.getNome()); // o comentário de cima de aplica a todas as linhas abaixo por serem todos Strings a única diferença são os números dois campos das tabelas; comandoSQL.setString(3, pessoa.getEmail()) ; comandoSQL.setString(4, pessoa.getTelefone ()); // serve para qualquer tipo de comando SQL. Ele retorna true ou false dependendo se existe ou não um ResultSet ele ira executar nossos comando SQL; comandoSQL.execute(); // Faz todas as mudanças SQL e libera todos os fechamentos da base de dados prendidos atualmente por este objeto da conexão Conexao.getInstance().commit(); // se não ocorrer nenhum erro ele retornara True e nossos dados contidos no beans serão, armazenados no Banco; return true; // o catch tem q retornar uma SQLException para podermos identificar possíveis erros nos nossos códigos java ou SQL acima escritos } catch (SQLException e) { // o e. printStackTrace ira imprimir o erro se houver e.printStackTrace(); } // se houver o erro ele ira retornar false; return false; // fim do método Gravar } Comentários do Código: Método Alterar(); ALTERAR // O Altera tem os mesmo comentários do método acima com exceção da linha que contem o código SQL que não será mais um INSERT e sim um UPDATE, observe que o que irá mudar é somente o nome do método e o código SQL contido na linha: comandoSQL = conexao.getInstance().prepareStatement ("update Pessoa set nome = ? where id = ?”); no resto da estrutura do método será igual os comentários do método Gravar();

Comentários do Código: Método Deletar(); DELETAR // O deletar tem os mesmo comentários do método acima com exceção da linha que contem o código SQL que não será mais um INSERT e sim um DELETE, observe que o que ira mudar é somente o nome do método e o código SQL contido na linha: comandoSQL = Conexao.getInstance().prepareStatement ("delete from Pessoa


where id = ?"); observe que agora passamos somente o campo Id (que é a nossa chave primaria da tabela pessoas) só precisamos passar o ID porque o próprio banco apagar os demais campos relacionados a esse Id através do comando SQL. public boolean deleta(Pessoa pessoa) { try { PreparedStatement comandoSQL; comandoSQL = Conexao.getInstance().prep areStatement("delete from Pessoa where id = ?"); //passamos apenas o campo ID comandoSQL.setInt(1, pessoa.getId()); comandoSQL.execute(); Conexao.getInstance().commit(); } catch (SQLException e) { e.printStackTrace(); } return false; }

8º Passo:

Agora vamos criar a Tela, Responsável pela captura dos dados informados pelo usuário.

Criaremos uma classe do tipo gui (Graphical User Interface), ou seja, Interface Gráfica do Usuário

utilizando a classe JFrame da API Swing.

Swing é uma API Java para interfaces gráficas. Ela é compatível com a API AWT, mas trabalha de

uma maneira totalmente diferente. A API Swing procura renderizar\desenhar por contra própria todos

os componentes, ao invés de delegar essa tarefa ao sistema operacional, como a maioria das outras

APIs de interface gráfica trabalham.

Por ser uma API de mais alto nível, ou seja, mais abstração, menor aproximação das APIs do sistema

operacional, ela tem bem menos performance que outras APIs gráficas e consome mais memória RAM

em geral. Porém, ela é bem mais completa, e os programas que usam Swing têm uma aparência

muito parecida, independente do Sistema Operacional utilizado.

Seguindo... Criaremos um pacote chamado gui e dentro dele um Formulário JFrame, Chamado de

TelaPessoa.java

Clique com botão direito do mouse sobre o pacote gui, Novo => Formulario JFrame...


Crie os campos que representarão os dados a serem persistidos, tente deixar a Tela com a seguinte

aparência.


Os Componentes da API Swing utilizados neste projeto são :

JBotton : 4 Botões

JPanel : 4 Painéis com Bordas e Titulo

JTabbedPane : Com 2 JPanel que são as Abas:

JTextField : 4 representam nossos dados a serem persistidos

JTable : Abrigara todos as pessoas cadastradas

• Gravar • Alterar • Excluir • Listar

• Fundo • Ações • Dados da

Pessoa • Lista de

Pessoas

• Aba Cadastro • Aba Consulta

• Código • Nome • Email • Telefone

• Lista de

Pessoas


Tente deixar a Tela com a seguinte aparência:


Agora vamos escrever o método que ira popular nossa tabela com os dados do banco;

Dentro do código fonte no Inicio da Classe TelaPessoa.java dentro do método construtor após o

método InitComponents(); crie a chamada para o método listarPessoas(); que ainda vamos criar

dentro do código junto com os métodos, gravar, alterar, excluir e listar;

Código do método TelaPessoas (); = “Método Construtor da Classe” copie e cole dentro da sua

classe TelaPessoas.

public TelaPessoas() { // inicia os componentes initComponents(); // dispose da MP TelaPessoas.this.dispose(); // preenche a tabela com os dados Do BD com o dao listarPessoas(); }

Atributos que deveram, ser declarados no escopo global da classe TelaPessoas.java

// instancia um novo objeto da classe Pessoa.java Pessoa pessoa = new Pessoa(); // instancia um novo objeto da classe DaoPessoa.java DaoPessoa daoP = new DaoPessoa(); // variavel da tabela modelo Pessoa private DefaultTableModel tabelaModeloPessoa; //Array List da tabela que ira popular a tabela List<Pessoa> arlTabela = new ArrayList<Pessoa>( );


No evento ActionPerformed do Botão Gravar crie a chamada para o método gravar que

escreveremos ainda dentro da classe TelaPessoa; clique com botão direito do mouse sobre o botão

em seguida em Eventos => Action = > actionPerformad

E cole o seguinte código:

//Código do método ActionPerformed(); => Botão Gravar private void jbGravarActionP erformed(java.awt.event.ActionEvent evt) { gravarPessoa(); }

Na parte do método main Crie o método gravar

//Código do método gravarPessoa(); private void gravarPessoa() { pessoa.setId(new Integer(jtfId.getText())) ; pessoa.setNome(jtfNome.getText()); pessoa.setEmail(jtfEmail.getText()); pessoa.setTelefone(jtfTelefone.getText()); daoP.grava(pessoa); }


Repetir a ação para os demais métodos ou seja o mesmo devera ser feito para os botões Alterar e

Excluir e Listar, segue os códigos fonte abaixo:

//Código do método ActionPerformed(); => Botão Alterar private void jbAlterarActionPerformed(java.awt .event.ActionEvent evt) { AlterarPessoa(); }

//Código do método alterarPessoa(); private void alterarPessoa() { pessoa.setId(new Integer(jtfId.getText())); pessoa.setNome(jtfNome.getText()); pessoa.setEmail(jtfEmail.getText()); pessoa.setTelefone(jtfTelefone.getText()); daoP.atualiza(pessoa); }

//Código do método ActionPerformed (); => Botão Excluir private void jbExcluirActionPerformed(java.awt .event.A ctionEvent evt) { ExcluirPessoa(); }

//Código do método excluirPessoa(); private void deletarPessoa() { pessoa.setId(new Integer(jtfId.getText())); daoP.deleta(pessoa); }

Faça os imports e Compile a Classe garanta que não haja erros!!!

Pronto com isso já podemos Realizar as operações de CRUD (Create, Update Delete); Mais ainda falta

o Listar para que possamos visualizar em tempo de execução da aplicação, os dados persistidos ou

apagados do Banco.

No Inicio da Classe TelaPessoa.java dentro do método construtor após o método

InitComponents(); nos fizemos a chamada para o método listarPessoas(); Este método será

executado quando a nossa tela for construída portanto antes de o usuário visualizar a tela os dados

existentes no banco de dados serão listados na tabela.

//Código do método listarPessoas();

public void preencherTabela() { try { arlTabela.removeAll(arlTabela); arlTabela = daoP.lista(); for (int i = 0; i < arlTabela.size(); i ++) { Pessoa pess = (Pessoa) arlTabela.ge t(i);


Vector linha = new Vector(); linha.add(pess.getId()); linha.add(pess.getNome()); linha.add(pess.getEmail()); linha.add(pess.getTelefone()); tabelaModeloPessoa.addRow(linha); } } catch (Exception ex) { ex.printStackTrace(); System.out.println("iiiiii deu erro na Tebela.........."); } }

Pronto com isso, podemos testar a aplicação;

9º Passo:

Clique em Projetos => Executar




Conclusão:

Esse tutorial fornece apenas uma simples introdução sobre o assunto, Os Exemplos aqui mostrados

fazem uso de pouquíssimos recursos oferecidos por estas APIS. Lembre-se que com o estudo

aprofundado sobre elas será possível desenvolver sistemas com: O envio de instruções SQL para

qualquer banco de dados relacional; Possibilitar o uso de bancos de dados já instalados; Usar a API

de baixo nível como base para API de alto nível, Usar recursos gráficos para apresentação e

manipulação de dados.

Robson Adão Fagundes (http://robsonfagundes.blogspot.com) Analista de Sistemas Pleno e

Docente das Disciplinas de Engenharia de Software II e Multimídia e Desenvolvimento Web do Curso

de Sistemas de Informação da Faculdade Iguaçu Capanema - PR

Documents

Persistência de Objetos no SGBD PostgresSQL Utilizando as APIs JDBC JDK Swing e Design Patteners DAO