Upload
jussara-reis
View
161
Download
0
Embed Size (px)
Citation preview
Persistência de dados com o
Faculdade Zacarias de Góes | Sistemas de Informação | Linguagem de Programação Orientada a Objetos
Persistência dos dados com o
1
INDICE
1. INTRODUÇÃO AO HIBERNATE 2
1.1. MAPEAMENTO OBJETO-RELACIONAL 2
1.2. POJO 3
1.3. CONFIGURAÇÃO 4
1.3.1. HIBERNATE.CFG.XML 4
1.3.2. HBM.XML 5
1.4. DIALETOS SUPORTADOS 5
1.5. HQL 6
1.6. TIPOS DE DADOS 7
2. CRIANDO UMA SIMPLES APLICAÇÃO 7
2.1. A INTERFACE GRÁFICA 8
2.2. O BANCO DE DADOS 9
2.3. MAPEANDO O BANCO DE DADOS 9
2.4. CONFIGURANDO O HIBERNATE 10
2.5. A CLASSE DA SESSÃO 11
2.6. A CLASSE DE PERSISTÊNCIA 12
2.7. IMPLEMENTANDO AS CLASSES 13
2.8. RODANDO A APLICAÇÃO 16
3. REFERÊNCIAS 20
Persistência dos dados com o
2
1. INTRODUÇÃO AO HIBERNATE
O Hibernate é um Java FrameWork responsável por realizar a persistência dos
dados no Banco de Dados utilizando o Mapeamento Objeto-Relacional. Ele funciona
como um MiddleWare, uma camada que está entre a aplicação e o Banco de Dados,
servindo como um intermediário e diminuindo a complexidade da programação,
reduzindo substancialmente o tempo de desenvolvimento.
Ele facilita o mapeamento dos atributos entre uma base tradicional de dados
relacionais e o modelo objeto de uma aplicação, mediante o uso de arquivos XML para
estabelecer esta relação.
Sua principal característica é a transformação das classes (POJO) e tipos de dados
do Java para tabelas e tipos de dados SQL. O Hibernate gera as chamadas SQL
(Select, Insert, Join, Triggers...) e libera o desenvolvedor do trabalho manual da
conversão dos dados resultante, mantendo o programa portável para qualquer banco
de dados SQL, porém causando um pequeno aumento no tempo de execução.
Demonstração do papel do Hibernate em uma aplicação
1.1. MAPEAMENTO OBJETO-RELACIONAL
O Object-Relational Mapping (ORM), em português, Mapeamento Objeto-
Relacional, é uma técnica de desenvolvimento utilizada para facilitar a comunicação da
programação orientada aos objetos com os bancos de dados relacionais. As tabelas do
banco de dados são representadas através de classes e os registros de cada tabela são
representados como instâncias das classes.
Com esta técnica aliada ao Hibernate, o programador não precisa se preocupar com
os comandos em linguagem SQL, apenas irá utilizar uma interface de programação
simples que faz todo o trabalho de persistência.
Persistência dos dados com o
3
O Hibernate utiliza duas técnicas de mapeamento: arquivos XML separados da
aplicação e Annotations (Anotações) que estão presentes no próprio código. Iremos
abordar apenas o uso de arquivos XML.
1.2. POJO
POJO significa Plain Old Java Objects, a tradução mais próxima para o português
seria: O Simples e Velho Objeto Java. Seu objetivo é criar classes o mais simples
possível, seguindo um padrão já definido, que tornam suas instâncias "genéricas" para
todo o programa e diversos FrameWorks que se beneficiam desta técnica.
Uma classe POJO segue definições rígidas de estrutura:
Construtor sem argumentos;
Atributos declarados como private;
Métodos getters e setters, para cada atributo, declarados como public;
Nada mais que isso.
Abaixo segue um exemplo de uma classe POJO:
public class Usuario { private int ID;
private String nome; private String email;
// CONSTRUTOR
public Usuario() {
}
// GETTERS public int getID() {
return ID;
} public String getNome() {
return nome; } public String getEmail() {
return email; }
// SETTERS public void setID(int ID) {
this.ID = ID;
} public void setNome(String nome) {
this.nome = nome; } public void setEmail(String email) {
this.email = email; }
}
No Hibernate o POJO é utilizado para mapear os campos do Banco de Dados na
aplicação, permitindo que a geração do código SQL seja feita de forma automática, em
tempo de execução.
Persistência dos dados com o
4
Uma regra que deve ser seguida rigorosamente é criar a classe POJO com o mesmo
nome da tabela a qual está sendo associado e os atributos com o mesmo nome e tipo
dos campos. Isto não é obrigatório, mais por questão de organização e controle do
código esta regra é altamente recomendada.
1.3. CONFIGURAÇÃO
Para que o Hibernate funcione, além de importar as APIs necessárias para seu
projeto, é preciso configurá-lo corretamente. Ele pode ser configurado de diversas
formas:
Utilizando uma instância de org.hibernate.cfg.Configuration;
Através do arquivo hibernate.properties;
Através do arquivo hibernate.cfg.xml.
Utilizaremos o hibernate.cfg.xml em nossos exemplos. Há um grande número
de propriedades que controlam o comportamento do Hibernate em tempo de execução,
sendo possível configurá-las em qualquer uma das técnicas citadas acima.
Também é preciso mapear as classes POJO contendo a estrutura das tabelas, que
por sua vez pode ser feito de duas maneiras:
Com o uso de @Annotations;
Com o uso do hbm.xml.
Os Annotations nos permite fazer o mapeamento diretamente no POJO utilizando o
@ antes da declaração da classe, métodos e atributos. Já o hbm.xml (Hibernate
Mapping) é um arquivo separado que possui a localização do POJO. Utilizaremos o
hbm.xml em nossos exemplos.
1.3.1. HIBERNATE.CFG.XML
O hibernate.cfg.xml contém basicamente as seguintes informações:
Local onde se encontra o Banco de Dados
Dialeto do Banco de Dados (MySQL, SQL Server, Oracle, Firebird...);
Usuário e senha;
Local onde se encontram os hmb.xml;
Tipo de cache a ser utilizado;
Habilitar a coleta de estatísticas para melhorar o desempenho;
E várias outras propriedades.
A seguir temos um exemplo do hibernate.cfg.xml:
Persistência dos dados com o
5
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration
DTD 3.0//EN" "http://www.hibernate.org/dtd/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
<session-factory>
<property
name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property
name="hibernate.connection.url">jdbc:mysql://localhost/banco_dados</property>
<property name="hibernate.connection.username">usuario</property>
<property name="hibernate.connection.password"/>senha</property>
<property
name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property name="show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<property name="hibernate.generate_statistics">true</property>
<mapping resource="classePOJO.hbm.xml"/>
</session-factory>
</hibernate-configuration>
1.3.2. HBM.XML
O arquivo hbm.xml é responsável por mapear Banco de Dados, informando o nome
da tabela, nome, tamanho e tipo de dados dos campos, o elemento identificador da
tabela entre outras informações.
A nomenclatura deste arquivo deve ser a seguinte: nome_pojo.hbm.xml. O
exemplo a seguir demonstra como um arquivo de mapeamento deve ser criado:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="aplicacao.exemplo" table="tabela_exemplo">
<id column="id" name="id" type="java.lang.Long">
<generator class="native"></generator>
</id>
<property column="nome" name="nome" length="50"
type="java.lang.String"/>
<property column="email" name="email" length="50"
type="java.lang.String"/>
<property column="data_nascimento" name="data_nascimento"
type="java.util.Date"/>
</class>
</hibernate-mapping>
1.4. DIALETOS SUPORTADOS
Você deve sempre determinar a propriedade hibernate.dialect ao configurar o
Hibernate. Se você especificar um dialeto, o Hibernate usará padrões lógicos exclusivos
para o dialeto informado, reduzindo o esforço de especificá-los manualmente.
Persistência dos dados com o
6
A seguir temos uma tabela com os principais Bancos de Dados suportados pelo
Hibernate:
Banco de Dados Dialeto
PostgreSQL org.hibernate.dialect.PostgreSQLDialect
MySQL5 org.hibernate.dialect.MySQL5Dialect
Oracle 11g org.hibernate.dialect.Oracle10gDialect
SQL Server 2008 org.hibernate.dialect.SQLServer2008Dialect
HypersonicSQL org.hibernate.dialect.HSQLDialect
Interbase org.hibernate.dialect.InterbaseDialect
Firebird org.hibernate.dialect.FirebirdDialect
1.5. HQL
O Hibernate vem com uma poderosa linguagem de consulta, o Hibernate Query
Language (HQL), que é muito parecida com o SQL. No entanto, comparado com o SQL
o HQL é totalmente orientado à objetos, e compreende noções de herança, polimorfismo
e associações.
As Consultas não diferenciam maiúscula de minúscula, exceto pelo nomes das
classes e propriedades Java. Portanto, SeLeCT é o mesmo que sELEct que é o mesmo
que SELECT, mas org.hibernate.EXEMPLO não é org.hibernate.Exemplo e
exemplo.Teste não é exemplo.tEsTe.
A seguir são apresentados alguns exemplos de HQL:
// SELECT Query query = session.createQuery("from pessoas where id = :id ");
query.setParameter("id", "2324");
// UPDATE
Query query = session.createQuery("update pessoas set nome = :nome where id =
:id");
query.setParameter("nome", "Fulano");
query.setParameter("id", "2324");
// DELETE
Query query = session.createQuery("delete pessoas where id = :id");
query.setParameter("id", "2324");
Para realizarmos um INSERT, UPDATE ou DELETE, não precisamos escrever o HQL
como mostra o exemplo acima, apenas precisamos atribuir os devidos valores para o
POJO e utilizarmos um código como o citado abaixo para persistir os dados:
try {
transacao = sessao.beginTransaction();
sessao.save(pojo);
transacao.commit();
} catch (Exception e) { }
Persistência dos dados com o
7
1.6. TIPOS DE DADOS
Sabemos que o Java possui seus próprios tipos de dados (java.lang.String,
java.lang.Character, java.util.Date, java.util.List...), assim como o SQL
também possui (varchar, character, timestamp...). Isso poderia se tornar um
problema em alguns casos, pois nem sempre a conversão de um tipo de dado do Java
coincidiria com um tipo de dado SQL.
Por exemplo, no Java temos o tipo java.util.Date responsável por armazenar
data e hora, ou apenas um dos dois. Na linguagem SQL temos date (Data), time
(Horário) e timestamp (Data e Horário). Uma conversão deste tipo pode não ser bem
sucedida em determinadas situações.
Para que este tipo de problema não ocorra, o Hibernate tem seus próprios tipos de
dados, que funcionam como intermediários entre os tipos da aplicação e o Banco de
Dados, garantindo uma conversão segura.
Confira a tabela comparativa entre os tipos de dados do Hibernate e do Java:
Hibernate Java
integer int, java.lang.Integer
long long, java.lang.Long
short short, java.lang.Short
float float, java.lang.Float
double double, java.lang.Double
character char, java.lang.Character
byte byte, java.lang.Byte
boolean, yes_no, true_false boolean, java.lang.Boolean
string, text java.lang.String
date, time, timestamp java.util.Date
calendar, calendar_date java.util.Calendar
big_decimal java.math.BigDecimal
big_integer java.math.BigInteger
Locale java.util.Locale
timezone java.util.TimeZone
currency java.util.Currency
class java.lang.Class
Binary byte[]
2. CRIANDO UMA SIMPLES APLICAÇÃO
Iremos desenvolver uma simples aplicação que realizará as funções básicas do SQL:
SELECT, INSERT, UPDATE e DELETE. Iremos utilizar o Java 6, Hibernate 3.6.6, MySQL5
Persistência dos dados com o
8
e o NetBeans 7 neste projeto. Para baixar o Hibernate acesse:
http://hibernate.org/downloads.
Primeiramente crie um novo projeto no NetBeans com o nome de sua preferência,
aqui daremos o nome de HelloHibernate. Feito isso iremos importar as APIs
necessárias para o funcionamento do Hibernate, são elas:
hibernate3.jar;
hibernate-jpa-2.0-api-1.0.1.Final.jar;
antlr-2.7.6.jar;
commons-collections-3.1.jar;
dom4j-1.6.1.jar;
javassist-3.12.0.GA.jar;
jta-1.1.jar;
slf4j-api-1.6.1.jar;
slf4j-simple-1.6.1.jar.
A API slf4j-simple-1.6.1.jar não vem no pacote de instalação do Hibernate,
mas ainda assim é necessário para seu funcionamento. Para baixá-la acesse:
http://slf4j.org/download.html.
Agora iremos criar as seguintes classes:
Main (Formulário JFrame);
HibernateUtil (Classe que realizará a persistência dos dados);
Sessao (Responsável pela conexão com o Banco de Dados);
Pessoas (POJO da tabela pessoas que será criada mais a frente).
Nesta aplicação iremos fazer um sistema de cadastro/consulta com apenas 3
campos: nome, idade e sexo que são do tipo, respectivamente, string, integer e
character.
2.1. A INTERFACE GRÁFICA
A interface gráfica deve ser feita parecida com a figura abaixo:
Persistência dos dados com o
9
Interface Gráfica da aplicação
Nesta interface encontramos os seguintes componentes Swing:
JTextField: txtNome;
JSpinner: spnIdade;
JRadioButton: rdoM e rdoF (Com o ButtonGroup grpSexo);
JButton: btnInserir, btnAtualizar, btnDeletar;
JTable: tblRegistros.
2.2. O BANCO DE DADOS
O nome do Banco de Dados será hello_hibernate e o nome da tabela pessoas.
A estrutura da tabela deve ser feita da seguinte forma:
Campo Tipo Tamanho Atributos
id int Auto Increment, Primary Key
nome varchar 50
Idade Int 3
sexo char 1
2.3. MAPEANDO O BANCO DE DADOS
Chegou a hora de criarmos o POJO, a classe responsável por mapear a tabela
pessoas. Ela deve ficar da seguinte forma:
public class Pessoas {
// ATRIBUTOS
private int id;
private String nome;
Persistência dos dados com o
10
private int idade;
private char sexo;
// CONSTRUTOR
public Pessoas() {
}
// GETTERS
public int getId() {
return id;
}
public String getNome() {
return nome;
}
public int getIdade() {
return idade;
}
public char getSexo() {
return sexo;
}
// SETTERS
public void setId(int id) {
this.id = id;
}
public void setNome(String nome) {
this.nome = nome;
}
public void setIdade(int idade) {
this.idade = idade;
}
public void setSexo(char sexo) {
this.sexo = sexo;
}
}
Apenas declaramos os quatro atributos com seus respectivos tipos e com o
modificador de acesso private. Em seguida criamos os métodos getters e setters para
cada atributo.
2.4. CONFIGURANDO O HIBERNATE
Agora iremos criar o pessoas.hbm.xml, o arquivo contendo o mapeamento da
tabela pessoas com os tipos de dados do Hibernate e que também informa o POJO
responsável pelo mapeamento, neste caso a classe Pessoas. O arquivo deve ficar
desta forma:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-mapping PUBLIC "-//Hibernate/Hibernate Mapping DTD 3.0//EN"
"http://hibernate.sourceforge.net/hibernate-mapping-3.0.dtd">
<hibernate-mapping>
<class name="Pessoas" table="pessoas">
<id name="id">
<generator class="native"/>
Persistência dos dados com o
11
</id>
<property name="nome" type="string" length="50"/>
<property name="idade" type="integer" length ="3"/>
<property name="sexo" type="character" length ="1"/>
</class>
</hibernate-mapping>
Feito isso, iremos criar o hibernate.cfg.xml, arquivo responsável pela conexão
com o Banco de Dados e pelo comportamento geral do Hibernate. Iremos informar o
Dialeto, Driver e URL do Banco de Dados, usuário, senha e habilitaremos as opções de
mostrar o SQL no console da IDE com formatação (Apenas para facilitar o entendimento
do código) e a geração de estatísticas.
Repare que no final deste arquivo indicamos o local do pessoas.hbm.xml na
propriedade resource da Tag mapping.
O arquivo deve ficar da seguinte forma:
<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration
DTD 3.0//EN" "http://hibernate.sourceforge.net/hibernate-configuration-
3.0.dtd">
<hibernate-configuration>
<session-factory>
<property
name="hibernate.dialect">org.hibernate.dialect.MySQLDialect</property>
<property
name="hibernate.connection.driver_class">com.mysql.jdbc.Driver</property>
<property
name="hibernate.connection.url">jdbc:mysql://localhost:3306/hello_hibernate</pr
operty>
<property name="hibernate.connection.username">root</property>
<property name="hibernate.connection.password"/>
<property name="hibernate.show_sql">true</property>
<property name="hibernate.format_sql">true</property>
<property name="hibernate.generate_statistics">true</property>
<!-- ARQUIVO DE MAPEAMENTO -->
<mapping resource="pessoas.hbm.xml"/>
</session-factory>
</hibernate-configuration>
2.5. A CLASSE DA SESSÃO
A classe Sessao será responsável por ler o arquivo hibernate.cfg.xml e
estabelecer a conexão com o Banco de Dados. Nela usaremos apenas três classes:
Configuration, SessionFactory e Session.
A classe Configuration é responsável por ler o arquivo hibernate.cfg.xml e
iniciar a sessão propriamente dita.
Persistência dos dados com o
12
A classe SessionFactory possui um custo alto de criação, é criado uma única vez,
no início da execução da aplicação, a partir da instância de uma Configuration.
Uma Session é um objeto de baixo custo de criação e deve ser usado uma vez,
para uma única requisição e então deve ser descartada (sessao.close()).
Uma transação precisa ser o mais curta possível, para reduzir a disputa pelo
bloqueio na Base de Dados. Transações longas impedirão que sua aplicação seja
altamente concorrente.
A classe Sessao deve ficar da seguinte maneira:
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.cfg.Configuration;
public class Sessao {
private static SessionFactory fabricaSessao;
// Estrutura static para garantir que a SessionFactory seja iniciada apenas
uma vez
static {
try {
fabricaSessao = new
Configuration().configure("hibernate.cfg.xml").buildSessionFactory();
} catch (Exception e){
e.printStackTrace();
}
}
public static Session getSessao(){
return fabricaSessao.openSession();
}
}
2.6. A CLASSE DE PERSISTÊNCIA
Feita a classe Sessao iremos implementá-la na classe HibernateUtil junto com
os métodos select, insertUpdate e delete.
Nesta classe precisaremos das classes Session, Transaction, Query e List.
A Session nos permite acessar a SessionFactory. A Transaction é quem
iniciará a Session e execuratá a Query. Ao realizar o SELECT será retornado uma
List.
Veja como deve ficar a classe:
import java.util.ArrayList;
import java.util.List;
import javax.swing.JOptionPane;
import org.hibernate.HibernateException;
import org.hibernate.Query;
import org.hibernate.Session;
import org.hibernate.Transaction;
public class HibernateUtil {
Persistência dos dados com o
13
private Session sessao;
private Transaction transacao;
private Query query;
public List select(){
List<Pessoas> lista = new ArrayList();
try {
this.sessao = Sessao.getSessao();
transacao = sessao.beginTransaction();
query = sessao.createQuery("from Pessoas");
lista = query.list();
sessao.close();
} catch (HibernateException e) {
JOptionPane.showMessageDialog(null, "Erro ao realizar
Select.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
e.printStackTrace();
}
return lista;
}
public void insertUpdate(Pessoas pessoa){
try{
this.sessao = Sessao.getSessao();
transacao = sessao.beginTransaction();
sessao.saveOrUpdate(pessoa);
transacao.commit();
sessao.close();
JOptionPane.showMessageDialog(null, "Registro salvo com sucesso!",
null, JOptionPane.INFORMATION_MESSAGE);
} catch (HibernateException e) {
JOptionPane.showMessageDialog(null, "Erro ao persistir os
dados.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
e.printStackTrace();
}
}
public void delete(Pessoas pessoa){
try{
this.sessao = Sessao.getSessao();
transacao = sessao.beginTransaction();
sessao.delete(pessoa);
transacao.commit();
sessao.close();
JOptionPane.showMessageDialog(null, "Registro deletado com
sucesso!", null, JOptionPane.INFORMATION_MESSAGE);
} catch (HibernateException e) {
JOptionPane.showMessageDialog(null, "Erro ao deletar
registro.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
e.printStackTrace();
}
}
}
Como você pode ver, criamos três métodos: select, insertUpdate e delete. Em
select utilizamos o HQL para realizar uma consulta que retornará uma List. Em
insertUpdate utilizamos o método saveOrUpdate que realiza tanto o INSERT quanto
o UPDATE (apenas se o atributo id já existir). Em delete utilizamos o método delete
para apagar determinado registro.
Note que tanto em insertUpdate e delete passamos por parâmetro o POJO
Pessoas e no método select retornamos uma List<Pessoas>. Observe também
que utilizamos o sessao.beginTransaction() para iniciar a sessão, em seguida
Persistência dos dados com o
14
executamos a query com o transacao.commit() e fechamos a sessão,
sessao.close(). Isso é muito importante pois, como vimos anteriormente, uma
transação tem que ser o mais curta possível.
2.7. IMPLEMENTANDO AS CLASSES
Agora vamos implementar o HibernateUtil e outros métodos na classe principal
Main, tornando a aplicação funcional. Vamos começar com a declaração dos atributos e
do método construtor Main.
private HibernateUtil hibernate;
private Pessoas pessoas;
private DefaultTableModel tblModel;
private int id;
public Main() {
hibernate = new HibernateUtil();
pessoas = new Pessoas();
initComponents();
setLocationRelativeTo(null);
setListeners();
atualizarTabela();
}
O que acabamos de fazer?
Instanciamos o HibernateUtil e o POJO Pessoas;
Iniciamos os componentes Swing;
Centralizamos a tela;
Adicionamos os listeners necessários (A seguir);
Atualizamos a tabela (A seguir).
Agora iremos criar os métodos limparCampos e validarCampos:
private void limparCampos(){
id = 0;
txtNome.setText("");
spnIdade.setValue(0);
grpSexo.clearSelection();
}
private boolean validarCampos(){
if(txtNome.getText().isEmpty()){
JOptionPane.showMessageDialog(null, "Informe o nome", null,
JOptionPane.WARNING_MESSAGE);
return false;
} else if((Integer)spnIdade.getValue() < 1){
JOptionPane.showMessageDialog(null, "Informe uma idade válida", null,
JOptionPane.WARNING_MESSAGE);
return false;
} else if(!rdoF.isSelected() && !rdoM.isSelected()){
JOptionPane.showMessageDialog(null, "Informe o sexo", null,
JOptionPane.WARNING_MESSAGE);
return false;
}
return true;
}
Persistência dos dados com o
15
Feito isso, o próximo passo é criar os métodos setPessoas (Que irá pegar os
valores do formulário e setar no POJO) e atualizarTabela (Que chamará o método
select do HibernateUtil e preencherá a tabela sempre que um evento for
disparado).
private void setPessoas() {
pessoas.setId(id);
pessoas.setNome(txtNome.getText());
pessoas.setIdade((Integer)spnIdade.getValue());
if(rdoM.isSelected())
pessoas.setSexo('M');
else if(rdoF.isSelected())
pessoas.setSexo('F');
}
private void atualizarTabela(){
try {
limparCampos();
tblModel.getDataVector().clear();
List<Pessoas> select = hibernate.select();
if(!select.isEmpty()){
for(Pessoas p : select)
tblModel.addRow(new Object[]{p.getId(), p.getNome(),
p.getIdade(), p.getSexo()});
}
} catch (Exception e) {
JOptionPane.showMessageDialog(null, "Erro ao atualizar
tabela\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);
}
}
Por último iremos adicionar os listeners nos botões e na tabela. Nos botões
btnInserir, bntAtualizar e BtnDeletar iremos adicionar um ActionListener
que, primeiramente, realizará uma validação e caso a mesma seja positiva executará o
setPessoas, depois o método do HibernateUtil (insertUpdade ou delete) e por
último atualizará a tabela.
Na tabela adicionaremos um MouseListener e sobrescreveremos o método
mouseClicked. Ao clicarmos em uma linha, os campos nome, idade e sexo serão
preenchidos e o atributo id terá seu valor atualizado.
private void setListeners() {
btnInserir.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if(validarCampos()){
id = 0;
setPessoas();
hibernate.insertUpdate(pessoas);
atualizarTabela();
}
}
});
btnAtualizar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
Persistência dos dados com o
16
if(validarCampos()){
setPessoas();
hibernate.insertUpdate(pessoas);
atualizarTabela();
}
}
});
btnDeletar.addActionListener(new ActionListener() {
@Override
public void actionPerformed(ActionEvent e) {
if(id > 0){
setPessoas();
hibernate.delete(pessoas);
atualizarTabela();
}
}
});
tblRegistros.addMouseListener(new MouseAdapter() {
@Override
public void mouseClicked(MouseEvent e) {
int linha = tblRegistros.getSelectedRow();
id = (Integer)tblRegistros.getModel().getValueAt(linha, 0);
txtNome.setText(tblRegistros.getModel().getValueAt(linha,1)+"");
spnIdade.setValue(tblRegistros.getModel().getValueAt(linha, 2));
if((Character)tblRegistros.getModel().getValueAt(linha, 3)=='M')
rdoM.setSelected(true);
else if((Character)tblRegistros.getModel().getValueAt(linha,
3)=='F')
rdoF.setSelected(true);
}
});
}
Com isso feito nossa aplicação já está pronta para ser testada. Vamos lá?
2.8. RODANDO A APLICAÇÃO
Agora vamos dar um Build (F11) no projeto e observar no console do NetBeans se
houve alguma exceção . Se você seguiu todos os passos a risca então o processo de
compilação será executado com sucesso.
Vamos rodar a aplicação (F6) e novamente observar o console. Agora você está
diante do Log de inicialização do Hibernate que deve ser parecido com a figura abaixo:
Persistência dos dados com o
17
Log de inicialização do Hibernate no NetBeans
É muito importante prestarmos atenção neste Log, pois nele encontramos
informações úteis a respeito de sua configuração e a possíveis HibernateException
que podem vir a acontecer.
Agora observe o final do Log, mais precisamente na consulta SQL que foi feita: um
SELECT gerado automaticamente. Lembram-se que no método construtor da classe
principal Main chamamos o método atualizarTabela? Se você estiver vendo esta
consulta SQL em seu console e não houve nenhum HibernateException significa
que o Hibernate está configurado perfeitamente e que o SELECT foi executado sem
erros.
Vamos voltar para a aplicação. Como ainda não temos nenhum registro no Banco de
Dados, mesmo com o SELECT sendo feito, temos uma tabela vazia na aplicação. Para
resolver isso vamos inserir alguns registros:
Persistência dos dados com o
18
INSERT
Enquanto você inseria os registros, você observou o console do NetBeans com as
consultas SQL (INSERT e SELECT) sendo geradas automaticamente? Até agora não
precisamos nos preocupar com nenhum código SQL, não é mesmo? E vamos continuar
assim graças ao Hibernate.
Agora vamos testar o UPDATE e DELETE:
U
UPDATE DELETE
Acabamos de persistir os dados com o Hibernate provando a facilidade de uso e
eficiência deste incrível FrameWork. Se compararmos com o modo tradicional (JDBC,
ResultSet, Next), o Hibernate nos livra da mão de obra e stress de construir diversas
consultas SQL que muitas vezes precisam ser refeitas e podem acabar complicando o
entendimento do código e comprometendo sua integridade.
Persistência dos dados com o
19
Com pouco tempo de estudo e mínimos conhecimentos em Banco de Dados,
podemos desenvolver aplicações magníficas que se aproveitam do Paradigma da
Orientação a Objetos para persistir os dados em praticamente qualquer Banco de Dados
utilizado atualmente. Isso mesmo, aprendendo Hibernate aprenderemos a trabalhar
também com o Oracle, MySQL, PosgreSQL, SQL Server, SQLite, Firebird e muitos
outros SGBDs famosos pela sua segurança e robustez.
Persistência dos dados com o
20
3. REFERÊNCIAS
LINWOOD, Jeff; MINTER, Dave. Beginning Hibernate. 2ª Edição. New York: Apress,
2010. 379.
RED HAT. HIBERNATE - Persistência Relacional para Java Idiomático. Disponível
em: <http://docs.jboss.org/hibernate/core/3.6/reference/pt-BR/html_single/>.
CAFÉ, Adriel Almeida. POJO: Encapsulando as Classes. Disponível em:
<http://adrielcafe.com/cafelog/java/35-pojo-encapsulando-as-classes>.