Tutorial Hibernate

O Hibernate é um framework de persistência “open source” cujo propósito é prover um

mecanismo para persistência de objetos Java em um banco de dados relacional. O site do projeto é
http://www.hibernate.org/, onde pode ser feito o download de qualquer versão do framework.
As principais vantagens de se utilizar o Hibernate são:
1. Ele oferece vários recursos que facilitam o mapeamento do modelo orientado a
objetos para o relacional e vice-versa. Este processo é conhecido como MOR ou mapeamento objeto
relacional;
2. Estes recursos simplificam o trabalho de persistir e recuperar os objetos no modelo
relacional, que é bastante diferente do orientado a objetos – no qual nós desenvolvemos a aplicação;
3. O Hibernate nos dá a impressão de que estamos trabalhando com um SGBDOO
durante o desenvolvimento da aplicação. Apesar de estarmos trabalhando, na verdade, com um SGBD
relacional.

Instalação e configuração do Hibernate

1) Download dos recursos necessários:

Você precisa baixar três recursos para o funcionamento do Hibernate:

• Hibernate Core: Arquivo compactado que contém a implementação do Hibernate, documentação,

fontes, exemplos, etc. Disponível em http://www.hibernate.org/ ou
http://sourceforge.net/projects/hibernate/files/;

• Hibernate Annotetions: Contém as anotações utilizadas pelo Hibernate. Disponível em

http://www.hibernate.org/ ou http://sourceforge.net/projects/hibernate/files/;

• Diver JDBC: É a implementação do JDBC para o SGBD que você utilizará (disponível no site de
cada fabricante de SGBD).

2) Configuração do CLASSPATH:
De posse dos recursos adquiridos no site oficial do Hibernate, você agora precisa acrescentá-los ao seu
projeto no Eclipse. Isto é feito por meio da configuração do CLASSPATH4 do seu projeto Java. Veja em
detalhes como fazer isso no tópico “Como configurar o CLASSPATH do projeto?” mais adiante.
Por ora, vamos conhecer os pacotes (arquivos .jar5) necessários ao seu projeto Java que vai utilizar o
Hibernate. Você precisará incluir no seu projeto os seguintes arquivos:

• O hibernate3.jar, que fica no diretório raiz do Hibernate Core; Exemplo: d:\java-

frameworks\hibernate-3.2\hibernate3.jar

• Todos os pacotes dentro do diretório lib do Hibernate Core, que são as dependências e recursos
utilizados pelo Hibernate; Exemplo: d:\java-frameworks\hibernate-3.2\lib\*

• O hibernate-annotetions.jar, que fica no diretório raiz do Hibernate Annotetions; Exemplo:

d:\java-frameworks\hibernate-annotetions-3.3.0\hibernate-annotetions.jar

• Todos os pacotes dentro do diretório lib do Hibernate Annotetions, que são suas dependências;
Exemplo: d:\java-frameworks\hibernate-annotetions-3.3.0\lib\*

1
Tutorial Hibernate

3. Mapeamento Objeto Relacional:

Também conhecido pela sigla MOR, como citado anteriormente. Consiste em se apontar a
correspondência que existe entre os atributos de uma classe (modelo OO) e os campos de uma tabela no
banco de dados (modelo relacional). Isto torna possível, por exemplo, aconstrução automática de objetos
a partir do retorno de uma consulta SQL.
Podemos realizar o mapeamento por uma das seguintes técnicas:

• Uso de XML: Consiste em se criar um arquivo XML para mapear cada classe de domínio do
projeto cujos objetos serão persistidos. É preciso acrescentar estes arquivos XML de mapeamento
no arquivo hibernate.cfg.xml, para indicar a localização física de cada um deles.

• Uso de Anotações: Também conhecidas como annotetions é uma forma prática e fácil de fazer
“anotações” no código Java, ou seja, de incluir metadados sobre uma classe dentro do próprio
código desta classe.

4. Configuração do arquivo “hibernate.cfg.xml” no seu projeto:

No arquivo de configuração do Hibernate, que deve estar no diretório raiz do da pasta de fontes “src”,
você deve configurar, basicamente, os seguintes dados:

• A URL JDBC – Na propriedade hibernate.connection.url;

• O driver JDBC que será utilizado – Na propriedade hibernate.connection.driver_class;

• O nome do usuário – Na propriedade hibernate.connection.username;

• A senha do usuário – Na propriedade hibernate.connection.password;

• Os arquivos XML que fazem o mapeamento das classes de domínio do seu projeto, caso haja, na
propriedade mapping resource;

• As classes de domínio mapeadas por anotações, caso haja, na propriedade mapping class.
<?xml version='1.0' encoding='utf-8'?>
<!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.connection.driver_class">org.postgresql.Driver</property>
<property name="hibernate.connection.url">jdbc:postgresql://127.0.0.1:5432/book1?
charSet=LATIN1</property>
<property name="hibernate.connection.username">postgres</property>
<property name="hibernate.connection.password">postgres</property>
<property name="hibernate.dialect">org.hibernate.dialect.PostgreSQLDialect</property>
<property name="current_session_context_class">thread</property>
<property name="hibernate.format_sql" >true</property>
<property name="cache.provider_class">org.hibernate.cache.NoCacheProvider</property>
<property name="show_sql">false</property>

<property name="hibernate.c3p0.min_size">5</property>
<property name="hibernate.c3p0.max_size">20</property>
<property name="hibernate.c3p0.timeout">180</property>
<property name="hibernate.c3p0.item_test_period">100</property>

<mapping class="uni.jsf.dominio.Usuario" />

<mapping class="uni.jsf.dominio.Livro" />

</session-factory>
</hibernate-configuration>

2
Tutorial Hibernate

A seguir veremos quais são as interfaces a serem utilizadas na aplicação:

Configuration (org.hibernate.Configuration)
Realiza as configurações para a inicialização do Hibernate, através de definições como:
a URL JDBC de conexão, o usuário e senha do banco, o driver JDBC do banco de dados, o dialeto
Hibernate para este banco, etc, assim como quais são os mapeamentos entre as classes persistentes e as
tabelas do banco de dados.

SessionFactory (org.hibernate.SessionFactory)
É conhecido com “fábrica de sessões” porque ele cria os objetos “Session” a partir de
uma configuração (Configuration). Sua função é manter em memória os mapeamentos entre as classes e
as tabelas, a fim de permitir a criação de objetos Session que serão capazes de fazer a persistência dos
dados a partir destes mapeamentos. Aconselha-se criar apenas uma instância desta classe para criar
quantas sessões forem necessárias, uma vez que é um custo alto cria-lo várias vezes, e ele pode ser
acessado por vários processos simultaneamente.

Session (org.hibernate.Session)
A instância da classe Session é responsável por fazer a persistência dos objetos
mapeados para as tabelas do banco através de uma conexão JDBC, sendo possível criar, remover,
atualizar e recuperar objetos persistentes. A criação de cada instância tem um baixo custo e a mesma
não pode ser acessada por vários processos simultaneamente de forma segura.

Transaction (org.hibernate.Transaction)
É usada para controlar as transações feitas através do Hibernate, sendo criada a partir
de um objeto Session. Permite confirmar as alterações feitas durante a transação (commit) ou desfazer
essas alterações (rollback).

Interfaces Criteria e Query

As interfaces Criteria e Query são utilizadas para realizar consultas ao banco de dados.
Query utiliza a linguagem HQL (Hibernate Query Language) para fazer as consultas que recuperam os
objetos utilizando comandos de texto exatamente como na linguagem SQL, enquanto Criteria utiliza
restrições e critérios para construir as consultas, a partir da criação de instâncias e chamada de métodos
específicos de sua API.

Dialetos do Hibernate:
Um dialeto é uma classe especial que permite ao Hibernate conhecer as
particularidades de cada banco de dados. O Hibernate trabalha com dialetos para um grande número de
bancos de dados, tais como: PostgreSQL, FirebirdSQL, Oracle, DB2, MySQL, Sybase, Progress, Microsoft
SQL Server, Ingres, Informix entre outros.

• · DB2 - org.hibernate.dialect.DB2Dialect

• · FirebirdSql - org.hibernate.dialect. FirebirdDialect

3
Tutorial Hibernate

• · HSQLDB - org.hibernate.dialect.HSQLDialect
• · Informix - org.hibernate.dialect.InformixDialect
• · Ingres - org.hibernate.dialect.IngresDialect
• · Interbase - org.hibernate.dialect.InterbaseDialect
• · Pointbase - org.hibernate.dialect.PointbaseDialect
• · PostgreSQL - org.hibernate.dialect.PostgreSQLDialect
• · Mckoi SQL - org.hibernate.dialect.MckoiDialect
• · Microsoft SQL Server - org.hibernate.dialect.SQLServerDialect
• · MySQL - org.hibernate.dialect.MySQLDialect
• · Oracle (any version) - org.hibernate.dialect.OracleDialect
• · Oracle 9 - org.hibernate.dialect.Oracle9Dialect
• · Progress - org.hibernate.dialect.ProgressDialect
• · FrontBase - org.hibernate.dialect.FrontbaseDialect
• · SAP DB - org.hibernate.dialect.SAPDBDialect
• · Sybase - org.hibernate.dialect.SybaseDialect

• · Sybase Anywhere - org.hibernate.dialect.SybaseAnywhereDialect

Classes Persistentes
As entidades domínio de negócio de uma aplicação são implementadas por classes
persistentes. O Hibernate associa cada uma das tabelas do banco de dados a um POJO (Plain Old Java
Object), também conhecidos como VO (Value Object). POJO´s ou VO’s são objetos Java que seguem o
padrão JavaBeans (possuem um método construtor padrão sem argumentos, seus atributos são privados
e possuem e métodos getters e setters públicos para acessar os seus atributos).

O Hibernate depende das características do padrão JavaBeans para fazer a

persistência, pois ele persiste ,as propriedades do objeto utilizando os métodos get/set para acessar ou
retornar todos os seus atributos na hora de ler ou gravar das tabelas, assim como utiliza o construtor
padrão sem argumentos para instanciá-las simplesmente chamando Classe.newInstance();
Cada classe persistente precisa ter um atributo “id” que represente o “identificador do
objeto”, que deverá ser único a fim de diferenciar um objeto do outro.

4
Tutorial Hibernate

Utilização da classe HibernateUtil.java:

A classe HibernateUtil.Java é disponibilizada com o Hibernate para ajudar o programador a criar os
objetos Session responsáveis por fazer a persistência dos objetos. Ela declara um atributo estático do
tipo SessionFactory para ter uma única instância da fábrica de sessões. Este padrão é conhecido como
Singleton. Todas as classes que precisarem criar uma sessão utilizarão sempre a mesma fábrica de
sessões.

public class HibernateUtil

{

//Objeto que constroi uma fábrica de sessões para

//ser utilizado nas transações sql
private static SessionFactory factory;

//bloco que é inicializado quando a classe é chamada pela

//primeira vez e nunca mais é executado
static
{
//cria um objeto na memória utilizando
//as configurações obtidas no
//hibernate.cfg.xml
AnnotationConfiguration config = new AnnotationConfiguration();
config.configure();
factory = config.buildSessionFactory();
}

//método que retorna uma sessão de uso

//para aplicar o sql
public static Session getSession()
{
return factory.openSession();
}

5
Tutorial Hibernate

Mapeamento Objeto Relacional

Ferramentas para auxiliar nesta tarefa tornaram-se popular entre os desenvolvedores

Java e são conhecidas como ferramentas de mapeamento objeto-relacional (ORM).
O Hibernate abstrai o seu código SQL, que será gerado em tempo de execução. Mais
que isso, ele vai gerar o SQL que serve para um determinado banco de dados, já que cada banco fala um
“dialeto” diferente dessa linguagem. Assim há também a possibilidade de trocar de banco de dados sem
ter de alterar código SQL, já que isso fica de responsabilidade da ferramenta.

Mapeando uma classe:

Para mapear a classe basta adicionar algumas poucas anotações em nosso código.
Anotação é um recurso do Java que permite inserir metadados em relação a nossa classe, atributos e
métodos. Essas anotações depois poderão ser lidas por frameworks e bibliotecas, para que eles tomem
decisões baseadas nessas pequenas configurações.
Para essa nossa classe em particular, precisamos de apenas três anotações:
@Entity
public class Usuario
{
@Id
@GeneratedValue(strategy = GenerationType.SEQUENCE, generator = "gen_usuario")
@SequenceGenerator(name = "gen_usuario", sequenceName = "seq_usuario")
private Long id;

private String login = "";

private String senha = "";
private String nome = "";
private String email = "";
}

Mas em que tabela essa classe será gravada? Em quais colunas? Que tipo de coluna? Na ausência de
configurações mais específicas, o Hibernate vai usar convenções: a classe Usuario será gravada na tabela
de nome também Usuario, e o atributo login em uma coluna de nome login também!
Se quisermos configurações diferentes das convenções, basta usarmos outras anotações, que são
completamente opcionais. Por exemplo, para mapear o atributo 'login' numa coluna chamada
'login_usuario' faríamos:

@Column(name = "login_usuario", nullable = true, length = 50)

private String login = "";

Também podemos especificar o nome da tabela, e até criar índices únicos através de @Table:
@Entity
@Table(name = "usuario", uniqueConstraints = { @UniqueConstraint(columnNames = { "login" }) })
public class Usuario

6
Tutorial Hibernate

Criando um DAO (Data Access Object) que utiliza Hibernate:

1. Criar uma classe com o nome do seu DAO. Exemplo: UsuarioDAO
2. Criar dentro da classe um atributo do tipo Session para controlar a sessão do Hibernate que fará o
trabalho de persistência. O atributo deve ser inicializado com uma instância obtida com a ajuda da classe
HibernateUtil.
3. Criar os métodos que façam a persistência da classe.
public class UsuarioDAO
{
private Session session;

public UsuarioDAO(Session session)

{
this.session = session;
}

public void incluir(Usuario usuario)

{
Transaction transaction = session.beginTransaction();
transaction.begin();
session.save(usuario);
transaction.commit();
}

public Usuario obter(String login)

{
Query query = session.createQuery("from Usuario where login = :login ");
query.setParameter("login", login);
return (Usuario) query.uniqueResult();
}

public void alterar(Usuario user)

{
Transaction transaction = session.beginTransaction();
transaction.begin();
session.saveOrUpdate(user);
transaction.commit();
}

public Usuario obter(Long id)

{
return (Usuario) session.load(Usuario.class, id);
}

public List<Usuario> listarTodos()

{
return session.createQuery("from Usuario").list();
}

public void remover(Usuario user)

{
Transaction transaction = session.beginTransaction();
transaction.begin();
session.delete(user);
transaction.commit();
}