Introdução ao Hibernate

Há dois mundos diferentes de software: um é o mundo Java, em que nada além de objetos são

conhecidos, enquanto o outro é o mundo do banco de dados relacional, em que os dados

reinam.

Os desenvolvedores Java sempre trabalham com objetos representando estados e

comportamentos que modelam problemas do mundo real. A persistência de objetos é um

requisito fundamental em aplicações Java. O estado é modelado de modo a ser persistente em

repositórios duradouros para que ele se torne permanente.

Um pequeno exemplo:

Suponha que estejamos fazendo o design de um sistema de Internet banking. Esperamos que o

banco mantenha uma cópia segura de nossas contas, dos detalhes pessoais, das preferências e

das transações. Isso significa que, para serem duradouros, os dados da aplicação devem ser

persistentes em um espaço de armazenamento permanente. No contexto dessa aplicação

bancária, por dados persistentes quero dizer o cliente.

Hibernate – Mapeamento com Anotação

Projeto Desktop Uma Classe

Objetivo

Este documento descreve uma introdução ao framework Hibernate empregando Anotações. É

um exemplo simples de mapeamento objeto relacional com anotações Hibernate através de

uma pequena aplicação Desktop. Tem também uma breve introdução sobre anotações.

Programas Utilizados

Java (jdk-1_6_0_02-windows-i586-p)

Eclipse 3.2 ()

Hibernate 3.02

MySql 5.0

Criando um novo Projeto

Abrir o Eclipse 3.2 e informar um WorkSpace (Teste).

Clicar em: File | New | Project... | Java | Java Project

Clicar em: Next

Informar o nome: "SeuProjeto"

O projeto deverá ter esta estrutura:

Importando os Arquivos JARs do Hibernate e do MySQL

Criar uma pasta de nome lib no projeto para importar os arquivos jar´s do Hibernate e do

MySQL.

A pasta lib criada fica como a seguir:

Vamos importar os arquivos jar´s para o projeto. Clicar com o botão direito na pasta lib e depois

em:

Import... | General | File System | Next

Clicar no botão Browse e selecione a pasta onde se encontram os arquivos jar´s do Hibernate

(pasta Hibernate_JAR). Fazer a mesma para importar o jar do MySQL (pasta MySQL)

Selecionar os arquivos e clicar em Finish.

Informando ao Projeto que existem novos JARs

“Colocar os jars no projeto ou referenciá-los externamente?

É uma boa prática sempre colocarmos os jars de dependência de nosso projeto no próprio

projeto e não deixá-los em outro lugar e referenciá-los externamente. Desta forma, cada

projeto pode ter sua própria versão e evitamos problemas de compatibilidade. Além disso,

nosso projeto é auto-contido e conseguimos transportá-lo facilmente para outras máquinas.”

(Caelum – Java e Orientação a Objeto)

Clicar com o botão direito do mouse no projeto e depois em:

Properties | Java Build Path | na aba Libraries | no botão ADD JARs

Abrir a pasta lib, selecionar todos os arquivos jar e clique em OK.

Por fim clique em Ok.

Agora os jar estão incorporados ao projeto.

Inserindo os arquivos hibernate.cfg.xml,

hibernate-configuration-3.0.dtd e

log4j.properties na pasta src (source) do projeto

Copiar também o arquivo hibernate.cfg.xml da pasta Hibernate_Postgress/Hibernate_CFG e

colar dentro da pasta src (source).

Copiar também o arquivo hibernate-configuration-3.0.dtd da pasta

Hibernate_Postgress/Hibernate_DTD e colar dentro da pasta do projeto.

Copiar o arquivo log4j.properties (pasta Hibernate_Postgres/Hibernate_Property) e colar na

pasta do projeto, no nosso caso SeuProjeto.

Para visualizar os arquivos na janela Package Explorer clicar em Refresh.

Criando a Classe Evento com o Mapeamento Anotação

Criar o arquivo conforme abaixo e salvar como Evento.java

package modelo;

import java.io.Serializable;

import java.util.Date;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name="evento")

public class Evento implements Serializable{

@Id

@GeneratedValue(strategy=GenerationType.AUTO)

//@Column(name="idEvento")

private Integer idEvento;

private String nome ;

private Date dataInicio;

private Date dataFim;

public Evento (){}

//... IMPORTANTE: colocar os métodos GETs e SETs...

}

Vamos criar a Classe DaoEvento, responsável pela acesso com a base de dados como indicada a

seguir. Salve-a com o DaoEvento.java

package dao;

import modelo.Evento;

import org.hibernate.cfg.AnnotationConfiguration;

import org.hibernate.SessionFactory;

import org.hibernate.Transaction;

import org.hibernate.cfg.Configuration;

import org.hibernate.classic.Session;

public class DaoEvento {

private SessionFactory fabrica;

public DaoEvento() throws Exception{

// Cria uma configuração

AnnotationConfiguration configuration =

new AnnotationConfiguration();

// Lê o arquivo hibernate.cfg.xml

configuration.configure("hibernate.cfg.xml");

// Cria o objeto fabrica responsável em criar os objetos Sessions

fabrica = configuration.buildSessionFactory();

}

public void incluir(Evento e) throws Exception {

Session sessao = fabrica.openSession();

Transaction transacao= sessao.beginTransaction();

sessao.save(e);

transacao.commit();

sessao.close();

}

public void alterar(Evento e) throws Exception {

Session sessao = fabrica.openSession();

Transaction transacao= sessao.beginTransaction();

sessao.update(e);

transacao.commit();

sessao.close();

}

public void excluir(Evento e) throws Exception {

Session sessao = fabrica.openSession();

Transaction transacao= sessao.beginTransaction();

sessao.delete(e);

transacao.commit();

sessao.close();

}

public Evento consultar(Evento e)throws Exception{

Evento ev;

Session sessao =fabrica.openSession();

Transaction transacao = sessao.beginTransaction();

ev = (Evento)sessao.load(modelo.Evento.class, e.getIdEvento());

transacao.commit();

sessao.close();

return ev;

}

}

Criando Referência para o Banco de Dados (MySQL)

Abrir o hibernate.cfg.xml com algum editor (Notepad) e alterar os parâmetros de conformidade

com a configuração da sua conexão com o banco MySQL.

Deve ficar parecido com isto:

<?xml version="1.0" encoding="utf-8"?>

<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate Mapping DTD 3.0//EN"

"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">

<hibernate-configuration>

<session-factory>

<property name="hibernate.connection.driver_class">

com.mysql.jdbc.Driver</property>

<property name="hibernate.dialect">

org.hibernate.dialect.MySQLDialect</property>

<property name="hibernate.connection.url">

jdbc:mysql://localhost:3306/empresa

?createDatabaseIfNotExist=true</property>

<property name="hibernate.connection.username">aluno</property>

<property name="connection.password">aluno</property>

<property name="hibernate.hbm2ddl.auto">create</property>

<property name="hibernate.hbm2ddl.auto">update</property>

<property name="show_sql">true</property>

<property name="format_sql">true</property>

<mapping class="modelo.Evento"/>

</session-factory>

</hibernate-configuration>

Para testar criaremos uma classe Tela com o método main. Copiar o conteúdo indicado a

seguir:

package visao;

import java.util.Date;

import modelo.Evento;

import dao.DaoEvento;

public class Tela {

public static void main(String[] args) throws Exception {

try{

Date dataInicio = new Date();

Date dataFim = new Date();

DaoEvento dao = new DaoEvento();

Evento evento = new Evento();

evento.setNome("show");

evento.setDataInicio(dataInicio);

evento.setDataFim(dataFim);

dao.incluir(evento);

System.out.println("Registro inserido com sucesso!!!");

}catch(Exception e){

System.out.println("Não foi possível, Erro: " +

e.getMessage());

}

}

}

Execute o arquivo Tela.java com a opção de Run | Java Application. Se tudo estiver como

descrito, você terá inserido o primeiro registro numa base de dados utilizando o Hibernate.

Verificar no MySql se realmente foi criado o banco (empresa), a tabela (evento) e inserido

corretamente os dados indicados na classe Tela.

Resumo dos Arquivos Criados e seus Locais

SeuProjeto:

hibernate.cfg.xml

log4j.properties

hibernate-configuration-3.0.dtd

//todos os JARs do Hibernate e do PostgreSql

dao

DaoEvento.java

modelo

Evento.java

visao

Tela.java

Conceitos

Inicialmente, para que o Hibernate soubesse como carregar e armazenar objetos de classes persistentes

eram utilizados apenas arquivos de mapeamento XML. Dessa forma, era possível informar que tabela do

banco de dados se refere uma dada classe persistente e quais colunas na tabela são referentes a quais

atributos da classe. Com o surgimento das anotações no Java 5.0, tornou-se possível substituir os

arquivos XML para o mapeamento objeto relacional. Através do uso de um conjunto de anotações no

código fonte das classes mapeadas.

As anotações podem ser definidas como metadados que aparecem no código fonte e são ignorados pelo

compilador. Qualquer símbolo em um código Java que comece com uma @ (arroba) é uma anotação.

Em outras palavras, as anotações marcam partes de objetos de forma que tenham algum significado

especial.

Definindo a Classe Evento com Anotações Hibernate

A seguir é apresentada a classe Evento realizando o mapeamento com anotações. Dessa forma, é

informado ao Hibernate que tabela no banco de dados deve ser usada e quais atributos correspondem

as quais colunas desta tabela.

package modelo;

import java.io.Serializable;

import java.util.Date;

import javax.persistence.Entity;

import javax.persistence.GeneratedValue;

import javax.persistence.GenerationType;

import javax.persistence.Id;

import javax.persistence.Table;

@Entity

@Table(name="evento")

public class Evento implements Serializable{

@Id

@GeneratedValue(strategy=GenerationType.AUTO)

@Column(name="idEvento")// não é necessário por ser igual ao atributo

private Integer idEvento;

private String nome ;

private Date dataInicio;

private Date dataFim;

public Evento (){}

// métodos gets e sets

}

Definindo uma entidade:

@Entity: Torna a classe uma entidade visível ao EntityManager

@Table: Define a tabela de armazenamento, caso seja necessário.

Anotações que têm escopo de classe, mas não definem a entidade:

Definindo a identidade de uma entidade:

@Id: Identifica a propriedade que representa a chave primária da tabela.

@Column: Configura o nome da coluna em que será armazenada a propriedade.

@GenerationValue: Define a estratégia de geração de chave primária

Definindo a estratégia de geração de chaves: GenerationType

GenerationType.AUTO: Define a estratégia automaticamente de acordo com o banco utilizado.

GenerationType.IDENTITY: Suporta colunas de identidades do tipo long, short ou int para os

bancos DB2, MySQL, MS SQL Server, Sybase e HipersonicSQL.

GenerationType.SEQUENCE: Nos bancos PostgresSQL, DB2, Oracle ou SAP DB, uma

sequência é utilizada.

GenerationType.TABLE: Uma tabela é utilizada para guardar o ultimo valor de chave gerado.

Cada gerador é mapeado para uma linha dessa tabela.

Considerações:

Hibernate requer que toda classe persistente possua um construtor padrão sem argumentos, assim, o

Hibernate pode instanciá-la simplesmente chamando Construtor.newInstance();

Observe que a classe Evento apresenta métodos setters e getters para acessar ou retornar todos os

seus atributos. O Hibernate persiste as propriedades no estilo JavaBeans, utilizando esses métodos;

A classe Evento possui um atributo idEvento que é o seu identificador único. É importante que, ao

utilizar Hibernate, todos os objetos persistentes possuam um identificador e que eles sejam

independentes da lógica de negócio da aplicação.

Há necessidade de se criar um objeto SEQUENCE do banco PostgreSQL chamado

hiberente_sequence. Veja o comando create sequence no item a seguir.

Configurar as propriedades indicando o seu banco, o usuário e por fim a senha para a sua

aplicação.

<property name="hibernate.connection.url">

jdbc:mysql://localhost:3306/??????? </property>

<property name="hibernate.connection.username">?????????</property>

<property name="hibernate.connection.password">?????</property>

Por fim a Execução do Exemplo

Neste ponto temos o Hibernate configurado e no projeto temos os seguintes arquivos:

As classes modelo.Evento e dao.DaoEvento; O banco de dados empresa com a tabela evento; O hibernate.cfg.xml com o tipo, o nome, o usuário e a senha do banco; Os jar´s do Hibernate e do MySql, mais os arquivos log4j.properties e hibernate-

configuration-3.0.dtd.