persistência de dados com o hibernate

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


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.


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.


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:


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:


<!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.


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");


// DELETE

Query query = session.createQuery("delete pessoas where id = :id");


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) { }


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


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:

http://hibernate.org/downloads

http://slf4j.org/download.html


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;


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:


<!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"/>

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:


<!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>



<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.


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 {


13

private Session sessao;

private Transaction transacao;

private Query query;

public List select(){

List<Pessoas> lista = new ArrayList();

try {

this.sessao = Sessao.getSessao();


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);


}

return lista;

}

public void insertUpdate(Pessoas pessoa){

try{



sessao.saveOrUpdate(pessoa);

transacao.commit();

sessao.close();

JOptionPane.showMessageDialog(null, "Registro salvo com sucesso!",

null, JOptionPane.INFORMATION_MESSAGE);


JOptionPane.showMessageDialog(null, "Erro ao persistir os

dados.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);


}

}

public void delete(Pessoas pessoa){

try{



sessao.delete(pessoa);

transacao.commit();

sessao.close();

JOptionPane.showMessageDialog(null, "Registro deletado com

sucesso!", null, JOptionPane.INFORMATION_MESSAGE);


JOptionPane.showMessageDialog(null, "Erro ao deletar

registro.\n"+e.getMessage(), null, JOptionPane.ERROR_MESSAGE);


}

}

}

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


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,


return false;

} else if(!rdoF.isSelected() && !rdoM.isSelected()){

JOptionPane.showMessageDialog(null, "Informe o sexo", null,


return false;

}

return true;

}


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



16

if(validarCampos()){

setPessoas();

hibernate.insertUpdate(pessoas);

atualizarTabela();

}

}

});

btnDeletar.addActionListener(new ActionListener() {

@Override


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:


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:


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.


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.


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>.

persistência de dados com o hibernate

Documents