Hibernate com JPAPrática

Definição da Aplicação

Pequeno sistema de gerencia de projetos contendo as seguintes entidades: Projeto, Atividade e Responsável.

Utilizaremos

Netbeans IDE 6.8 ou superior, banco de dados MySQL ou Derby e Hibernate 3.x .

Criando novo Projeto e Configurando o hibernate.

Criar um novo aplicativo Java Arquivo -> Novo Projeto -> Java -> Aplicativo Java

Configurar o Hibernate Adicionar Bilbiotecas

botão direito sobre a pasta bibliotecas escolha a opção Adicionar Biblioteca procure por “Hibernate JPA” clique em adicionar

Preparar Banco de Dados Adicionar biblioteca do DB (MySQL, por ex., MySQL

JDBC Driver.)

Preparar a estrutura do Projeto

Criar os seguintes pacotes: conf -> configuração do hibernate modelos - > pacote para as classes de domínio

Projeto, Atividade e Responsável)

testes -> classes que vamos utilizar para fazer nossos testes.

utils -> classes utilitárias.

Configuração do Hibernate Adicionar hibernate.cfg.xml no pacote conf

botão direito do mouse sobre o pacote conf e escolha a opção novo.

No lado categorias selecione Hibernate e do lado direito a opção Assistente Para configuração do Hibernate

Configuração do Hibernate

Clicando no botão próximo o assistente solicita o nome arquivo Alterar pasta para src/conf, porque nós queremos que nosso

arquivo fique no pacote conf.

Conexão com uma fonte de dados

Pode ter sido previamente criada, mas vamos criar uma nova conexão.

Escolha no combobox a opção Nova Conexão com Banco de Dados

Conexão com uma fonte de dados

Conexão com uma fonte de dados Nome do Driver: Driver JDBC do banco que vamos conectar: MySQL Host: Máquina onde nosso banco de dados está instalado e esperando por conexão:

localhost (nossa própria máquina) Porta: porta em que o mysql está escutando, aguardando por conexão, se nenhuma

porta é informada é utilizada a porta padrão a 3306. Banco de Dados: Nome da nossa fonte de dados, onde nossas tabelas serão

criadas. Se ainda não foi criado seu banco, use o seu mysql. Chamar banco de dados de projectdb

Nome Usuário: Nome do usuário usado para acessar seu banco de dados, vamos usar o usuário administrador que no mysql é o usuário root.

Senha: Informe a senha usada para acessar o banco de dados.

Alterando a configuração atual Exibir na console toda e qualquer instrução enviada

para o banco de dados. Na janela de configuração do arquivo vamos selecionar

a opção Propriedades Opcionais -> Propriedades de

Configurar -> Adicionar

escolha a opção hibernate.show_sql e valor digite true.

Primeira Entidade: Responsavelpackage modelos;

import java.io.Serializable;import javax.persistence.Entity;import javax.persistence.GeneratedValue;import javax.persistence.GenerationType;import javax.persistence.Id;

/** * criando em 10/11/2010 * @author bacala */@Entitypublic class Responsavel implements Serializable {

@Id @GeneratedValue private long id; private String matricula; private String nome;

// métodos get e set

public long getId() { return id; } ……

Anotações JPA É importante observar que os imports feitos, foram todos do pacote

javax.persitence e não do pacote do hibernate, isso porque nós queremos seguir a especificação e não apenas usar o hibernate de forma pura.

Detalhando as anotações: @Entity -> a classe é uma entidade e que seus objetos serão persistido em

banco de dados @Id -> Informa o atributo que será nossa chave primaria. @GeneratedValue -> Informa que o valor desse atributo será gerado

automaticamente. Em nenhum momento fizemos referencia à nenhum nome de tabela ou

coluna do banco de dados, isso porque estamos convencionando que o nome da tabela será o mesmo nome da classe e que o nome das colunas será o mesmo nome dos atributos. @Table(name=”nome_tabela”) informa o nome da tabela com a qual nossa

entidade seria mapeada. @Column(“nome_coluna”) informa nomes diferente para nossas colunas da

tabela.

Informar ao Hibernate as classes informar para o hibernate a localização das

classes de entidade para que ele possa reconhecer como uma entidade mapeada.

abrir arquivo hibernate.cfg.xml e na opção mapeamentos vamos adicionar a classe Responsavel.

Adicionando a entidade Responsavel

Lendo a configuração e criando um BDpackage utils;

import org.hibernate.cfg.AnnotationConfiguration;import org.hibernate.tool.hbm2ddl.SchemaExport;

public class GerarBancoDeDados { public static void main(String...args) { /** * AnnotationConfiguration - responsavel por ler arquivo hibernate.cfg.xml e reconhecer nossas entidades mapeadas. **/ AnnotationConfiguration configuration = new AnnotationConfiguration(); /** * o método configure solicita o caminho do arquivo hibernate.cfg.xml. Caso o arquivo * não esteja em um pacote diferente do pacote desta classe, não seria necessario * informá-lo . Simplesmente usaríamos configuration.configure(). **/ configuration.configure("conf/hibernate.cfg.xml"); SchemaExport export = new SchemaExport(configuration); /** * create espera dois argumento booleanos. O primeira informa * se queremos que ele exiba o script sql gerado. O segundo se queremos * que ele execute diretamente as instruções no banco de dados.**/ export.create(true, true); }}

Criando um utilitáriopackage utils;

import org.hibernate.Session;import org.hibernate.SessionFactory;import org.hibernate.cfg.AnnotationConfiguration;

public class HibernateUtil { private static SessionFactory factory;

/** * escopo estático. É a primeira coisa executa em uma classe e só executada apenas uma vez. Objetivo é carregar nossas configurações do * hibernate para que sessões possam ser criadas. * O hibernate possui uma classe responsavel por funciona como uma fábrica de sessões: classe SessionFactory **/ static { AnnotationConfiguration configuration = new AnnotationConfiguration(); configuration.configure("conf/hibernate.cfg.xml"); factory = configuration.buildSessionFactory(); } /** * sempre que quisermos uma session do hibernate apenas chamamos * HibernateUtils.getSession();**/ public static Session getSession(){ return factory.openSession(); }}

Testando...package testes;

import modelos.Responsavel;import org.hibernate.Session;import utils.HibernateUtil;

public class TestaEntidadeResponsavel { public static void main(String...args) { /** * Solicitando uma sessão para nossa fábrica de sessões. **/ Session session = HibernateUtil.getSession(); /** * Criando um objeto da nossa entidade que será salvo no banco **/Responsavel responsavel = new Responsavel();

responsavel.setMatricula("AM-123"); responsavel.setNome(“Mané ");/** * Iniciando uma transação com o banco de dados **/ session.getTransaction().begin(); /** * chamando o método save do hibernate para persistir nosso objeto **/ session.save(responsavel); /** * encerrando e comitando nossa transação **/ session.getTransaction().commit(); }}

Recuperando o objeto gravado...

...Responsavel resp = (Responsavel)

session.load(Responsavel.class, 1L);System.out.println("Nome: " +resp.getNome());...

Bibliografia

http://quebrandoparadigmas.wordpress.com/2010/03/21/introducao-a-jpa-com-hibernate/