Persistência de dados com o

Transcrição

1 Persistência de dados com o Faculdade Zacarias de Góes Sistemas de Informação Linguagem de Programação Orientada a Objetos

2 1 INDICE 1. INTRODUÇÃO AO HIBERNATE MAPEAMENTO OBJETO-RELACIONAL POJO CONFIGURAÇÃO HIBERNATE.CFG.XML HBM.XML DIALETOS SUPORTADOS HQL TIPOS DE DADOS 7 2. CRIANDO UMA SIMPLES APLICAÇÃO A INTERFACE GRÁFICA O BANCO DE DADOS MAPEANDO O BANCO DE DADOS CONFIGURANDO O HIBERNATE A CLASSE DA SESSÃO A CLASSE DE PERSISTÊNCIA IMPLEMENTANDO AS CLASSES RODANDO A APLICAÇÃO REFERÊNCIAS 20

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

4 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 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 ; // CONSTRUTOR public Usuario() { // GETTERS public int getid() { return ID; public String getnome() { return nome; public String get () { return ; // SETTERS public void setid(int ID) { this.id = ID; public void setnome(string nome) { this.nome = nome; public void set (string ) { this. = ; 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.

5 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 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 Com o uso do hbm.xml. Os Annotations nos permite fazer o mapeamento diretamente no POJO utilizando 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 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:

6 5 <?xml version="1.0" encoding="utf-8"?> <!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD 3.0//EN" " <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> 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" " <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=" " name=" " 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.

7 6 A seguir temos uma tabela com os principais Bancos de Dados suportados pelo Hibernate: Banco de Dados PostgreSQL MySQL5 Oracle 11g SQL Server 2008 HypersonicSQL Interbase Firebird Dialeto org.hibernate.dialect.postgresqldialect org.hibernate.dialect.mysql5dialect org.hibernate.dialect.oracle10gdialect org.hibernate.dialect.sqlserver2008dialect org.hibernate.dialect.hsqldialect org.hibernate.dialect.interbasedialect 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) {

8 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 integer long short float double character byte boolean, yes_no, true_false string, text date, time, timestamp calendar, calendar_date big_decimal big_integer Locale timezone currency class Binary Java int, java.lang.integer long, java.lang.long short, java.lang.short float, java.lang.float double, java.lang.double char, java.lang.character byte, java.lang.byte boolean, java.lang.boolean java.lang.string java.util.date java.util.calendar java.math.bigdecimal java.math.biginteger java.util.locale java.util.timezone java.util.currency java.lang.class 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

9 8 e o NetBeans 7 neste projeto. Para baixar o Hibernate acesse: 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 final.jar; antlr jar; commons-collections-3.1.jar; dom4j jar; javassist ga.jar; jta-1.1.jar; slf4j-api jar; slf4j-simple jar. A API slf4j-simple jar não vem no pacote de instalação do Hibernate, mas ainda assim é necessário para seu funcionamento. Para baixá-la acesse: 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 A INTERFACE GRÁFICA A interface gráfica deve ser feita parecida com a figura abaixo:

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

11 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 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" " <hibernate-mapping> <class name="pessoas" table="pessoas"> <id name="id"> <generator class="native"/>

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

13 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 {

14 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

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

16 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() public void actionperformed(actionevent e) { if(validarcampos()){ id = 0; setpessoas(); hibernate.insertupdate(pessoas); atualizartabela(); ); btnatualizar.addactionlistener(new ActionListener() public void actionperformed(actionevent e) {

17 16 if(validarcampos()){ setpessoas(); hibernate.insertupdate(pessoas); atualizartabela(); ); btndeletar.addactionlistener(new ActionListener() public void actionperformed(actionevent e) { if(id > 0){ setpessoas(); hibernate.delete(pessoas); atualizartabela(); ); tblregistros.addmouselistener(new MouseAdapter() 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:

18 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:

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

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

21 20 3. REFERÊNCIAS LINWOOD, Jeff; MINTER, Dave. Beginning Hibernate. 2ª Edição. New York: Apress, RED HAT. HIBERNATE - Persistência Relacional para Java Idiomático. Disponível em: < CAFÉ, Adriel Almeida. POJO: Encapsulando as Classes. Disponível em: <