Hibernate com JPA Prá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: Responsavel package 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 */ @Entity public 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 BD package 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ário package 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/