Apostila de Hibernate - 3

Hibernate com
Anotaes
Por: Raphaela Galhardo Fernandes
Gleydson de A. Ferreira Lima
______________________________
raphaela@j2eebrasil.com.br,
gleydson@j2eebrasil.com.br
JavaRN - http://javarn.dev.java.net
J2EEBrasil - http://www.j2eebrasil.com.br
Natal, Maio de 2007
Sumrio
HIBERNATE COM ANOTAES .........................................................................................................1
1.
CONCEITOS GERAIS DE PERSISTNCIA .................................................................................4
2.
MAPEAMENTO OBJETO RELACIONAL ...................................................................................4

2.1 MAPEAMENTO OBJETO RELACIONAL ...........................................................................................5
2.1.1 Mapeamento de um objeto com tipos primitivos...............................................5
2.1.2 Mapeamento de objetos que contm uma coleo de objetos ....................6
3.
INTRODUO AO HIBERNATE ........................................................................................8
4.
ARQUITETURA .........................................................................................................................8
4.1
4.2
4.3
4.4
4.5
5.
SESSION (ORG.HIBERNATE.SESSION) .............................................................................................9

SESSIONFACTORY (ORG.HIBERNATE.SESSIONFACTORY)...............................................................9
CONFIGURATION (ORG..HIBERNATE.CONFIGURATION)................................................................10
TRANSACTION (ORG.HIBERNATE.TRANSACTION) ........................................................................10
INTERFACES CRITERIA E QUERY .................................................................................................10
CLASSES PERSISTENTES............................................................................................................10
5.1
5.2
IDENTIDADE/IGUALDADE ENTRE OBJETOS..............................................................................12

ESCOLHENDO CHAVES PRIMRIAS ..............................................................................................12
6.
OBJETOS PERSISTENTES, TRANSIENTES E DETACHED ..................................................14
7.
COMO UTILIZAR O HIBERNATE ANNOTATION ...................................................................15
8.
INTRODUO A ANOTAES (ANNOTATIONS) ..................................................................16

8.1
TIPOS DE ANOTAES SUPORTADAS PELO JAVA 5.0 ............................................................17
PRIMEIRO EXEMPLO COM HIBERNATE ANNOTATIONS ..................................................19
9.
10.
CONFIGURANDO O HIBERNATE..........................................................................................23
11.
MANIPULANDO OBJETOS PERSISTENTES .......................................................................25
12.
MAPEANDO ATRIBUTOS DA CLASSE .................................................................................29
13.
ASSOCIAES ...........................................................................................................................32
13.1 ASSOCIAES 1-N (ONE-TO-MANY).............................................................................................32

13.2 ASSOCIAES N-1 (MANY-TO-ONE).............................................................................................40
13.3 ASSOCIAES N-N (MANY-TO-MANY) .........................................................................................42
13.4 ASSOCIAES N-N COM ATRIBUTOS ............................................................................................48
13.4.1 Composite-id.......................................................................................................................49
13.5 ASSOCIAES 1-1 (ONE-TO-ONE) ................................................................................................52
14.
DEFINIO DE CHAVE PRIMRIA UTILIZANDO UMA SEQNCIA PRPRIA .....55
15.
COLEES..................................................................................................................................56
15.1
15.2
15.3
15.4
16.
16.1
SET ..............................................................................................................................................57
LIST .............................................................................................................................................59
MAP ............................................................................................................................................61
BAG .............................................................................................................................................62
HERANA....................................................................................................................................64
TABELA POR CLASSE CONCRETA ................................................................................................66
16.2
16.3
17.
17.1
17.2
17.3
17.4
17.5
17.6
17.7
17.8
17.9
18.
18.1
18.2
19.
19.1
19.2
19.3
TABELA POR HIERARQUIA ..........................................................................................................70

TABELA POR SUBCLASSE ............................................................................................................73
TRANSAES.............................................................................................................................76
MODELOS DE TRANSAES .........................................................................................................78
TRANSAES E BANCO DE DADOS ..............................................................................................79
AMBIENTES GERENCIADOS E NO GERENCIADOS .......................................................................79
TRANSAES JDBC ....................................................................................................................80
TRANSAES JTA .......................................................................................................................81
API PARA TRANSAES DO HIBERNATE .....................................................................................81
FLUSHING ....................................................................................................................................82
NVEIS DE ISOLAMENTO DE UMA TRANSAO ............................................................................83
CONFIGURANDO O NVEL DE ISOLAMENTO ..................................................................................85
CONCORRNCIA.......................................................................................................................85
LOCK OTIMISTA ..........................................................................................................................86
LOCK PESSIMISTA .......................................................................................................................93
CACHING.....................................................................................................................................95
ARQUITETURA DE CACHE COM HIBERNATE ................................................................................96
MAPEANDO CACHE .....................................................................................................................98
UTILIZANDO O CACHE .................................................................................................................99
1. Conceitos Gerais de Persistncia

Imagine um usurio fazendo uso de uma aplicao, por exemplo, um
sistema para controlar suas finanas. Ele passa a fornecer como dados de entrada
todos os seus gastos mensais para que a aplicao lhe gere, por exemplo, grficos
nos quais ele possa avaliar seus gastos. Finalizada, a sua anlise financeira, o
usurio resolve desligar o computador em que a aplicao se encontra. Imagine
agora que o usurio teve novos gastos, voltou a ligar o computador, acessou
novamente o sistema de finanas e que gostaria de realizar novas anlises com
todos os seus gastos acumulados. Se a aplicao no armazenar, de alguma
forma, os primeiros gastos fornecidos, o usurio teria que inform-los novamente
e em seguida, acrescentar os novos gastos para fazer a nova anlise, causando
grande trabalho e o sistema no sendo eficiente. Para resolver esse tipo de
problema, uma soluo seria armazenar (persistir) os dados lanados a cada vez
pelo usurio em um banco de dados relacional, utilizando SQL (Structured Query
Language).
2. Mapeamento Objeto Relacional

Seo Escrita Por: Juliano Rafael Sena de Arajo
Por vrios anos os projetos de aplicaes corporativas tiveram uma forte

necessidade de se otimizar a comunicao da lgica de negcio com a base de
dados. Essa necessidade ganhou mais intensidade com o crescimento dessas
aplicaes, crescimento esse, tanto em requisitos (funcionalidade) quanto em
volume de dados armazenados em seu banco de dados.
Na dcada de 80, foram criados os bancos de dados relacionais (BDR) que
substituram as bases de dados de arquivos. Para esse tipo de base de dados foi
criada uma linguagem, a SQL. Essa linguagem foi toda baseada na lgica relacional
e por isso contava com diversas otimizaes em suas tarefas se comparadas com
as outras tecnologias existentes. A partir de ento foi diminudo o tempo gasto para
as operaes de persistncia, mesmo com um grande volume de dados. Entretanto,
essa linguagem no propiciava aos desenvolvedores uma facilidade para que a
produtividade fosse aumentada.
Uma soluo que surgiu no incio da dcada de 90 foi criao de um
modelo de banco de dados baseado no conceito de orientao a objetos. Este
modelo visava facilitar, para os desenvolvedores, a implementao da camada de
persistncia da aplicao, pois eles j estavam familiarizados com o paradigma de
orientao a objetos, consequentemente, a produtividade certamente aumentaria.
Na prtica, esse modelo de dados no foi utilizado em grandes aplicaes, visto que
elas tinham um volume de dados muito grande e esse modelo era ineficiente em
termos de tempo de resposta, pois ao contrrio dos bancos de dados relacionais,
eles no tinham um modelo matemtico que facilitasse as suas operaes de
persistncias.
Ento a soluo foi usar os BDR e desenvolver ferramentas para que o seu
uso seja facilitado. Uma dessas ferramentas o framework Hibernate que usa o
conceito de mapeamento objeto relacional (MOR).
As
subsees
seguintes
apresentam
os
conceitos
relacionados
ao
mapeamento objeto relacional.

2.1
Mapeamento objeto relacional

Como foi descrito anteriormente, mapeamento objeto relacional funciona
com a transformao dos dados de um objeto em uma linha de uma tabela de um

banco de dados, ou de forma inversa, com a transformao de uma linha da tabela
em um objeto da aplicao. Abordando essa idia, alguns problemas podero
existir, como, se um objeto tiver uma coleo de outros objetos. Nas prximas
subsees sero abordados os alguns tipos de mapeamentos bsicos.
2.1.1 Mapeamento de um objeto com tipos primitivos
Esse o mapeamento mais simples, onde um objeto tem apenas tipos de
dados bsicos. Vale salientar que entendesse por tipos bsicos aqueles que
possuem um correspondente em SQL, ou seja, o tipo String da linguagem Java
considerado um tipo bsico, pois ele possui um correspondente em SQL.
Na Figura 1, observa-se o mapeamento de trs objetos do tipo Veiculo na
tabela de um banco de dados. Caso a aplicao deseje saber o veculo da cor
vermelha, por exemplo, ento o objeto que tem o Plio como modelo retornado.
Figura 1 - Exemplo de mapeamento de tipos bsicos
2.1.2 Mapeamento de objetos que contm uma coleo de objetos

Esse tipo de mapeamento quando um objeto possui um conjunto de outros
objetos. Para obter esse conceito necessrio adicionar, ao exemplo da Figura 1,
uma nova classe chamada de Fabricante que conter as informaes: nome, que
armazenar o nome desse fabricante e o veiculos, que conter o conjunto de
veculos do fabricante (telefone e endereco no so informaes relevantes no
exemplo). Faz-se necessrio a adio de uma informao na classe Veiculo
chamada de fabricante, como mostrado na Figura 2.
Figura 2 - Relacionamento entre as classes Fabricante e Veiculo

O atributo fabricante adicionado em Veiculo simplesmente para
relacionar um veculo ao seu fabricante, enquanto o veiculos de Fabricante
referencia a classe Veiculo.
Como foram realizadas mudanas no domnio do exemplo orientado a
objetos, faz-se necessria uma alterao no modelo do banco de dados.
Primeiramente, o vnculo que foi realizado entre um fabricante e um veculo dever
ser implementado atravs de uma chave estrangeira (referncia a uma outra

tabela, pois em BDR no existe o conceito de colees) que se localizar na tabela
VEICULO, caracterizando o mapeamento 1 para N, ou seja, um veculo possui
apenas um fabricante e um fabricante possui vrios (N) veculos. Essa chave
estrangeira ser realizada entre a informao nome da classe Fabricante e o
atributo fabricante da classe Veiculo.
Figura 3 Exemplo de mapeamento 1 para N

Para um melhor entendimento, a Figura 3 mostra o mapeamento dos
objetos para as tabelas no BDR. Nele observa-se que cada veculo est associado
com um fabricante, isso implica dizer que na tabela de VEICULO existe uma
referncia para a tabela FABRICANTE. Essa associao feita atravs da coluna
fabricante da tabela VEICULO. Pensando em termos prticos, quando um veculo
for inserido no banco de dados, ele ser ligado ao seu respectivo fabricante, no
momento da insero.
Para recuperar os veculos inseridos o desenvolvedor ter que implementar
uma busca que retorne alm das informaes do veculo as informaes do seu
fabricante, isso poder ser realizado fazendo a seguinte consulta SQL: SELECT *
FROM fabricante WHERE nome = <fabricante>, onde <fabricante> o nome
do fabricante que est na tabela VEICULO, por exemplo, caso a aplicao deseje
as informaes do veculo do modelo Plio, ento para se buscar o fabricante a
seguinte consulta ser realizada: SELECT * FROM fabricante WHERE nome =
'Fiat'.
Utilizando a mesma idia, os fabricantes so buscados; a nica diferena
que agora a consulta que buscar os veculos associados com o fabricante retornar
uma coleo de veculos (SELECT * FROM veiculo WHERE fabricante =
<nomeFabricante>).
Esse tipo de mapeamento muito utilizado em aplicaes em que os objetos
fazem muita referncia a outros objetos.
Com a idia do MOR vrios projetos de ferramenta comearam a ser

desenvolvidas, visando facilitar a implementao da camada de persistncia, dentre
elas o framework Hibernate, que um software livre de cdigo aberto e que est
tendo uma forte adeso de novos projetos corporativos. Essa ferramenta ser
descrita nas prximas sees.
3. Introduo ao Hibernate
O Hibernate um framework de mapeamento objeto relacional para
aplicaes Java, ou seja, uma ferramenta para mapear classes Java em tabelas
do banco de dados e vice-versa. bastante poderoso e d suporte ao
mapeamento de associaes entre objetos, herana, polimorfismo, composio e
colees.
O Hibernate no apresenta apenas a funo de realizar o mapeamento
objeto relacional. Tambm disponibiliza um poderoso mecanismo de consulta de
dados, permitindo uma reduo considervel no tempo de desenvolvimento da
aplicao.
4. Arquitetura
A arquitetura do Hibernate formada basicamente por um conjunto de
interfaces. A Figura 4 apresenta as interfaces mais importantes nas camadas de
negcio e persistncia. A camada de negcio aparece acima da camada de
persistncia por atuar como uma cliente da camada de persistncia. Vale salientar
que algumas aplicaes podem no ter a separao clara entre as camadas de
negcio e de persistncia.
De acordo com a Figura 4, as interfaces so classificadas como:
Interfaces responsveis por executar operaes de criao, deleo,

consulta e atualizao no banco de dados: Session, Transaction e
Query;
Interface utilizada pela aplicao para configurar o Hibernate:

Configuration;
Interfaces responsveis por realizar a interao entre os eventos do

Hibernate e a aplicao: Interceptor, Lifecycle e Validatable.
Interfaces
que
mapeamento
permitem
do
Hibernate:
extenso
das
UserType,
funcionalidades
de
CompositeUserType,
IdentifierGenerator.
O Hibernate tambm interage com APIs j existentes do Java: JTA, JNDI e
JDBC.
Figura 4 - Arquitetura do Hibernate
De todas as interfaces apresentadas na Figura 4, as principais so: Session,

SessionFactory, Transaction, Query, Configuration. Os sub-tpicos seguintes
apresentam uma descrio mais detalhada sobre elas.
4.1 Session (org.hibernate.Session)

O objeto Session aquele que possibilita a comunicao entre a aplicao e
a persistncia, atravs de uma conexo JDBC. um objeto leve de ser criado, no
deve ter tempo de vida por toda a aplicao e no threadsafe. Um objeto Session
possui um cache local de objetos recuperados na sesso. Com ele possvel criar,
remover, atualizar e recuperar objetos persistentes.
4.2 SessionFactory (org.hibernate.SessionFactory)
O objeto SessionFactory aquele que mantm o mapeamento objeto

relacional em memria. Permite a criao de objetos Session, a partir dos quais
os dados so acessados, tambm denominado como fbrica de objetos Sessions.
Um objeto SessionFactory threadsafe, porm deve existir apenas uma
instncia dele na aplicao, pois um objeto muito pesado para ser criado vrias
vezes.
4.3 Configuration (org..hibernate.Configuration)

Um objeto Configuration utilizado para realizar as configuraes de
inicializao
do
Hibernate.
Com
ele,
define-se
diversas
configuraes
do
Hibernate, como por exemplo: o driver do banco de dados a ser utilizado, o

dialeto, o usurio e senha do banco, entre outras. a partir de uma instncia
desse objeto que se indica como os mapeamentos entre classes e tabelas de
banco de dados devem ser feitos.
4.4 Transaction (org.hibernate.Transaction)
A interface Transaction utilizada para representar uma unidade indivisvel

de uma operao de manipulao de dados. O uso dessa interface em aplicaes
que usam Hibernate opcional. Essa interface abstrai a aplicao dos detalhes das
transaes JDBC, JTA ou CORBA.
4.5 Interfaces Criteria e Query

As interfaces Criteria e Query so utilizadas para realizar consultas ao
banco de dados.
5. Classes Persistentes
As classes persistentes de uma aplicao so aquelas que implementam as
entidades de domnio de negcio. O Hibernate trabalha associando cada tabela do
banco de dados a um POJO (Plain Old Java Object). POJOs so objetos Java que
seguem a estrutura de JavaBeans (construtor padro sem argumentos, e mtodos
getters e setters para seus atributos). A Listagem 1 apresenta a classe Pessoa
representando uma classe POJO.
10
package br.com.jeebrasil.dominio.Pessoa;
public class Pessoa {
private int id;

private long cpf;
private String nome;
private int idade;
private Date dataNascimento;
public Pessoa(){}
public int getId() { return id; }

private void setId(int Long id) {
this.id = id;
}
public long getCpf(){ return cpf; }

public void setCpf(long cpf){
this.cpf = cpf;
}
public Date getDataNascimento() { return dataNascimento; }

public void setDataNascimento (Date dataNascimento) {
this.dataNascimento = dataNascimento;
}
public String getNome () { return nome; }

public void setNome (Stringnome) {
this.nome = nome;
}
public int getIdade(){ return idade;

public void setIdade(int idade){
this.idade = idade;
}
}
Listagem 1 Exemplo de Classe POJO
11
Consideraes:
O Hibernate requer que toda classe persistente possua um construtor

padro sem argumentos, assim, o Hibernate pode instanci-las
simplesmente chamando Construtor.newInstance();
Observe que a classe Pessoa apresenta mtodos setters e getters

para acessar ou retornar todos os seus atributos. O Hibernate
persiste as propriedades no estilo JavaBeans, utilizando esses
mtodos;
A classe Pessoa possui um atributo id que o seu identificador

nico. importante que, ao utilizar Hibernate, todos os objetos
persistentes
possuam
um
identificador
que
eles
sejam
independentes da lgica de negcio da aplicao.
5.1 Identidade/Igualdade entre Objetos
Em aplicaes Java, a identidade entre objetos pode ser obtida a partir do

operador ==. Por exemplo, para verificar se dois objetos obj1 e obj2 possuem a
mesma identidade Java, basta verificar se obj1 == obj2. Dessa forma, dois
objetos possuiro a mesma identidade Java se ocuparem a mesma posio de
memria.
O conceito de igualdade entre objetos diferente. Dois objetos, por
exemplo, duas Strings, podem ter o mesmo contedo, mas verificar se as duas so
iguais utilizando o operador ==, pode retornar um resultado errado, pois como j
citado, o operado == implicar em uma verificao da posio de memria e no
do contedo. Assim, para verificar se dois objetos so iguais em Java, deve-se
utilizar o mtodo equals, ou seja, verificar se obj1.equals(obj2).
Incluindo o conceito de persistncia, passa a existir um novo conceito de
identidade, a identidade de banco de dados. Dois objetos armazenados em um
banco de dados so idnticos se forem mapeados em uma mesma linha da tabela.
5.2 Escolhendo Chaves Primrias
Um passo importante ao utilizar o Hibernate inform-lo sobre a estratgia

utilizada para a gerao de chaves primrias.
Uma chave candidata uma coluna ou um conjunto de colunas que
identifica unicamente uma linha de uma tabela do banco de dados. Ela deve
12
satisfazer as seguintes propriedades:
nica;
Nunca ser nula;
Constante.
Uma nica tabela pode ter vrias colunas ou combinaes de colunas que
satisfazem essas propriedades. Se a tabela possui um nico atributo que a
identifique, ele por definio a sua chave primria. Se possuir vrias chaves
candidatas, uma deve ser escolhida para representar a chave primria e as demais
serem definidas como chaves nicas.
Muitas aplicaes utilizam como chaves primrias chaves naturais, ou seja,
que tm significados de negcio. Por exemplo, o atributo cpf da tabela Pessoa
(associada classe Pessoa). Essa estratgia pode no ser muito boa em longo
prazo, j que uma chave primria adequada deve ser constante, nica e no nula.
Dessa forma, se for desejado que a chave primria da tabela Pessoa seja uma
outra ao invs do cpf, podem surgir problemas j que provavelmente o cpf deve
ser referenciado em outras tabelas. Um problema que poderia acontecer seria a
remoo do cpf da tabela.
O Hibernate apresenta vrios mecanismos internos para a gerao de
chaves primrias. Veja a Tabela 1.
Tabela 1 - Mecanismo de Gerao de Chaves Primrias

Mecanismo
Descrio
Identity
Mapeado para colunas identity no DB2, MySQL, MSSQL, Sybase,

HSQLDM, Infomix.
Sequence
Mapeado em seqncias no DB2, PostgreSQL, Oracle, SAP DB,

Firebird (ou generator no Interbase).
Increment
L o valor mximo da chave primria e incrementa um. Deve ser

usado quando a aplicao a nica a acessar o banco e de
forma no concorrente.
Hilo
Usa algoritmo high/low para gerao de chaves nicas.
uudi.hex
Usa uma combinao do IP com um timestamp para gerar um

identificador nico na rede.
13
6. Objetos Persistentes, Transientes e Detached

Nas diversas aplicaes existentes, sempre que for necessrio propagar o
estado de um objeto que est em memria para o banco de dados ou vice-versa,
h a necessidade de que a aplicao interaja com uma camada de persistncia. Isto
feito, invocando o gerenciador de persistncia e as interfaces de consultas do
Hibernate. Quando interagindo com o mecanismo de persistncia, necessrio para
a aplicao ter conhecimento sobre os estados do ciclo de vida da persistncia.
Em aplicaes orientadas a objetos, a persistncia permite que um objeto
continue a existir mesmo aps a destruio do processo que o criou. Na verdade,
o que continua a existir seu estado, j que pode ser armazenado em disco e
ento, no futuro, ser recriado em um novo objeto.
Em uma aplicao no h somente objetos persistentes, pode haver
tambm objetos transientes. Objetos transientes so aqueles que possuem um
ciclo de vida limitado ao tempo de vida do processo que o instanciou. Em relao
s classes persistentes, nem todas as suas instncias possuem necessariamente
um estado persistente. Elas tambm podem ter um estado transiente ou
detached.
O Hibernate define estes trs tipos de estados: persistentes, transientes e
detached. Objetos com esses estados so definidos como a seguir:
Objetos Transientes: so objetos que suas instncias no esto nem

estiveram associados a algum contexto persistente. Eles so
instanciados, utilizados e aps a sua destruio no podem ser
reconstrudos automaticamente;
Objetos
Persistentes:
so objetos
que suas
instncias
esto
associadas a um contexto persistente, ou seja, tem uma identidade

de banco de dados.
Objetos
detached:
so
objetos
que
tiveram
suas
instncias
associadas a um contexto persistente, mas que por algum motivo

deixaram de ser associadas, por exemplo, por fechamento de
sesso,
finalizao
de
sesso.
So
objetos
em
um
estado
intermedirio, nem so transientes nem persistentes.
O ciclo de vida de um objeto persistente pode ser resumido a partir da

Figura 5.
14
Figura 5: Ciclo de Vida - Persistncia
De acordo com a figura acima, inicialmente, o objeto pode ser criado e ter o
estado transiente ou persistente. Um objeto em estado transiente se torna
persistente se for criado ou atualizado no banco de dados. J um objeto em estado
persistente, pode retornar ao estado transiente se for apagado do banco de dados.
Tambm pode passar ao estado detached, se, por exemplo, a sesso com o banco
de dados por fechada. Um objeto no estado detached pode voltar ao estado
persistente se, por exemplo, for atualizado no banco de dados. Tanto do estado
detached quanto do estado transiente o objeto pode ser coletado para destruio.
7. Como Utilizar o Hibernate Annotation

Para utilizar o Hibernate Annotation, primeiramente, preciso copiar sua
verso atual do site http://hibernate.org, disponvel em um arquivo compactado.
Ento, este arquivo deve ser descompactado e seu contedo consiste em um
conjunto de arquivos JARs. Esses arquivos devem ser copiados para o diretrio das
libs
de
sua
aplicao.
persistence.jar
tambm
Os
arquivos
devem
hibernate-annotations.jar
referenciados
no
classpath
juntamente com a classe do driver do banco de dados utilizado.
15
e lib/ejb3da
aplicao,
8. Introduo a Anotaes (Annotations)

Como j citado, o mapeamento objeto relacional utilizando Hibernate pode
ser feito a partir de anotaes. As anotaes podem ser definidas como metadados
que aparecem no cdigo fonte e so ignorados pelo compilador. Qualquer smbolo
em um cdigo Java que comece com uma @ (arroba) uma anotao. Este recurso
foi introduzido na linguagem Java a partir da verso Java SE 5.0. Em outras
palavras, as anotaes marcam partes de objetos de forma que tenham algum
significado especial.
A Listagem 2 e a Listagem 3 apresentam exemplo de um tipo de anotao
denominado de TesteAnotacao
e do seu uso em um mtodo qualquer
(metodoTeste), respectivamente. O exemplo meramente ilustrativo, de forma

que o tipo de anotao definido no agrega nenhum significado especial ao cdigo
fonte.
public @interface TesteAnotacao{

...
}
Listagem 2 Exemplo ilustrativo para a criao de um tipo de anotao
@TesteAnotacao
public void metodoTeste{
...
}
Listagem 3 Exemplo ilustrativo para o uso de um tipo de anotao
As anotaes podem possuir nenhum, um ou mais de um elementos em sua

definio. Um exemplo de tipo de anotao sem nenhum atributo j foi visto nas
Listagem 2 e na Listagem 3. Se um tipo de anotao possui um nico elemento,
como definido e ilustrado na Listagem 4, no momento de se utilizar a anotao, um
valor para este atributo deve ser passo entre parnteses, como mostrado na
Listagem 5

String elemento1();
}
16
@TesteAnotacao(Definindo valor)
...
}
Listagem 5 Exemplo ilustrativo para o uso de um tipo de. Anotao
No caso caso em que o tipo da anotao ser definido com mais de um
elemento, como mostrado na Listagem 6, na hora em que a anotao for usada,
para atribuir valores para seus elementos preciso pass-los tambm entre
parnteses, porm definindo o nome do elemento e o seu valor, como exemplo
ilustrado na Listagem 7.

String elemento1();
int elemento2();
}
@TesteAnotacao(elemento1 = Definindo valor 1, elemento2 = 25)

...
}
Listagem 7 Exemplo ilustrativo para o uso de um tipo de anotao
8.1 Tipos de Anotaes Suportadas pelo Java 5.0
Dois tipos de anotaes so suportadas pelo Java 5.0: anotaes simples e

meta anotaes. As anotaes simples so usadas apenas para agregar significado
especial ao cdigo fonte, mas no para criar algum tipo de anotao. J as meta
anotaes so aquelas utilizadas para definir tipos de anotaes.
No o intuito desta seo detalhar cada um dos tipos de anotaes
existentes no Java 5.0, mas apenas cit-las e apresentar os seus significados.
As anotaes simples do Java 5.0 so trs:
@Override: indica que o mtodo que possui esta anotao deve ter a sua
implementao sobrescrevendo a de sua superclasse. Se o mtodo anotado
no tiver implementao, o compilador gerar um erro;
17
@Deprecated: permite indicar que algum elemento do cdigo fonte est

em desuso, ou com uso depreciado. A anotao servir para que o
compilador alerte o programador quanto a utilizao de um elemento em
desuso;
@Suppresswarnings: esta anotao indica ao compilador que os alertas

(warnings) no elemento anotado no sejam informados ao programador.
J as meta anotaes so:
@Target: indica em que nvel dos elementos da classe a anotao ser

aplicada, por exemplo: a qualquer tipo; a um atributo, a um mtodo, a um
construtor, etc;
@Retention: indica onde e quanto tempo a anotao ser considerada. Por

exemplo: se apenas a nvel de cdigo fonte e ignoradas pelo compilador; se
apenas pelo compilador em tempo de compilao e no pela JVM; ou
consideradas pela JVM apenas em tempo de execuo;
@Documented: indica que o elemento anotado deve ser documentado

atravs de alguma ferramenta javadoc;
@Inherited: indica que a classe anotada com este tipo automaticamente

herdada. Por exemplo, se uma anotao definida a partir de @Inherited,
uma classe anotada por esta nova anotao ir herdar automaticamente
todos os seus elementos.
Mais informaes sobre estes tipos de anotaes a partir do artigo An

Introduction to Java Annotation por M. M. Islam Chisty (Outrubro, 2005).
Inicialmente, o mapeamento objeto relacional com Hibernate era feito a

partir de um conjunto de configuraes em arquivos XMLs. Com o surgimento das
anotaes no Java SE 5.0, o framework Hibernate anexou este recurso, permitindo
que as classes Java fossem mapeadas a partir de anotaes, simplificando o seu
uso. A prxima seo apresentar um exemplo simples do uso da persistncia de
uma classe com Hibernate Annotations.
18
9. Primeiro Exemplo com Hibernate Annotations

Inicialmente, para que o Hibernate soubesse como carregar e armazenar
objetos de classes persistentes, eram utilizados apenas arquivos de mapeamentos
XML. Dessa forma, era possvel informar que tabela do banco de dados se refere
uma dada classe persistente e quais colunas na tabela so referentes a quais
atributos da classe. Com o surgimento das anotaes no Java 5.0, tornou-se
possvel substituir os arquivos XML para o mapeamento objeto relacional. Atravs
do uso de um conjunto de anotaes no cdigo fonte das classes mapeadas.
Neste primeiro exemplo, ser apresentado como realizar o mapeamento
objeto relacional da classe Aluno (Classe ilustrada na Figura 6) utilizando
anotaes. Dessa forma, informando ao Hibernate que tabela no banco de dados a
representa e quais atributos correspondem as quais colunas desta tabela.
Figura 6 - Classe Aluno

A classe Java que representa a entidade Aluno est ilustrada na Listagem 8.
package br.com.jeebrasil.dominio;
public class Aluno {
//Atributos da classe
private int id;
private int matricula;
private long cpf;
//Construtor padro
public Aluno(){}
//Mtodos getters e setters

public long getCpf() { return cpf; }
public void setCpf(long cpf) { this.cpf = cpf; }
19
public int getId() { return id; }

public void setId(int id) { this.id = id; }
public int getMatricula() { return matricula; }

public void setMatricula(int matricula) {
this.matricula = matricula;
}
public String getNome() { return nome; }

public void setNome(String nome) { this.nome = nome; }
}
Listagem 8 - Classe de Domnio: Aluno
Para os exemplos ilustrados neste material, a base de dados foi feita

utilizando o PostgreSQL 8.2, que pode ser baixado no site www.posgresql.org. A
classe Aluno foi mapeada para a tabela aluno presente no esquema anotaes do
banco criado denominado jeebrasil. O script para a criao da tabela aluno pode
ser visto na Listagem 9.
CREATE TABLE anotacoes.aluno

(
id_aluno integer NOT NULL, -- Identificador da tabela
matricula integer NOT NULL, -- Matrcula do aluno
nome character(40) NOT NULL, -- Nome do aluno
cpf bigint NOT NULL, -- CPF do aluno
CONSTRAINT pk_aluno PRIMARY KEY (id_aluno),
CONSTRAINT un_cpf_aluno UNIQUE (cpf),
CONSTRAINT un_matricula_aluno UNIQUE (matricula)
)
WITHOUT OIDS;
ALTER TABLE anotacoes.aluno OWNER TO postgres;
COMMENT ON COLUMN anotacoes.aluno.id IS 'Identificador da tabela';
COMMENT ON COLUMN anotacoes.aluno.matricula IS 'Matrcula do aluno';
COMMENT ON COLUMN anotacoes.aluno.nome IS 'Nome do aluno';
COMMENT ON COLUMN anotacoes.aluno.cpf IS 'CPF do aluno';
Listagem 9 Script para a Criao da Tabela aluno
20
Para o mapeamento com anotaes das entidades, sero utilizadas tanto

anotaes
do
pacote
javax.persistence.*,
como
do
pacote
org.hibernate.annotations.*.
Todas as classes persistentes mapeadas com anotaes so declaradas
usando a anotao @Entity, aplicada em nvel de classes, como mostrado na
Listagem 10. Observa-se que com o uso de anotaes, no h mais a necessidade
de se utilizar arquivos de mapeamento XML adicionais.
Quando o nome da classe diferente do nome da tabela para a qual
mapeada necessrio informar na anotao @Table qual o nome da tabela,
usando o atributo name. No caso do mapeamento da classe Aluno, no havia a
necessidade de se informar o nome da tabela, pois ela e a classe possuem o
mesmo nome. Como a tabela pertence a um esquema do banco de dados
(anotaes), no mapeamento da classe, tambm necessrio informar em que
esquema a tabela mapeada se encontra, utilizando o atributo schema da anotao
@Table.
No
caso,
linha
do
cdigo
fonte
@Table(name="aluno",
schema="anotacoes") est informando o nome e o esquema da tabela para a qual

est mapeada a classe aluno.
A chave primria da tabela mapeada na classe atravs da anotao @Id.
O valor atribudo chave primria pode ser dado tanto pela aplicao quanto por
um
mecanismo
do
Hibernate
que
gere
automaticamente.
anotao
@GeneratedValue permite a definio automtica para o valor do identificador,

utilizando um dos mecanismos de gerao apresentados anteriormente. Neste caso,
utilizou-se a estratgia a partir de uma seqncia, como feito na linha de cdigo
@GeneratedValue(strategy
GenerationType.SEQUENCE). Dessa forma, na
hora de persistir uma linha na tabela aluno, o Hibernate vai pegar como valor para
a chave primria o prximo valor disponvel por uma seqncia padro chamada
hibernate_sequence. Deve-se salientar que o programador dever criar uma
seqncia com este nome na base de dados. Ainda em relao ao identificador,
como o nome da coluna mapeada diferente do nome do atributo, necessrio
utilizar a anotao @Column informando o nome da coluna, atravs do atributo
name. Neste exemplo, o nome da coluna mapeada para o identificador
id_aluno, mapeada da seguinte forma: @Column(name="id_aluno").
Observa-se que nos demais atributos da classe no h nenhuma anotao
de mapeamento. Isso pode ser feito quando o nome do atributo igual ao nome da
coluna da tabela mapeada, de forma que no h a necessidade de mapeamento
explcito.
21
Por fim, para se utilizar as anotaes para mapeamento das classes,

preciso import-las de algum lugar, neste caso do pacote javax.persistence,
como mostrado no incio do cdigo fonte da Listagem 10.
package br.com.jeebrasil.hibernate.anotacoes.dominio;
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
import javax.persistence.Table;
//Anotao que informa que a classe mapeada persistente

@Entity
//Informando nome e esquema da tabela mapeada
@Table(name="aluno", schema="anotacoes")
public class Aluno {
//Definio da chave primria

@Id
//Definio do mecanismo de definio da chave primria
@GeneratedValue(strategy = GenerationType.SEQUENCE)
//Informa o nome da coluna mapeada para o atributo
@Column(name="id_aluno")
private int id;
private long cpf;
public void Aluno(){}

//...
}
Listagem 10 Mapeamento da classe Aluno com anotaes
Depois de criar todas as classes persistentes com seus respectivos

mapeamentos
com
anotacoes,
deve-se
Hibernate, mostradas na seo seguinte.
22
realizar
algumas
configuraes
do
10. Configurando o Hibernate

Pode-se configurar o Hibernate de trs maneiras distintas:
Instanciar
um
objeto
de
configurao
(org.hibernate.cfg.Configuration) e inserir suas propriedades

programaticamente;
Usar um arquivo .properties com as suas configuraes e indicar as

classes mapeadas programaticamente;
Usar um arquivo XML (hibernate.cfg.xml) com as propriedades de

inicializao e os caminhos das classes mapeadas.
Ser apresentada a configurao a partir do arquivo hibernate.cfg.xml.

Um exemplo deste arquivo de configurao pode ser visto na Listagem 11. Vrios
parmetros podem ser configurados. Basicamente, deve-se configurar:
A URL de conexo com o banco de dados;
Usurio e senha do banco de dados;
Nmeros mximo e mnimo de conexes no pool;
Dialeto.
<?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="connection.driver_class">
org.postgresql.Driver
</property>
<property name="connection.url">
jdbc:postgresql://localhost:5432/jeebrasil
</property>
<property name="dialect">
org.hibernate.dialect.PostgreSQLDialect
</property>
<property name="show_sql">true</property>
23
<property name="connection.username">postgres</property>
<property name="connection.password">postgres</property>
<property name="connection.pool_size">10</property>


<mapping class="br.com.jeebrasil.hibernate.anotacoes.dominio.Aluno"/>
</session-factory>
</hibernate-configuration>
Listagem 11 - Arquivo de Configurao hibernate.cfg.xml
Resumindo as descries das propriedades a serem configuradas:
hibernate.dialect: implementao do dialeto SQL especfico do banco

de dados a ser utilizado. Usado para identificar as particularidades do
banco de dados;
hibernate.connection.driver_class: nome da classe do driver JDBC

do banco de dados que est sendo utilizado;
hibernate.connection.url: a URL de conexo especfica do banco

que est sendo utilizado;
hibernate.connection.username: o nome de usurio com o qual o

Hibernate deve se conectar ao banco;
hibernate.connection.password: a senha do usurio com o qual o

Hibernate deve se conectar ao banco;
hibernate.connection.pool_size: tamanho do pool de conexes;
hibernate.connection.isolation:
define
nvel
de
isolamento.
Parmetro opcional;
hibernate.show_sql: utilizado para definir se os SQLs gerados pelo

Hibernate devem ou no ser exibidos (true | false).
O Hibernate trabalha com dialetos para um grande nmero de bancos de

dados, tais como: DB2, MySQL, Oracle, Sybase, Progress, PostgreSQL, Microsoft
SQL Server, Ingres, Informix entre outros. Possveis valores para os dilates esto
presentes na Tabela 2.
24
Tabela 2 - Possveis valores de dialetos

DB2 - org.hibernate.dialect.DB2Dialect
HypersonicSQL - 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
J no final do arquivo hibernate.cfg.xml onde devem ser informados os

arquivos das classes mapeadas que o Hibernate deve processar. Se alguma classe
no for definida neste local, a mesma no poder ser persistida utilizando os
mecanismos do Hibernate.
Para este exemplo, apenas uma classe foi mapeada. Se existissem outras
classes persistentes, as mesmas deveriam ter linhas semelhantes a <mapping
class="br.com.jeebrasil.hibernate.anotacoes.dominio.Aluno"/>,
informando o seu nome para que possam ser persistidas atravs do Hibernate.
11.
Manipulando Objetos Persistentes

O Hibernate utiliza objetos Session para persistir e recuperar objetos. Um
objeto Session pode ser considerado como uma sesso de comunicao com o
banco de dados atravs de uma conexo JDBC.
O cdigo fonte exibido na Listagem 12 mostra a criao e persistncia de um
objeto do tipo Aluno. Inicialmente alguns imports de objetos so feitos para se
utilizar a persistncia com o Hibernate. Em seguida, dentro do mtodo main, criase
um
objeto
que
conter
as
configuraes
definidas
do
arquivo
hibernate.cfg.xml. A partir deste arquivo, uma sesso para a persistncia de

objetos aberta, juntamente com uma transao. Ento, criou-se um objeto do
tipo Aluno, atribuiu-se valores para seus atributos e, por fim, invocou-se o mtodo
25
save do objeto Session. Com isso, uma linha na tabela aluno adicionada de
acordo com os valores definidos no objeto. Assim, a persistncia desejada
realizada e deve-se liberar tanto a transao quanto a sesso com o Hibernate.
package br.com.jeebrasil.hibernate.anotacoes.testes;
//Imports de elementos para o uso do Hibernate funcionar
import org.hibernate.Session;
import org.hibernate.SessionFactory;
import org.hibernate.Transaction;
import org.hibernate.cfg.AnnotationConfiguration;
import org.hibernate.cfg.Configuration;
//Import da classe de domnio persistida
import br.com.jeebrasil.hibernate.anotacoes.dominio.Aluno;
public class Listagem12 {

public static void main(String[] args) {
//Cria objeto que receber as configuraes

Configuration cfg = new AnnotationConfiguration();
//Informe o arquivo XML que contm a configuraes
cfg.configure(
"/br/com/jeebrasil/hibernate/anotacoes/conf/hibernate.cfg.xml");
//Cria uma fbrica de sesses.
//Deve existir apenas uma instncia na aplicao
SessionFactory sf = cfg.buildSessionFactory();
// Abre sesso com o Hibernate

Session session = sf.openSession();
//Cria uma transao
Transaction tx = session.beginTransaction();
// Cria objeto Aluno

Aluno aluno = new Aluno();
aluno.setNome("Raphaela Galhardo Fernandes");
aluno.setMatricula(200027803);
aluno.setCpf(1234567898);
session.save(aluno); // Realiza persistncia
26
tx.commit(); // Finaliza transao

session.close(); // Fecha sesso
}
}
Listagem 12 - Exemplo de Persistncia da Classe Aluno
O cdigo para a criao de um objeto SessionFactory deve ser chamado
uma nica vez durante a execuo da aplicao. Objetos deste tipo armazenam os
mapeamentos e configuraes do Hibernate e so muito pesados e lentos de se
criar.
A Listagem 13 apresenta o resultado da execuo do cdigo fonte presente
na Listagem 12. No caso, o Hibernate buscou um valor para a chave primria da
tabela, utilizando a seqncia padro hibernate_sequence. Em seguida, o
comando INSERT foi executado para inserir uma linha na tabela aluno de acordo
com as informaes atribudas ao objeto montado.
Hibernate: select nextval ('hibernate_sequence')

Hibernate: insert into anotacoes.aluno
(matricula, nome, cpf, id_aluno) values (?, ?, ?, ?)
Listagem 13 Resultado da Execuo do Cdigo da Listagem 12
A Tabela 3 apresenta alguns dos mtodos que podem ser invocados a partir
do objeto Session.
Tabela 3 - Mtodos invocados a partir do objeto Session
save(Object)
Inclui um objeto em uma tabela do banco de dados.
saveOrUpdate(Object)
Inclui um objeto na tabela caso ele ainda no exista

(seja transiente) ou atualiza o objeto caso ele j
exista (seja persistente).
delete(Object)
Apaga um objeto da tabela no banco de dados.
get(Class, Serializable id)
Retorna um objeto a partir de sua chave primria. A

classe do objeto passada como primeiro argumento
e o seu identificador como segundo argumento.
Em relao ao mtodo saveOrUpdate, uma questo que se pode formular

a seguinte: Como o Hibernate sabe se o objeto em questo j existe ou no no
banco de dados, ou seja, se ele deve ser criado ou atualizado?. A resposta
simples: se o valor atribudo ao identificador for diferente de zero, o objeto deve ter
27
sua linha na tabela atualizada (deve-se garantir que o valor do identificador do

objeto se refere a um valor da chave primria da tabela). Caso contrrio, uma nova
linha ser adicionada tabela.
A Listagem 14 e a Listagem 15 apresentam exemplos dos mtodos
invocados a partir do objeto Session.
//...
// Busca objeto aluno da base de dados com chave primria = 1

Aluno aluno = (Aluno) session.get(Aluno.class, 1);
// Atualiza informao de matrcula.
// Como o identificador do objeto aluno diferente de 0,

// a sua matrcula atualizada j que foi alterada
session.saveOrUpdate(aluno);
tx.commit();
session.close();
//...
Listagem 14 - Exemplo de Busca e Atualizao de um Objeto Aluno
//...

// Existe linha na tabela aluno com chave primria = 2
aluno.setId(2);
// Deleta aluno com id = 2 da tabela.

// Somente necessria informao do seu identificador
session.delete(aluno);
tx.commit();
session.close();
//...
Listagem 15 - Exemplo de Remoo de Objeto Aluno
28
Os resultados das execues dos cdigos presentes na Listagem 14 e na

Listagem 15 podem ser vistos na Listagem 16 e na Listagem 17, respectivamente.
Hibernate: select aluno0_.id_aluno as id1_0_0_, aluno0_.matricula as
matricula0_0_, aluno0_.nome as nome0_0_, aluno0_.cpf as cpf0_0_
from anotacoes.aluno aluno0_ where aluno0_.id_aluno=?
Hibernate: update anotacoes.aluno set matricula=?, nome=?, cpf=?
where id_aluno=?
Hibernate: delete from anotacoes.aluno where id_aluno=?

12. Mapeando Atributos da Classe

Esta seo destina-se a apresentar alguns exemplos de mapeamentos de
atributos de uma classe. Considerando a classe Cliente exibida na Figura 7,
composta de um conjunto de atributos, onde um deles (id) corresponde chave
primria da tabela correspondente. Dessa forma, pode-se criar uma tabela cliente
na base de dados a partir do script mostrado na e Listagem 18.
Figura 7 - Classe Cliente
CREATE TABLE anotacoes.cliente

(
id_cliente integer NOT NULL,
cpf bigint NOT NULL,
nome character(40) NOT NULL,
endereco character(100),
total_compras numeric(16,2),
29
data_cadastro timestamp without time zone NOT NULL,

data_nascimento date
)
WITHOUT OIDS;
ALTER TABLE anotacoes.cliente OWNER TO postgres;
Listagem 18 Script para a Criao da Tabela cliente
classe
Cliente,
ilustrada
pela
Listagem
19,
possui
exemplos
de
mapeamentos de atributos a partir das anotaes: @Column, @Transient,

@Temporal. As anotaes @Id e @GeneratedValue tambm so utilizadas e
servem para mapear a chave primria da tabela correspondente e definir como o
seu valor ser gerado, respectivamente, como explicado anteriormente.
import javax.persistence.*;
@Entity
@Table(name="cliente", schema="anotacoes")
public class Cliente {
@Transient
private int temporaria;
@Id
@Column(name="id_cliente")
private int id;
@Column(unique=true, nullable=false,
insertable=true, updatable=true)
private long cpf;
@Column(nullable=false, length=40,
@Column(length=100)
private String endereco;
@Column(name="total_compras", precision=2)
private double totalCompras;
30
@Column(name="data_nascimento", nullable=false)
@Temporal(TemporalType.DATE)
private Date dataNascimento;
@Column(name="data_cadastro")
@Temporal(TemporalType.TIMESTAMP)
private Date dataCadastro;
public Cliente(){}

}
Listagem 19 Mapeamento da Classe Cliente com Anotaes
A seguir uma breve descrio da utilizao destas anotaes:
Anotao @Transient: informa que o atributo mapeado no possui

correspondente na tabela mapeada pela classe, ou seja, no um atributo
persistente;
Atributos da anotao @Column utilizados:
name: nome da coluna na tabela do banco de dados que representa

o atributo;
unique: indica se a coluna na tabela que representa o atributo

possui a restrio de unicidade ou no. Por padro, assume o valor
false;
nullable: indica se a coluna na tabela que representa o atributo pode

assumir valor nulo ou no. Por padro, assume o valor true,
indicando que pode assumir valores nulos;
length: informa o tamanho mximo assumido pelo valor da coluna

na tabela;
precision: informa a preciso decimal dos possveis valores para a

coluna mapeada pelo atributo;
insertable: indica se o atributo ser inserido no momento da

insero de uma linha na tabela. Por padro assume o valor true;
updatable: indica se o atributo ser atualizado no momento da

atualizao de uma linha na tabela. Por padro assume o valor true.
31
Anotao @Temporal: utilizada para mapeamento de datas e hora. Recebe

um valor como argumento que pode ser:
o
TemporalType.DATE: usado para mapear datas;
TemporalType.TIME: usado para mapear hora;
TemporalType.TIMESTAMP: usado para mapear datas e hora.
13. Associaes
O termo associao utilizado para se referir aos relacionamentos entre as
entidades. Os relacionamentos n-para-n, n-para-1 e 1-para-n so os mais comuns
entre as entidades de um banco de dados.
Nas sees seguintes, sero apresentados exemplos de mapeamentos com
anotaes para cada um dos tipos de relacionamentos citados.
13.1 Associaes 1-n (one-to-many)
Para exemplificar o relacionamento 1-n, considere o relacionamento entre a

entidade Centro e a entidade Universidade da Figura 8. O relacionamento diz que
uma universidade possui um conjunto de n centros e um centro est associado a
apenas uma nica universidade. Considere as classes de domnio Java de uma
universidade e de um centro, respectivamente, mostradas na Listagem 20 e na
Listagem 21. Ambas as classes j possuem o seu mapeamento via anotaes
inserido.
Figura 8 - Relacionamento entre Centro e Universidade
32
import java.util.Collection;
import org.hibernate.annotations.Cascade;
import org.hibernate.annotations.CascadeType;
@Entity @Table(schema="anotacoes")
public class Universidade {
@Id
@Column(name="id_universidade")
private int id;
@OneToMany(mappedBy="universidade", fetch = FetchType.LAZY)

@Cascade(CascadeType.ALL)
private Collection<Centro> centros;

//...
}
Listagem 20 - Classe de Domnio: Universidade
import org.hibernate.annotations.Fetch;
import org.hibernate.annotations.FetchMode;
public class Centro {
@Id @GeneratedValue(strategy = GenerationType.SEQUENCE)

@Column(name="id_centro")
private int id;
33
@ManyToOne(fetch = FetchType.EAGER)
@JoinColumn(name="id_universidade",
@Fetch(FetchMode.JOIN)
@Cascade(CascadeType.SAVE_UPDATE)
private Universidade universidade;
//...
}
Listagem 21 - Classe de Domnio: Centro
As classes de domnio Universidade e Centro so mapeadas para as

tabelas universidade e centro, que podem ser criadas na base de dados a partir
dos scripts apresentados na Listagem 22 e na Listagem 23, respectivamente.
CREATE TABLE anotacoes.universidade

(
id_universidade integer NOT NULL, -- Identificador da tabela
nome character(100) NOT NULL, -- Nome da universidade
CONSTRAINT pk_universidade PRIMARY KEY (id_universidade)
)
WITHOUT OIDS;
ALTER TABLE anotacoes.universidade OWNER TO postgres;
COMMENT
ON
COLUMN
anotacoes.universidade.id_universidade
IS
'Identificador da tabela';
COMMENT
ON
COLUMN
anotacoes.universidade.nome
IS
'Nome
da
universidade';
Listagem 22 Script para a Criao da Tabela universidade
CREATE TABLE anotacoes.centro

(
id_centro integer NOT NULL, -- Identificador da tabela
nome character(100) NOT NULL, -- Nome do centro
id_universidade integer NOT NULL,
-- Identificador da universidade a que o centro pertence
CONSTRAINT pk_centro PRIMARY KEY (id_centro),
CONSTRAINT fk_centro_universidade FOREIGN KEY (id_universidade)
REFERENCES anotacoes.universidade (id_universidade) MATCH SIMPLE
34
ON UPDATE NO ACTION ON DELETE NO ACTION

)
WITHOUT OIDS;
ALTER TABLE anotacoes.centro OWNER TO postgres;
COMMENT
ON
COLUMN
anotacoes.centro.id_centro
IS
'Identificador
da
tabela';
COMMENT ON COLUMN anotacoes.centro.nome IS 'Nome do centro';
COMMENT ON COLUMN anotacoes.centro.id_universidade IS 'Identificador
da universidade a que o centro pertence';
Listagem 23 Script para a Criao da Tabela centro
A classe de domnio Universidade a que possui um mapeamento do tipo

1-n atravs do atributo coleo de centros. O seu mapeamento foi feito na
Listagem 20 a partir da anotao @OneToMany. Como a coleo conter objetos
do tipo Centro, ento est classe tambm dever ser uma classe persistente da
aplicao. Na anotao @OneToMany, existe um atributo denominado mappedBy
que dever receber como valor o nome do atributo na classe Centro (classe dos
tipos de objetos da coleo) que se refere classe Universidade (onde h o
mapeamento 1-n). Em outras palavras, a tabela centro possui uma chave
estrangeira para a tabela universidade, representada pelo atributo Universidade
universidade da classe Centro, que corresponder ao atributo mappedBy
da
anotao @OneToMany, ou seja, mappedBy=universidade.

J o atributo fecth indica quando o contedo do atributo ser trazido da base
de dados. Pode assumir dois valores:
FetchType.EAGER: sempre que o objeto "pai" for trazido da base de

dados, o atributo mapeado com fetch=FetchType.EAGER far com que o
seu contedo tambm seja trazido;
FetchType.LAZY: sempre que o objeto "pai" for trazido da base de dados,

o atributo mapeado com fetch=FetchType.LAZY far com que o seu
contedo somente seja trazido quando acessado pela primeira vez.
A anotao @Cascade, tambm utilizada no mapeamento da coleo

centros, serve para indicar com que ao em cascata o relacionamento ser
tratado, ou seja, especifica quais operaes devero ser em cascata do objeto pai
para o objeto associado. Por exemplo, pode assumir alguns dos valores abaixo:
35
CascadeType.PERSIST:
os
objetos
associados
vo
ser
inseridos
automaticamente quando o objeto "pai" for inserido;

CascadeType.SAVE_UPDATE: os objetos associados vo ser inseridos ou
atualizados
automaticamente quando
objeto "pai"
for
inserido ou
atualizado;
CascadeType.REMOVE: os objetos associados ao objeto "pai" vo ser
removidos, quando o mesmo for removido;

CascadeType.REPLICATE: Se o objeto for replicado para outra base de
dados, os filhos tambm sero;

CascadeType.LOCK: Se o objeto for reassociado com a sesso persistente,
os filhos tambm sero;

CascadeType.REFRESH: Se o objeto for sincronizado com a base de
dados, os filhos tambm sero;

CascadeType.MERGE: Se um objeto tiver suas modificaes mescladas em
uma sesso, os filhos tambm tero;

CascadeType.EVICT: Se o objeto for removido do cache de primeira nvel,
os filhos tambm sero;

CascadeType.ALL: juno de todos os tipos de cascade.
Para ilustrar o efeito da anotao @Cascade(CascadeType.ALL), considere o

exemplo da Listagem 24, onde, inicialmente, um objeto Universidade criado. Em
seguida, dois objetos da classe Centro tambm so criados, recebem valores para
seu
atributo
nome
so
associados
ao
objeto
universidade,
que
posteriormente persistido.
//...
Universidade univ = new Universidade();
univ.setNome("Universidade Federal do Rio Grande do Norte");
Centro centro1 = new Centro();

centro1.setNome("Centro de Tecnologia");
centro1.setUniversidade(univ);
Centro centro2 = new Centro();
centro2.setNome("Centro de Humanas");
centro2.setUniversidade(univ);
univ.setCentros(new HashSet<Centro>());
36
univ.getCentros().add(centro1);
univ.getCentros().add(centro2);
session.save(univ);
//...
Listagem 24 Exemplo de Persistncia OneToMany. Efeito da anotao
Listagem
25
apresenta
resultado
da
persistncia
do
objeto
universidade presente na Listagem 24. Observa-se, que a partir do atributo

cascade com valor CascadeType.ALL, inicialmente inserida uma linha na tabela
universidade e em seguida duas linhas na tabela centro. Vale salientar, que na
hora de inserir as linhas na tabela centro, como os objetos que as representavam
foram associados ao objeto universidade, automaticamente, o Hibernate atribui
como valor de suas chaves estrangeiras, o valor gerado para a chave primria da
linha criada na tabela universidade.
Hibernate: insert into anotacoes.Universidade

(nome, id_universidade) values (?, ?)
Hibernate: insert into anotacoes.Centro
(nome, id_universidade, id_centro) values (?, ?, ?)
Hibernate: insert into anotacoes.Centro
(nome, id_universidade, id_centro) values (?, ?, ?)
O atributo centros da classe Universidade foi mapeado com a anotao

@OneToMany e com o atributo fecth=FetchType.EAGER. A Listagem 26
apresenta um exemplo de consulta a uma linha na tabela universidade com valor
de chave primria igual a 100. Na Listagem 27 e na Listagem 28 esto os
resultados da consulta considerando o atributo fecth da coleo definido como
FetchType.EAGER e como FetchType.LAZY, respectivamente.
37
//...
//Consulta de uma linha na tabela universidade

//com valor de chave primria = 100
Universidade univ =
(Universidade)session.get(Universidade.class, 100);
session.close();
//...
Listagem 26 Consulta para Ilustrar o Uso do Atributo fecth
Hibernate: select universida0_.id_universidade as id1_3_1_,

universida0_.nome as
nome3_1_, centros1_.id_universidade as id3_3_,
centros1_.id_centro as id1_3_, centros1_.id_centro as id1_1_0_,
centros1_.nome as nome1_0_,
centros1_.id_universidade as id3_1_0_
from anotacoes.Universidade universida0_
left outer join anotacoes.Centro centros1_ on
universida0_.id_universidade=centros1_.id_universidade
where universida0_.id_universidade=?
Listagem 27 Resultado da Execuo do Cdigo da Listagem 26 com
fecth=FetchType.EAGER

universida0_.nome as nome3_0_
fecth=FetchType.LAZY
A partir destes resultados, possvel observar que realmente com o valor

FetchType.EAGER, o SQL gerado pelo Hibernate na consulta de uma universidade
realiza um left outer join com a tabela centro j trazendo os dados da coleo,
podendo ser desnecessrio. Por outro lado, utilizando FetchType.LAZY, a consulta
retorna apenas os dados referentes universidade, de forma que se fossem
necessrios os dados da coleo, bastaria acessar o atributo que a representa no
objeto universidade.
38
A Listagem 29 apresenta um exemplo com a coleo centros mapeada com

FetchType.LAZY. Neste exemplo, a mesma consulta universidade de chave
primria igual a 100 feita e em seguida um acesso ao atributo centros, atravs
da linha do cdigo fonte univ.getCentros().iterator(). O resultado pode ser visto
na Listagem 30, em que duas SQLs so geradas, uma gerada no momento da
consulta linha na tabela universidade de identificador igual a 100 e a outra no
momento em que se itera a coleo centros do objeto anteriormente recuperado.
//...
//Consulta de uma linha na tabela universidade

//com valor de chave primria = 100.
//fetch=FetchType.LAZY. No traz dados da coleo centros
Universidade univ =
(Universidade)session.get(Universidade.class, 100);
//Acesso coleo centros, de forma que os dados sero buscados
univ.getCentros().iterator();
session.close();
//...
Listagem 29 Consulta para Ilustrar o Uso do Atributo
fecth=FetchType.LAZY

universida0_.nome as nome3_0_ from anotacoes.Universidade
universida0_ where universida0_.id_universidade=?
Hibernate: select centros0_.id_universidade as id3_1_,

centros0_.id_centro as id1_1_, centros0_.id_centro as id1_1_0_,
centros0_.nome as nome1_0_, centros0_.id_universidade as
id3_1_0_ from anotacoes.Centro centros0_
where centros0_.id_universidade=?
39
13.2 Associaes n-1 (many-to-one)
O relacionamento n-1 ser apresentado a partir do relacionamento existente

entre as classes Centro e Universidade, mostrado tambm na Figura 8. Neste
caso, o relacionamento est presente no mapeamento da classe Centro, como
mostrado na Listagem 21, atravs da anotao @ManyToOne. Para facilitar o
entendimento, o trecho de mapeamento many-to-one do atributo universidade da
classe Centro pode ser visto tambm na Listagem 31.
//...
public class Centro {
//...
@JoinColumn(name="id_universidade",
//...
}
Listagem 31 - Mapeamento ManyToOne
A anotao @ManyToOne tambm possui o atributo fetch, que possui o

mesmo comportamento apresentado anteriormente. A anotao @JoinColumn
utilizada para informar qual o nome da coluna que corresponde chave estrangeira
do mapeamento, no caso, name=id_universidade. Nesta anotao tambm
so aceitveis os atributos insertable e updatable que se assumirem true indica
que o atributo deve ser inserido (insertable) ou atualizado (updatable) no
momento em que o objeto que possui o relacionamento inserido ou atualizado,
respectivamente. O atributo do relacionamento no ser inserido se insertable =
false e no ser atualizado se updatable = false.
Outra anotao utilizada a @Fecth, que define como o atributo mapeado
ser recuperado da base de dados. Pode assumir trs valores:
40
FetchMode.JOIN: utiliza outer join para carregar entidades ou colees

mapeadas;
FetchMode.SELECT: utiliza um novo select para carregar entidades ou

colees mapeadas;
FetchMode.SUBSELECT: utiliza uma consulta subselect
adicional para
carregar
mapeamentos
colees
adicionais.
No
permitido
para
ManyToOne.
A Listagem 32 apresenta uma consulta base de dados do centro com valor de

chave primria igual a 110. A Listagem 33 apresenta o resultado da consulta com o
mapeamento do atributo universidade da classe Centro utilizando a anotao
@Fecth recebendo com valor FetchMode.JOIN. Pode-se observar que uma nica
consulta feita, realizando um JOIN entre as tabelas centro e universidade. J
na Listagem 34, o resultado da consulta com o uso da anotao @Fetch com o
valor FetchMode.SELECT resulta em duas consultas SELECT base de dados,
uma para buscar as informaes do centro de chave primria igual a 110 e a outra
para buscar as informaes da universidade associada.
//...
//Consulta de uma linha na tabela centro

//com valor de chave primria = 110
Centro centro = (Centro)session.get(Centro.class, 110);
session.close();
//...
Listagem 32 Consulta para Ilustrar o Uso da Anotao @Fecth
Hibernate: select centro0_.id_centro as id1_1_1_, centro0_.nome

as nome1_1_, centro0_.id_universidade as id3_1_1_,
universida1_.id_universidade as id1_3_0_, universida1_.nome as
nome3_0_
from anotacoes.Centro centro0_
left outer join anotacoes.Universidade
universida1_ on
centro0_.id_universidade=universida1_.id_universidade
where centro0_.id_centro=?
41
Hibernate: select centro0_.id_centro as id1_1_0_, centro0_.nome as

nome1_0_, centro0_.id_universidade as id3_1_0_
from anotacoes.Centro centro0_ where centro0_.id_centro=?

@Fetch(FetchMode.SELECT)
13.3 Associaes n-n (many-to-many)
O relacionamento n-n ser feito a partir do relacionamento entre as

entidades Departamento e Curso mostrado na Figura 9.
Figura 9 - Relacionamento n-n entre Curso e Departamento
Um relacionamento n-n implica em existir uma nova tabela para mapear o

relacionamento no banco de dados. Vamos denominar essa nova tabela como
DEPARTAMENTO_CURSO, como mostrado na Figura 10. Dessa forma, um
departamento possui uma coleo de cursos e um curso uma coleo de
departamentos. A existncia dessas colees nas classes de domnio opcional. Por
exemplo, pode ser que em um sistema real no seja necessrio saber todos os
departamentos de determinado curso, mas se for realmente necessrio, o
Hibernate apresenta outros mecanismos para a obteno desta informao.
42
Figura 10 - Tabela de relacionamento DEPARTAMENTO_CURSO
Para criar as tabelas curso, departamento e departamento_curso,

pode-se utilizar os scripts presentes na Listagem 35, na Listagem 36 e na Listagem
37, respectivamente.
CREATE TABLE anotacoes.curso

(
id_curso integer NOT NULL,
codigo integer NOT NULL,
nome character varying NOT NULL,
sigla character(6) NOT NULL,
CONSTRAINT pk_curso PRIMARY KEY (id_curso),
CONSTRAINT uk_codigo_curso UNIQUE (codigo)
)
WITHOUT OIDS;
ALTER TABLE anotacoes.curso OWNER TO postgres;
Listagem 35 - Script para a Criao da Tabela curso
CREATE TABLE anotacoes.departamento

(
id_departamento integer NOT NULL,
nome character varying NOT NULL,
sigla character(6) NOT NULL,
id_centro integer NOT NULL,
CONSTRAINT pk_departamento PRIMARY KEY (id_departamento),
CONSTRAINT fk_departamento_centro FOREIGN KEY (id_centro)
REFERENCES anotacoes.centro (id_centro) MATCH SIMPLE
)
WITHOUT OIDS;
ALTER TABLE anotacoes.departamento OWNER TO postgres;
Listagem 36 - Script para a Criao da Tabela departamento
43
CREATE TABLE anotacoes.departamento_curso

(
id_departamento integer NOT NULL,
id_curso integer NOT NULL,
CONSTRAINT fk_dc_curso FOREIGN KEY (id_curso)
REFERENCES anotacoes.curso (id_curso) MATCH SIMPLE
ON UPDATE NO ACTION ON DELETE NO ACTION,
CONSTRAINT fk_dc_departamento FOREIGN KEY (id_departamento)
REFERENCES anotacoes.departamento (id_departamento) MATCH SIMPLE
)
WITHOUT OIDS;
ALTER TABLE anotacoes.departamento_curso OWNER TO postgres;
Listagem 37 - Script para a Criao da Tabela departamento_curso
As classes Java das entidades Departamento e Curso esto ilustradas nas

Listagem 38 e Listagem 39, respectivamente. Ambas as classes possuem
mapeamentos de colees com o relacionamento n-n, que feito a partir da
anotao @ManyToMany. Para este mapeamento, foi preciso tambm do uso da
anotao @JoinTable para informar qual a tabela intermediria entre as entidades
Departamento e Curso.
A anotao @JoinTable possui o atributo name que onde informado o
nome da tabela intermediria que representa o mapeamento n-n, no caso, a tabela
departamento_curso. Possui tambm o atributo schema, onde dever ser
informado o esquema da base de dados em que a tabela se encontra. J o atributo
joinColumns recebe como valor uma anotao @JoinColumn, informando qual o
nome da coluna na tabela intermediria que representa a classe onde se est
fazendo o mapeamento n-n. Em relao ao mapeamento na tabela Departamento,
a coluna na tabela intermediria departamento_curso que a representa se chama
id_departamento. Por fim, no atributo inverseJoinColumns deve ser informada
qual a coluna que representa a outra entidade no relacionamento n-n. No
mapeamento da classe Departamento, a outra classe do relacionamento a
classe Curso, portanto, a coluna na tabela intermediria que a representa
id_curso.
44
@Entity
@Table(name="departamento", schema="anotacoes")
public class Departamento {
@Id
@Column(name="id_departamento")
private int id;
@Column(nullable=false, insertable=true, updatable=true)

@Column(nullable=false, insertable=true,
updatable=true, length=6)
private String sigla;
@ManyToOne(fetch=FetchType.EAGER)
@JoinColumn(name="id_centro", insertable=true, updatable=true)
private Centro centro;
@ManyToMany(fetch=FetchType.LAZY)
@JoinTable(name="departamento_curso", schema="anotacoes",
joinColumns=@JoinColumn(name="id_departamento"),
inverseJoinColumns=@JoinColumn(name="id_curso"))
private Collection<Curso> cursos;
//Mtodos setters e getters
}
Listagem 38 - Classe de Domnio: Departamento
Na classe Curso tambm h o mapeamento de um relacionamento n-n com

a coleo departamentos. A explicao semelhante ao mapeamento da coleo
cursos na classe Departamento.
45
@Entity
@Table(name="curso", schema="anotacoes")
public class Curso {
@Id
@Column(name="id_curso")
private int id;
@Column(unique=true, nullable=false,
private int codigo;
@Column(nullable=false, insertable=true,
updatable=true, length=6)
@Column(nullable=false, insertable=true, updatable=true)
private String sigla;
@ManyToMany(fetch=FetchType.LAZY)
@JoinTable(name="departamento_curso", schema="anotacoes",
joinColumns={@JoinColumn(name="id_curso")},
inverseJoinColumns={@JoinColumn(name="id_departamento")})
private Collection<Departamento> departamentos;
//Mtodos setters getters

}
Listagem 39 - Classe de Domnio: Curso
O cdigo presente na Listagem 40 cria um instncia de um objeto

Departamento. Em seguida recupera um objeto persistente da classe Centro com
identificador igual a 110 e outro da classe Curso com identificador igual a 220. O
objeto Curso adicionado na coleo de cursos do objeto Departamento criado.
Por fim, o departamento persistido.
//...
tx.begin();
46
Departamento depart = new Departamento();

depart.setNome("DEPARTAMENTO 1");
depart.setSigla("DEP.01");
//Busca objeto centro na base de dados com

//identificador igual a 110
depart.setCentro((Centro)session.get(Centro.class, 110));
//Busca objeto curso na base de dados com

//identificador igual a 220
Curso curso = (Curso)session.get(Curso.class, 220);
depart.setCursos(new ArrayList<Curso>());
//Adiciona curso na coleo do departamento
depart.getCursos().add(curso);
//Persiste departamento
session.save(depart);
tx.commit();
//...
Listagem 40 Exemplo com Mapeamento Usado a Anotao
@ManyToMany: Persistncia de Departamento
O SQL gerado apresentado na Listagem 41. Observa-se que SELECTs na
tabela centro, na tabela curso e na seqncia hibernate_seq so realizados.
Depois, feito e um INSERT na tabela departamento e em seguida, uma incluso
de
linha
na
tabela
de
relacionamento
departamento_curso,
devido
mapeamento n-n na classe Departamento.
Hibernate: select centro0_.id_centro as id1_1_1_, centro0_.nome as

nome1_1_, centro0_.id_universidade as id3_1_1_,
universida1_.id_universidade as id1_5_0_, universida1_.nome as
nome5_0_
from anotacoes.Centro centro0_
left outer join anotacoes.Universidade universida1_
on centro0_.id_universidade=universida1_.id_universidade
where centro0_.id_centro=?
47
ao
Hibernate: select curso0_.id_curso as id1_3_0_, curso0_.codigo as

codigo3_0_, curso0_.nome as nome3_0_, curso0_.sigla as sigla3_0_
from anotacoes.curso curso0_
where curso0_.id_curso=?
Hibernate: insert into anotacoes.departamento

(nome, sigla, id_centro, id_departamento) values (?, ?, ?, ?)
Hibernate: insert into anotacoes.departamento_curso

(id_departamento, id_curso) values (?, ?)
Listagem 41 Resultado da Execuo do Cdigo Presente na Listagem 40
13.4 Associaes n-n com Atributos
Imagine que seria necessrio guardar a data em que foi feita a associao
entre um determinado curso e um determinado departamento, ou seja, necessrio
ter um novo atributo na tabela departamento_curso. Dessa forma, esta tabela
no
seria
formada
apenas
pelos
identificadores
das
tabelas
curso
departamento, mas sim tambm pela data. Para essa situao, os mapeamentos
dos relacionamentos com a anotao @ManyToMany nas classes Departamento
e Curso no resolveriam o problema. Ento, deve-se criar uma nova classe
DepartamentoCurso, como mostrado no diagrama da Figura 11, formada por
uma chave primria composta por dois elementos e por um atributo que representa
a data.
Figura 11 - Mapeamento n-n com Atributo

Para adicionar a coluna data tabela departamento_curso, basta utilizar
o script apresentado na Listagem 42.
48
ALTER TABLE anotacoes.departamento_curso ADD COLUMN

data time without time zone;
ALTER TABLE anotacoes.departamento_curso ALTER COLUMN
data SET STORAGE PLAIN;
Listagem 42 - Script
departamento_curso
para
Adio
da
Coluna
data
na
Tabela
Com a adio da coluna data, deve ser feito o mapeamento da tabela

departamento_curso como mostrado na Listagem 43 a partir da classe
DepartamentoCurso. Pode-se observar que a chave composta representada
pelo atributo chaveComposta do tipo DepartamentoCursoPK e mapeada pela
anotao @EmbeddedId.
A classe DepartamentoCursoPK representa a chave primria composta e
mapeada como mostrado na seo seguinte.
import java.util.Date;
@Entity
@Table(name="departamento_curso", schema="anotacoes")
public class DepartamentoCurso {
@EmbeddedId
private DepartamentoCursoPK chaveComposta;
@Column(name="data")
@Temporal(TemporalType.DATE)
private Date data;

}
Listagem 43 - Classe de Domnio: DepartamentoCurso
13.4.1 Composite-id
Para mapear uma chave composta, deve-se criar uma classe que a
49
represente. Esta classe deve ser mapeada com a anotao @Embeddable, como
mostrado
na
Listagem
44
no
mapeamento
da
chave
composta
DepartamentoCursoPK. Dentro desta classe deve-se mapear os atributos que

compem a chave composta das maneiras vistas anteriormente. importante
ressaltar que a classe que representa a chave composta deve implementar a
interface Serializable.
import java.io.Serializable;
@Embeddable
public class DepartamentoCursoPK implements Serializable{
@JoinColumn(name="id_departamento")
private Departamento departamento;
@JoinColumn(name = "id_curso")
private Curso curso;
}
Listagem 44 - Classe de Domnio: DepartamentoCursoPK
Para exemplificar o relacionamento n-n com atributos, observe o exemplo da

Listagem 45. Primeiro um departamento e um curso so buscados na base de
dados, ambos com identificadores iguais a 1. Em seguida, cria-se uma instncia de
um objeto da classe DepartamentoCursoPK que representa a chave composta.
Os valores que compem a chave, curso e departamento, so atribudos.
Finalmente, cria-se um objeto da classe DepartamentoCurso que representa a
tabela de relacionamento entre as entidades, define-se a sua chave composta e a
data de criao, persistindo-o na base de dados.
//...
tx.begin();
Departamento d = (Departamento)session.get(Departamento.class, 1);
50
Curso c = (Curso)session.get(Curso.class, 1);
//Cria Chave Composta

DepartamentoCursoPK dcID = new DepartamentoCursoPK();
dcID.setDepartamento(d);
dcID.setCurso(c);
//Define relacionamento com atributo

DepartamentoCurso dc = new DepartamentoCurso();
dc.setChaveComposta(dcID);
dc.setData(new Date());
session.save(dc);
tx.commit();
//...
Listagem 45 Exemplo com Mapeamento de Chave Composta
O resultado da execuo do cdigo presente na Listagem 45 pode ser visto

na Listagem 46.
Hibernate: select departamen0_.id_departamento as id1_4_2_,

departamen0_.nome as nome4_2_, departamen0_.sigla as sigla4_2_,
departamen0_.id_centro as id4_4_2_, centro1_.id_centro as
id1_1_0_, centro1_.nome as nome1_0_, centro1_.id_universidade as
id3_1_0_, universida2_.id_universidade as id1_6_1_,
from anotacoes.departamento departamen0_
left outer join anotacoes.Centro centro1_ on
departamen0_.id_centro=centro1_.id_centro left outer join
anotacoes.Universidade universida2_ on
centro1_.id_universidade=universida2_.id_universidade
where departamen0_.id_departamento=?
Hibernate: select curso0_.id_curso as id1_3_0_, curso0_.codigo as

codigo3_0_, curso0_.nome as nome3_0_, curso0_.sigla as sigla3_0_
from anotacoes.curso curso0_ where curso0_.id_curso=?
Hibernate: insert into anotacoes.departamento_curso

(data, id_departamento, id_curso) values (?, ?, ?)
51
13.5 Associaes 1-1 (one-to-one)

Considere o relacionamento 1-1 entre as entidades Universidade e
Endereco mostrado na Figura 12. Uma universidade tem um nico endereo e um
endereo pertence apenas a uma nica universidade.
Figura 12 - Exemplo de Relacionamento 1-1

A Listagem 20 e a Listagem 47 apresentam as classes Java para as
entidades Universidade e Endereco, respectivamente. Na classe Endereco, o
relacionamento 1-1 com a classe Universidade mapeado atravs da anotao
@OneToOne e da anotao @JoinColumn usada para informar o nome da coluna
que representa a chave estrangeira para a tabela universidade.
@Entity
@Table(schema="anotacoes")
public class Endereco {
@Id
@Column(name="id_endereco")
private int id;
private String rua;

private int numero;
private String bairro;
private String cidade;
52
private String uf;

private int cep;
@OneToOne
@JoinColumn(name="id_universidade")

//...
}
Listagem 47 - Classe de Domnio: Endereo
A tabela endereo pode ser criada a partir do script exibido na Listagem 48.
CREATE TABLE anotacoes.endereco

(
id_endereco integer NOT NULL,
rua character varying(200) NOT NULL,
numero integer NOT NULL,
bairro character(30) NOT NULL,
cidade character(30) NOT NULL,
uf character(2) NOT NULL,
cep integer NOT NULL,
id_universidade integer NOT NULL,
CONSTRAINT endereco_pkey PRIMARY KEY (id_endereco),
CONSTRAINT fk_universidade_endereco FOREIGN KEY (id_universidade)
REFERENCES anotacoes.universidade (id_universidade) MATCH SIMPLE
)
WITHOUT OIDS;
ALTER TABLE anotacoes.endereco OWNER TO postgres;
Listagem 48 - Script para a Criao da Tabela endereco
Para finalizar o mapeamento 1-1 entre as classes Universidade e

Endereo, deve ser includo na classe Universidade o atributo endereco tambm
mapeado com a anotao @OneToOne, como mostrado na Listagem 49. No
mapeamento 1-1 na classe Universidade, como em sua tabela no h chave
estrangeira para a tabela endereco, deve-se informar qual atributo na classe
Universidade refere-se ao mapeamento 1-1 do outro lado, no caso o atributo
53
universidade, informado pelo atributo mappedBy da anotao @OneToOne.

Tambm
utilizada
anotao
@Cascade
passando
como
argumento
CascadeType.ALL, informando que no momento que se inserir, atualizar ou

remover uma universidade, a operao deve ser cascateada para a coluna da
tabela.
//...
@OneToOne(mappedBy="universidade")
private Endereco endereco;
//...
Listagem 49 Incluso de Atributo endereco na classe Universidade
Para ilustrar o uso deste mapeamento, considere o exemplo mostrado na

Listagem 50, onde, incialmente, objetos da classe Endereco e Universidade so
criados. Em seguida, associa-se a universidade ao endereo e o endereo a
universidade. Por fim, o objeto universidade persistido na base de dados.
A Listagem 51 apresenta o resultado da execuo do cdigo presente na
Listagem 50. Observa-se a universidade persistida na base de dados e em
seguida, o endereo tambm fazendo a associao com a universidade criada.
54
//...
tx.begin();
Endereco endereco = new Endereco();
endereco.setRua("Av. Senador Salgado Filho");
endereco.setNumero(1034);
endereco.setBairro("Lagoa Nova");
endereco.setCidade("Natal");
endereco.setUf("RN");
endereco.setCep(59067710);
Universidade universidade = new Universidade();
universidade.setNome("Universidade Teste");
endereco.setUniversidade(universidade);
universidade.setEndereco(endereco);
session.save(universidade);
tx.commit();
//...
Listagem 50 Exemplo para Ilustrar Mapeamento 1-1

Hibernate: insert into anotacoes.Universidade
(nome, id_universidade) values (?, ?)
Hibernate: insert into anotacoes.Endereco
(rua, numero, bairro, cidade, uf, cep,
id_universidade, id_endereco) values (?, ?, ?, ?, ?, ?, ?, ?)
14. Definio de Chave Primria Utilizando uma Seqncia Prpria

Nos mapeamentos apresentados at o momento, a definio dos valores das
chaves primrias foi feita apenas utilizando a seqncia hibernate_sequence. O
exemplo presente na Listagem 52 mostra o mapeamento da chave primria da
tabela cliente utilizando a seqncia de nome cliente_seq. Para isso, utilizou-se
55
as anotaes @SequenceGenerator e @GeneratedValue.

Na anotao @SequenceGenerator define-se qual seqncia criada na
base de dados ser utilizada para o mapeamento. No caso, nomeia-se a seqncia
com o nome SEQ_CLIENTE (name = SEQ_CLIENTE).
Para definir qual seqncia ser utilizada no mapeamento da chave
primria, utiliza-se a anotao @GeneratedValue, onde informado que a
definio
do
valor
do
atributo
GenerationType.SEQUENCE)
ser
atravs
nome
de
da
seqncias
mesma
(strategy
(generator
"SEQ_CLIENTE").
@Entity
@Table(name="cliente", schema="anotacoes")
public class Cliente {
@Id
@SequenceGenerator(name = "SEQ_CLIENTE",
sequenceName = " anotacoes.cliente_seq")
@GeneratedValue(
strategy = GenerationType.SEQUENCE,
generator = "SEQ_CLIENTE")
@Column(name="id_cliente")
private int id;
//...
}
Listagem 52 Mapeamento de Chave Primria Usando Seqncia Prpria
15. Colees
O
mapeamento
de
colees
foi
apresentado
no
contexto
dos
relacionamentos atravs da anotao @OneToMany. Essa seo est destinada a

apresentar o mapeamento dos quatro tipos de colees existentes (Set, Bag, List e
Map), porm formadas por tipos primitivos.
56
15.1
Set
Para exemplificar o mapeamento de um Set de tipos primitivos considere o
mapeamento de uma coleo de Strings para armazenar os telefones de um

Aluno, como visto na Figura 13. Ento, na classe Aluno deve-se inserir o atributo
telefones com seu mapeamento anotado, como mostrado na Listagem 53.
Figura 13 - Coleo de telefones para Aluno: Set
Para mapear esta coleo foi utilizada a anotao @CollectionOfElements.

A anotao @JoinTable utlizada para informar o nome da tabela e esquema onde
a coleo dos elementos mapeados sero armazendos, no caso atravs dos
atributos
name=aluno_telefone
schema=anotacoes.
Na
anotao
@JoinTable tambm informada o nome da coluna que representa a classe onde

a coleo est sendo mapeada, no caso a classe Aluno. Para informar esta coluna,
utiliza-se
atributo
joinColumns
que
recebe
como
valor
anotao
@JoinColumn com o nome da coluna, no caso id_aluno. Por fim, informa-se a

coluna que representar a informao do telefone utilizando a anotao @Column.
Os telefones do aluno so armazenados na tabela aluno_telefone. Para o
banco de dados est tabela separada da tabela aluno, mas para o Hibernate, ele
cria a iluso de uma nica entidade.
//...
import org.hibernate.annotations.CollectionOfElements;
//...
@CollectionOfElements
@JoinTable(name = "aluno_telefone", schema = "anotacoes",
joinColumns = @JoinColumn(name = "id_aluno"))
@Column(name = "telefone")
private Set<String> telefones;
//...
Listagem 53 Atributo telefones Inserido na Classe Aluno (Set)
57
Um Set no pode apresentar elementos duplicados, portanto a chave

primria de aluno_telefone consiste nas colunas id_aluno e telefone.
O script para a criao da tabela aluno_telefone est presente na Listagem
54.
CREATE TABLE anotacoes.aluno_telefone
(
id_aluno integer NOT NULL,
telefone character varying(12) NOT NULL
)
WITHOUT OIDS;
ALTER TABLE anotacoes.aluno_telefone OWNER TO postgres;
Listagem 54 - Script para a Criao da Tabela aluno_endereco
Dado o mapeamento da coleo de telefones de Aluno, observe o exemplo

mostrado na Listagem 55. Neste exemplo, cria-se um objeto Aluno que ter
valores para seus atributos definidos, inclusive dois nmeros de telefone inseridos
em sua coleo de Strings. Por fim, o objeto Aluno persistido. O resultado
mostrado na Listagem 56, onde primeiro inserida uma linha na tabela aluno e
posteriormente duas linhas na tabela aluno_telefone.
//...
tx.begin();
aluno.setNome("Joo Maria Costa Neto");
aluno.setTelefones(new HashSet<String>());
aluno.getTelefones().add("32222529");
session.save(aluno);
tx.commit();
//...
Listagem 55 - Exemplo de Mapeamento de Set
58

Hibernate: insert into anotacoes.aluno_telefone
(id_aluno, telefone) values (?, ?)
(id_aluno, telefone) values (?, ?)
Listagem 56 - Resultado da Execuo do Cdigo Presente na Listagem 55
15.2 List
Um List uma coleo ordenada que pode conter elementos duplicados. O

mapeamento de uma lista requer a incluso de uma coluna de ndice na tabela do
banco de dados. A coluna ndice define a posio do elemento na coleo, como
visto na Figura 14, a coluna ndice representada pela coluna posicao da tabela
aluno_telefone. Dessa maneira, o Hibernate pode preservar a ordenao da
coleo quando recuperada do banco de dados e for mapeada como um List.
Figura 14 - Coleo de telefones para Aluno: List

Para mapear a coleo de telefones da classe Aluno, define o atributo
telefones como mostrado na Listagem 57. A diferea a incluso da definio do
ndice atravs da anotao @IndexColumn(name = posio), informando a
coluna que ele representa na tabela.
//...
import org.hibernate.annotations.IndexColumn;
//...
59

@IndexColumn(name = "posicao")
private List<String> telefones;
//...
Listagem 57 Atributo telefones Inserido na Classe Aluno (List)
Mapeando
coleo
como
um
List,
chave
primria
da
tabela
ALUNO_TELEFONE passa a ser as colunas ID_ALUNO e POSICAO, permitindo a

presena de telefones (TELEFONE) duplicados na coleo.
Para exemplificar, considera-se o exemplo presente na Listagem 58, com
resultado de execuo presente na Listagem 59.
//...
tx.begin();

aluno.setTelefones(new ArrayList<String>());
tx.commit();
//...
Listagem 58 - Exemplo de Mapeamento de List

(id_aluno, posicao, telefone) values (?, ?, ?)
60
15.3 Map
Maps associam chaves aos valores e no podem conter chaves duplicadas.
Eles diferem de Sets no fato de que contm chaves e valores, ao passo que os
Sets contm somente a chave.
O mapeamento de um Map semelhante ao de um List, onde o ndice de
posio passa a ser a chave. Veja a Figura 14. A Listagem 60 apresenta a coleo
de telefones sendo mapeada como um Map. A chave primria da tabela
aluno_telefone passa a ser as colunas id_aluno e chave, tambm permitindo a
presena de telefones duplicados na coleo. A diferena dos outros mapeamentos
que a chave mapeada atravs da anotao @MapKey(columns =
{@Column(name = "chave")}).
Figura 15 - Coleo de telefones para Aluno: Map
//...
import org.hibernate.annotations.MapKey;
//...
@MapKey(columns = {@Column(name = "chave")})
private Map<String, String> telefones;
//...
Listagem 60 Atributo telefones Inserido na Classe Aluno (Map)
Para exemplificar, considera-se o exemplo presente na Listagem 61, com

resultado de execuo presente na Listagem 62.
//...
tx.begin();
61

aluno.setTelefonesMap(new HashMap<String, String>());

aluno.getTelefonesMap().put("1", "2234346");
aluno.getTelefonesMap().put("2", "2342342");
tx.commit();
//...
Listagem 61 - Exemplo de Mapeamento de Map

(id_aluno, chave, telefone) values (?, ?, ?)
(id_aluno, chave, telefone) values (?, ?, ?)
15.4 Bag
Um Bag consiste em uma coleo desordenada que permite elementos
duplicados. Em Java no h implementao de um Bag, contudo o Hibernate
fornece um mecanismo de que um List em Java simule o comportamento de um
Bag. Pela definio de um List, uma lista uma coleo ordenada, contudo o
Hibernate no preserva a ordenao quando um List persistido com a semntica
de um Bag. Para usar o Bag, a coleo de telefones deve ser definida com o tipo
List. Um exemplo de mapeamento de um Bag pode ser visto na Figura 16 e na
Listagem 63.
62
Figura 16 - Coleo de telefones para Aluno: Bag

Para simular o Bag como List, a chave primria no deve ter associao
com
posio
do
elemento
na
tabela,
assim
ao
invs
da
anotao
@IndexColumn, utiliza-se a anotao @CollectionId, onde uma chave substituta

diferente atribuda a cada linha da tabela na coleo. Entretanto, o Hibernate no
fornece nenhum mecanismo para descobrir o valor chave substituta de uma linha
em particular.
Para
exemplo,
chave
substituta
representada
pela
coluna
id_aluno_telefone da table aluno_telefone. necessrio informar como os seus

valores sero gerados, neste caso, utlizada uma seqncia. A anotao
@SequenceGenerator serve para definir o nome de uma seqncia no banco de
dados. O atributo name informa como ser denominada a seqncia, j o atributo
sequenceName informa qual seqncia se est utilizando.
A anotao @CollectionId utlizada para definir a chave substituta. No
atributo columns informa-se qual o nome da coluna na tabela; o atributo
generator informa qual seqncia est sendo utilizada para gerar seus valores (no
caso SEQ_HIBERNATE definida na anotao @SequenceGenerator); e o atributo
type utilizado para informar o tipo desta coluna, no caso integer.
//...
import org.hibernate.annotations.CollectionId;
import org.hibernate.annotations.Type;
//...
@JoinTable( name = "aluno_telefone", schema = "anotacoes",
@SequenceGenerator( name = "SEQ_HIBERNATE",
sequenceName = "hibernate_sequence")
@CollectionId(columns = @Column (name = "id_aluno_telefone"),
generator = "SEQ_HIBERNATE",
63
type = @Type(type = "integer"))

private List<String> telefones;
//...
Listagem 63 Atributo telefones Inserido na Classe Aluno (Bag)
Para exemplificar, considera-se o exemplo presente na Listagem 58, onde a
coleo agora est mapeada com semntica de Bag, com resultado de execuo
presente na Listagem 64. Observa-se que a seqncia hibernate_sequence
invocada duas vezes: uma para o valor da chave primria do objeto Aluno e outra
para o valor da chave substitua da coleo de telefones.
(id_aluno, id_aluno_telefone, telefone) values (?, ?, ?)
16. Herana
O Hibernate fornece vrios mecanismos de se realizar o mapeamento de
uma relao de herana:
Tabela por classe concreta: cada classe concreta mapeada para

uma tabela diferente no banco de dados. Em cada classe so
definidas colunas para todas as propriedades da classe, inclusive as
propriedades herdadas;
Tabela por Hierarquia: todas as classes so mapeadas em uma nica

tabela;
Tabela por Sub-Classe: mapeia cada tabela, inclusive a classe me,

para tabelas diferentes.
Observe o exemplo de herana apresentado na Figura 17. Neste caso, as

classes Aluno e Professor herdam da classe Pessoa, ou seja, so seus filhos.
64
Figura 17 Herana
A Figura 18, a Figura 19 e a Figura 20 mostram as tabelas que devem ser

criadas para as estratgias de mapeamento tabela por classe concreta, tabela por
hierarquia e tabela por sub-classe, respectivamente.
Figura 18 - Tabela por Classe Concreta
Figura 19 -Tabela por Hierarquia
65
Figura 20 - Tabela por Sub-Classe
16.1 Tabela Por Classe Concreta

Em relao estratgia tabela por classe concreta, onde so criadas duas
tabelas independentes, uma para cada classe filha da classe Pessoa, mapeia-se a
classe me usando a anotao @MappedSuperclass e seus atributos como j
apresentado em sees anteriores. O mapeamento da classe Pessoa pode ser visto
na Listagem 65.
package br.com.jeebrasil.hibernate.anotacoes.heranca.dominio;
import javax.persistence.MappedSuperclass;
@MappedSuperclass
@Id
@Column(name="id_pessoa")
private int id;
66

private long cpf;

//...
}
Listagem 65 Mapeamento da Classe Pessoa: Tabela Por Classe Concreta
Para mapear as subclasses atravs desta estratgia, utiliza-se a anotao
@Inheritance informando atravs do atributo strategy a estratgia de tabela por
classe concreta (valor InheritanceType.TABLE_PER_CLASS). A Listagem 66 e a
Listagem 67 apresentam os mapeamentos das classes Aluno e Professor,
respectivamente, que herdam da classe Pessoa. Verifica-se que apenas os
atributos especficos de cada classe precisam ser mapeados.
import javax.persistence.FetchType;
import javax.persistence.Inheritance;
import javax.persistence.InheritanceType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import br.com.jeebrasil.hibernate.anotacoes.dominio.Curso;
@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Aluno extends Pessoa{

//...
}
Listagem 66 Mapeamento da Classe Aluno: Tabela Por Classe Concreta
67
import javax.persistence.FetchType;
import javax.persistence.JoinColumn;
import javax.persistence.ManyToOne;
import br.com.jeebrasil.hibernate.anotacoes.dominio.Departamento;
//Anotao que informa que a classe mapeada persistente

@Entity
@Table(name="professor", schema="anotacoes")
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
public class Professor extends Pessoa{
@JoinColumn(name = "id_departamento")

//...
}
Listagem 67 Mapeamento da Classe Professor: Tabela Por Classe
Concreta
O principal problema dessa estratgia que no suporta muito bem

associaes polimrficas. Em banco de dados, as associaes so feitas atravs de
relacionamentos de chave estrangeira. Neste caso, as sub-classes so mapeadas
em tabelas diferentes, portanto uma associao polimrfica para a classe me no
seria possvel atravs de chave estrangeira.
Outro problema dessa abordagem que se uma propriedade mapeada na
superclasse, o nome da coluna deve ser o mesmo em todas as tabelas das
subclasses.
Dessa
forma,
vrias
colunas
diferentes
de
tabelas
distintas
compartilham da mesma semntica, podem tornar a evoluo do esquema mais
68
complexo, por exemplo, a mudana de um tipo de uma coluna da classe me

implica em mudanas nas vrias tabelas mapeadas.
Considere o exemplo mostrado na Listagem 68, em que um objeto do tipo
Aluno criado, tem valores atribudos para os atributos herdados e especfico e,
por fim, persistido. O resultado exibido na Listagem 69, onde uma linha na
tabela aluno inserida.
//...
tx.begin();
//Definio de atributos herdados

aluno.setCpf(228765287);
aluno.setNome("Claudia Dantas Pedroza");
//Definio de atributo especfico

Curso curso = (Curso) session.get(Curso.class, 220);
aluno.setCurso(curso);
//Persistncia do objeto aluno

tx.commit();
//...
Listagem 68 Exemplo de Persistncia: Tabela Por Classe Concreta
Hibernate: select curso0_.id_curso as id1_3_0_,

curso0_.codigo as codigo3_0_, curso0_.nome as nome3_0_,
curso0_.sigla as sigla3_0_ from anotacoes.curso curso0_
where curso0_.id_curso=?
(matricula, nome, cpf, id_curso, id_pessoa)
values (?, ?, ?, ?, ?)
69
16.2 Tabela Por Hierarquia

Em relao tabela por hierarquia, o mapeamento deve ser feito como
mostrado nas listagens abaixo, onde todos os atributos da classe me e das classes
filhas so armazenadas em uma nica tabela. Os mapeamentos de todas as classes
so feitos na tabela pessoa.
Para haver a distino entre as trs classes (Pessoa, Aluno e Professor)
surge uma coluna especial (discriminator). Essa coluna no uma propriedade da
classe persistente, mas apenas usada internamente pelo Hibernate. No caso, a
coluna discriminator a tipo_pessoa e neste exemplo pode assumir os valores 0,
1 e 2. Esses valores so atribudos automaticamente pelo framework. O valor 0
representa um objeto persistido do tipo Pessoa, o tipo 1 representa um objeto do
tipo Aluno, j o tipo 2, um objeto do tipo Professor.
O mapeamento da classe Pessoa, classe me, feito utilizando a anotao
@Inheritance
recebendo
InheritanceType.SINGLE_TABLE,
atributo
strategy
infomando
que
as
com
trs
classes
valor
sero
mapeadas em uma nica tabela.

A anotao @DiscriminatorColumn utilizada para informar a coluna
especial que identificar de que tipo ser o objeto persistido. O nome da coluna
definido pelo atributo name e o seu tipo pelo atributo discrimitatorType, que no
caso Integer. Por fim, a anotao @DiscriminatorValue utilizada para definir
o valor assumido pela coluna tipo_pessoa no caso de se persistir um objeto do
tipo Pessoa. Os atributos da classe so mapeados das maneiras apresentadas
anteriormente.
@Entity
@Table(name = "pessoa", schema = "anotacoes")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(
name = "tipo_pessoa",
discriminatorType = DiscriminatorType.INTEGER
)
@DiscriminatorValue("0")
70
@Id
private int id;
private long cpf;

//...
}
Listagem 70 Mapeamento da Classe Pessoa: Tabela Por Hierarquia
Os mapeamentos das subclasses Aluno e Professor sao feitos como
mostrado na Listagem 71 e na Listagem 72, respectivamente. Essas classes devem
ser mapeadas com anotao @Entity e com a anotao @DiscriminatorValue
para definir o valor assumido pela coluna tipo_pessoa no caso de se persistir um
objeto do tipo Aluno ou Professor.
@Entity
@JoinColumn(name = "aluno_id_curso")

//...
}
Listagem 71 Mapeamento da Classe Aluno: Tabela Por Hierarquia
71
@Entity
@JoinColumn(name = "professor_id_departamento")

//...
}
Listagem 72 Mapeamento da Classe Professor: Tabela Por Hierarquia
Considere o exemplo mostrado na Listagem 73, em que um objeto do tipo

Professor criado, tem valores atribudos para os atributos herdados e especfico
e, por fim, persistido. O resultado exibido na Listagem 74, onde uma linha na
tabela professor inserida.
//...
tx.begin();
Professor prof = new Professor();

prof.setCpf(2342523);
prof.setNome("Pedro Maia Ferreira");
prof.setMatricula(23523);

Departamento departamento = new Departamento();
departamento.setId(210);
prof.setDepartamento(departamento);
//Persistncia do objeto professor

session.save(prof);
72
//...
Listagem 73 Exemplo de Persistncia: Tabela Por Hierarquia

Hibernate: insert into anotacoes.pessoa
(matricula, nome, cpf, professor_id_departamento,
tipo_pessoa, id_pessoa) values (?, ?, ?, ?, 2, ?)
A estratgia tabela por hierarquia bastante simples e apresenta o melhor

desempenho na representao do polimorfismo. importante saber que restries
no nulas no so permitidas para o mapeamento de propriedades das sub-classes,
pois esse mesmo atributo para uma outra sub-classe ser nulo.
16.3 Tabela Por SubClasse
A terceira estratgia, como j citada, consiste em mapear cada classe em uma

tabela diferente. Nessa estratgia as tabelas filhas contm apenas colunas que no
so herdadas e suas chaves primrias so tambm chaves estrangeiras para a
tabela me. A Listagem 75 apresenta o mapeamento da superclasse Pessoa, onde
a estratgia de mapeamento da herana definida como JOINED, atravs da
anotao @Inheritance(strategy=InheritanceType.JOINED).
@Entity
@Table(name = "pessoa", schema = "anotacoes")
@Inheritance(strategy=InheritanceType.JOINED)
73
@Id
private int id;
private long cpf;
//...
}
Listagem 75 Mapeamento da Classe Pessoa: Tabela Por SubClasse
Os mapeamentos das subclasses Aluno e Professor sao feitos como
mostrado na Listagem 76 e Listagem 77, respectivamente. Essas classes devem ser
mapeadas com anotao @Entity e com a anotao @PrimaryKeyJoinColumn
para definir qual coluna da tabela filha corresponde coluna chave primria na
tabela me, que devem ter o mesmo valor.
@Entity
@PrimaryKeyJoinColumn(name = "id_aluno")
//...
}
Listagem 76 Mapeamento da Classe Aluno: Tabela Por SubClasse
74
@Entity
@Table(name="professor", schema="anotacoes")
@PrimaryKeyJoinColumn(name = "id_professor")
@JoinColumn(name = "id_departamento")
//...
}
Listagem 77 Mapeamento da Classe Professor: Tabela Por SubClasse
Neste caso, por exemplo, se um objeto da classe Aluno persistido, os

valores das propriedades da classe me so persistidos em uma linha da tabela
pessoa e apenas os valores correspondentes classe Aluno so persistidos em
uma linha da tabela aluno. Em momentos posteriores essa instncia de aluno
persistida pode ser recuperada de um join entre a tabela filha e a tabela me,
utilizando a coluna definida na anotao @PrimaryKeyJoinColumn. Uma grande
vantagem dessa estratgia que o modelo de relacionamento totalmente
normalizado.
A Listagem 78 apresenta um exemplo de persistncia de um objeto da
classe Professor. Observa-se no resultado da execuo na Listagem 79, que
inserida uma linha na tabela pessoa com os valores dos atributos herdados da
classe Pessoa e uma outra linha na tabela professor com apenas os valores
especficos da classe.
//...
tx.begin();
Professor prof = new Professor();

prof.setCpf(2342523);
75
prof.setNome("Pedro Maia Ferreira");

prof.setMatricula(23523);

Departamento departamento = new Departamento();
departamento.setId(210);
prof.setDepartamento(departamento);
//Persistncia do objeto professor

session.save(prof);
//...
Listagem 78 Exemplo de Persistncia: Tabela Por SubClasse

Hibernate: insert into anotacoes.pessoa
(matricula, nome, cpf, id_pessoa) values (?, ?, ?, ?)
Hibernate: insert into anotacoes.professor
(id_departamento, id_professor) values (?, ?)
17. Transaes
Uma transao uma unidade de execuo indivisvel (ou atmica). Isso
significa
dizer
que
todas
as
etapas
pertencentes
uma
transao
so
completamente finalizadas ou nenhuma delas termina.

Para exemplificar o conceito de transaes, considere um exemplo clssico
de transferncia entre contas bancrias: transferir R$ 150,00 da conta corrente do
cliente A para a conta corrente do cliente B. Basicamente, as operaes que
compem a transao so:
1) Debitar R$ 150,00 da conta corrente do cliente A

2) Creditar R$ 150,00 na conta corrente do cliente B
Para a efetivao da transao descrita acima, seria necessrio seguir os

seguintes passos:
1) Ler o saldo da conta corrente A (xA)

2) Calcular o dbito de R$ 150,00 da conta corrente A (dA = xA 150,00)
76
3) Gravar na base de dados o novo saldo da conta corrente A (xA = dA)

4) Ler o saldo da conta corrente B (xB)
5) Calcular o crdito de R$ 150,00 na conta corrente B (dB = xB + 150,00)
6) Gravar na base de dados o novo saldo da conta corrente B (xB = dB)
Caso ocorra algum problema (por exemplo: falta de energia, falha no

computador, falha no programa, etc.), a execuo dos passos anteriores pode ser
interrompida. Se, por exemplo, houvesse interrupo logo aps a execuo do 3
passo, a conta A teria um dbito de R$ 150,00 e ainda no teria sido creditado R$
150,00 na conta corrente B. Neste caso, o banco de dados estaria em um estado
inconsistente, afinal, R$ 150,00 teriam sumido da conta A sem destino. Dessa
maneira, de suma importncia garantir que esses seis passos sejam totalmente
executados. Caso haja alguma falha antes da concluso do ltimo passo, deve-se
garantir tambm que os passos j executados sero desfeitos, de forma que ou
todos os passos so executados ou todos os passos no so executados. Para
garantir a consistncia do banco, esses seis passos devem ser executados dentro
de uma transao, j que ela uma unidade de execuo atmica.
Resumindo, uma transao garante que a seqncia de operaes dentro da
mesma seja executada de forma nica, ou seja, na ocorrncia de erro em alguma
das operaes dentro da transao todas as operaes realizadas desde o incio
podem ser revertidas e as alteraes no banco de dados desfeitas, garantindo
assim, a unicidade do processo.
A transao pode ter dois fins: commit ou
rollback.
Quando a transao sofre commit, todas as modificaes nos dados
realizadas pelas operaes presentes na transao so salvas. Quando a transao
sofre rollback, todas as modificaes nos dados realizadas pelas operaes
presentes na transao so desfeitas.
Para que um banco de dados garanta a integridade dos seus dados deve
possuir quatro caractersticas, conhecidas como ACID:
Atomicidade: o banco de dados deve garantir que todas as transaes

sejam indivisveis.
Consistncia: aps a execuo de uma transao, o banco de dados deve

continuar consistente, ou seja, deve continuar com um estado vlido.
77
Isolamento: mesmo que vrias transaes ocorram paralelamente (ou

concorrentemente),
nenhuma
transao
deve
influenciar
nas
outras.
Resultados parciais de uma transao no devem ser vistos por outras

transaes executadas concorrentemente.
Durabilidade: aps a finalizao de uma transao, todas as alteraes

feitas por ela no banco de dados devem ser durveis, mesmo havendo
falhas no sistema aps a sua finalizao.
17.1 Modelos de Transaes

As definies do incio de uma transao, de seu fim e das aes que devem
ser tomadas na ocorrncia de falhas so feitas atravs de um modelo de transao.
Existem diversos modelos encontrados na literatura. Nesta seo sero abordados
apenas quatro: Flat Transactions, Nested Transactions, Chained Transactions e Join
Transactions.
Flat Transaction. Modelo mais utilizado pela maioria dos Sistemas

Gerenciadores de Banco de Dados (SGBD) e Gerenciadores de Transaes.
Conhecida como modelo de transaes planas por apresentar uma nica
camada de controle, ou seja, todas as operaes dentro da transao so
tratadas como uma nica unidade de trabalho.
Nested Transaction. Este modelo, tambm conhecido como Modelo de

Transaes Aninhadas, possibilita que uma transao possa ser formada por
vrias sub-transaes. Em outras palavras, uma nica transao pode ser
dividida em diversas unidades de trabalho, com cada unidade operando
independente uma das outras. A propriedade de atomicidade vlida para
as sub-transaes. Alm disso, uma transao no pode ser validada at
que todas as suas sub-transaes tenham sido finalizadas. Se uma
transao for interrompida, todas as suas sub-transaes tambm sero. O
contrrio no verdadeiro, j que se uma sub-transao for abortada a
transao que a engloba pode: ignorar o erro; desfazer a sub-transao;
iniciar uma outra sub-transao.
Chained Transaction. Tambm conhecido como Modelo de Transaes

Encadeadas, esse modelo tem como objetivo desfazer as operaes de uma
transao em caso de erro com a menor perda de trabalho possvel. Uma
78
transao
encadeada
consiste
em
um
conjunto
de
sub-transaes
executadas seqencialmente, em que medida que as sub-transaes vo

sendo executadas, so validadas e no podem mais ser desfeitas. Os
resultados do conjunto de transaes s sero visveis ao final da execuo
de todas elas.
Join Transaction. Esse modelo permite que duas transaes sejam unidas
em uma s, de forma que todos os recursos passam a ser compartilhados.
17.2 Transaes e Banco de Dados

Uma transao de banco de dados formada por um conjunto de operaes
que manipulam os dados. A atomicidade de uma transao garantida por duas
operaes: commit e rollback.
Os limites das operaes de uma transao devem ser demarcados. Assim,
possvel saber a partir de qual operao a transao iniciada e em qual
operao ela finalizada. Ao final da execuo da ltima operao que pertence
transao, todas as alteraes no banco de dados realizadas pelas operaes que
compe a transao devem ser confirmadas, ou seja, um commit realizado. Se
houver algum erro durante a execuo de algumas das suas operaes, todas as
operaes da transao que j foram executadas devem ser desfeitas, ou seja, um
rollback realizado. A Figura 21 ilustra esses conceitos.
Figura 21 - Estados do sistema durante uma transao
17.3 Ambientes Gerenciados e No Gerenciados
As sees seguintes referem-se s definies dos conceitos relacionados a
79
transaes JDBC e JTA, onde aparecem os termos ambientes gerenciados e no

gerenciados. Esta seo destina-se a explicar sucintamente o que so esses
termos.
Os
ambientes
gerenciados
so
aqueles
caracterizados
pela
gerncia
automtica de transaes realizadas por algum container. Exemplos de ambientes

gerenciados so componentes EJB (Enteprise JavaBeans) executando em servidores
de aplicaes (JBoss, Geronimo, etc). J os ambientes no gerenciados so
cenrios onde no h nenhuma gerncia de transao, como por exemplo:
Servlets, aplicaes desktop, etc..
17.4 Transaes JDBC

A tecnologia JDBC (Java Database Connectivity) um conjunto de classes e
interfaces escritas em Java, ou API, que realiza o envio de instrues SQL
(Structured Query Language) para qualquer banco de dados relacional.
Uma transao JDBC controlada pelo gerenciador de transaes SGBD e
geralmente utilizada por ambientes no gerenciados. Utilizando um driver JDBC,
o incio de uma transao feito implicitamente pelo mesmo.
bancos
de
dados
necessitem
invocar
uma
sentena
begin
Embora alguns
transaction
explicitamente, com a API JDBC no preciso fazer isso. Uma transao

finalizada aps a chamada do mtodo commit(). Caso algo acontea de errado,
para desfazer o que foi feito dentro de uma transao, basta chamar o mtodo
rollback(). Ambos, commit() e rollback(), so invocados a partir da conexo
JDBC.
A conexo JDBC possui um atributo auto-commit que especifica quando a
transao ser finalizada. Se este atributo for definido como true, ou seja, se na
conexo JDBC for invocado setAutoCommit(true), ativa-se o modo de auto
commit. O modo auto commit significa que para cada instruo SQL uma nova
transao criada e o commit realizado imediatamente aps a execuo e
finalizao da mesma, no havendo a necessidade de aps cada transao invocar
explicitamente o mtodo commit().
Em alguns casos, uma transao pode envolver o armazenamento de dados
em vrios bancos de dados. Nessas situaes, o uso apenas do JDBC pode no
garantir a atomicidade. Dessa maneira, necessrio um gerenciador de transaes
com suporte a transaes distribudas. A comunicao com esse gerenciador de
transaes feita usando JTA (Java Transaction API).
80
17.5 Transaes JTA

As transaes JTA so usadas em um ambiente gerencivel, onde existem
transaes CMT (Container Managed Transactions). Neste tipo de transao no h
a necessidade de programao explcita das delimitaes das transaes, esta
tarefa realizada automaticamente pelo prprio container. Para isso, necessrio
informar nos descritores dos EJBs a necessidade de suporte transacional s
operaes e como ele deve gerenci-lo.
O gerenciamento de transaes feito pelo Hibernate a partir da interface
Transaction.
17.6 API para Transaes do Hibernate
A interface Transaction fornece mtodos para a declarao dos limites de

uma transao. A Listagem 80 apresenta um exemplo de uso de transaes com a
interface Transaction.
A
transao
iniciada
partir
da
invocao
ao
mtodo
session.beginTransaction(). No caso de um ambiente no gerenciado, uma

transao JDBC na conexo JDBC iniciada. J no caso de um ambiente
gerenciado, uma nova transao JTA criada, caso no exista nenhuma j criada.
Casa j existe uma transao JTA, essa nova transao une-se a existente.
A chamada ao mtodo tx.commit() faz com que os dados em memria
sejam sincronizados com a base de dados. O Hibernate s realiza efetivamente o
commit se o comando beginTransaction() iniciar uma nova transao (em ambos
ambientes gerenciado ou no gerenciado). Se o beginTransaction() no iniciar
uma nova transao (no caso de transaes JTA isso possvel), ento o estado em
sesso apenas sincronizado com o banco de dados e a finalizao da transao
feita de acordo com a primeira parte do cdigo fonte que a criou.
Se ocorrer algum erro durante a execuo do mtodo acaoExecutada(), o
mtodo tx.rollback() executado, desfazendo o que foi feito at o momento em
que o erro ocorreu.
Observa-se que no final do cdigo a sesso finalizada a partir do comando
session.close(), liberando a conexo JDBC e devolvendo-a para o pool de
conexes.
Session session = sessions.openSession();

Transaction tx = null;
81
try {
tx = session.beginTransaction();
acaoExecutada();
tx.commit();
} catch (Exception e) {
if (tx != null) {
try {
tx.rollback();
} catch (HibernateException he) {
//log he and rethrow e
}
}
} finally {
try {
session.close();
} catch (HibernateException he) {
throw he;
}
}
Listagem 80 - Usando a Interface Transaction do Hibernate
17.7 Flushing
Flushing o processo de sincronizar os dados em sesso (ou em memria)

com o banco de dados. As mudanas nos objetos de domnio em memria feitas
dentro do escopo de uma sesso (Session) no so imediatamente propagadas
para o banco de dados. Isso permite ao Hibernate unir um conjunto de alteraes e
fazer um nmero mnimo de interaes com o banco de dados, ajudando a
minimizar a latncia na rede.
A operao de flushing ocorre apenas em trs situaes: quando dado
commit na transao, algumas vezes antes de uma consulta ser executada (em
situaes que alteraes podem influenciar em seu resultado) e quando o mtodo
Session.flush() invocado.
O Hibernate possui um modo flush que pode ser definido a partir do
82
comando session.setFlushMode(). Este modo pode assumir os seguintes valores:
FlushMode.AUTO: valor padro. Faz com que o Hibernate no realize o

processo de flushing antes de todas as consultas, somente realizar se as
mudanas dentro da transao alterar seu resultado.
FlushMode.COMMIT: especifica que os estados dos objetos em memria

somente sero sincronizados com a base de dados ao final da transao, ou
seja, quando o mtodo commit() chamado.
FlushMode.NEVER: especifica que a sincronizao s ser realizado diante da

chamada explcita ao mtodo flush().
17.8 Nveis de Isolamento de uma Transao
As bases de dados tentam assegurar que uma transao ocorra de forma

isolada,
ou
seja,
mesmo
que
estejam
acontecendo
outras
transaes
simultaneamente, como se ela estivesse ocorrendo sozinha.

O nvel de isolamento de uma transao especifica quais dados esto visveis
a uma sentena dentro de uma transao. Eles impactam diretamente no nvel de
acesso concorrente a um mesmo alvo no banco de dados por transaes diferentes.
Geralmente, o isolamento de transaes feito usando locking, que significa
que uma transao pode bloquear temporariamente um dado para que outras
transaes no o acessem no momento que ela o est utilizando. Muitos bancos de
dados implementam o nvel de isolamento de uma transao atravs do modelo de
controle concorrente multi-verses (MCC Multiversion Concorrency Control).
Dentre alguns fenmenos que podem ocorrer devido quebra de isolamento
de uma transao esto trs:
Dirty Read (Leitura Suja): uma transao tem acesso a dados modificados
por uma outra transao ainda no finalizada que ocorre concorrentemente.
Isso pode causar problema, pois pode ocorrer um erro dentro da transao
que est modificando os dados e as suas alteraes serem desfeitas antes
de confirmadas, ento possvel que a transao que acessa os dados j
modificados esteja trabalhando se baseando em dados incorretos.
Nonrepeatable Read (Leitura que no pode ser repetida): uma transao

l mais de uma vez um mesmo dado e constata que h valores distintos em
cada leitura. Por exemplo, uma transao A l uma linha do banco; uma
83
transao B modifica essa mesma linha e finalizada (commit) antes que a

transao A; a transao A l novamente esta linha e obtm dados
diferentes.
Phantom Read (Leitura Fantasma): em uma mesma transao uma

consulta pode ser executada mais de uma vez e retornar resultados
diferentes. Isso pode ocorrer devido a uma outra transao realizar
mudanas que afetem os dados consultados. Por exemplo, uma transao A
l todas as linhas que satisfazem uma condio WHERE; uma transao B
insere uma nova linha que satisfaz a mesma condio antes da transao A
ter sido finalizada; a transao A reavalia a condio WHERE e encontra
uma linha fantasma na mesma consulta feita anteriormente.
Existem quatro nveis de isolamento da transao em SQL. Eles se

diferenciam de acordo com a ocorrncia ou no dos fenmenos anteriormente
descritos, como mostrado na Tabela 4.
Tabela 4 - Nveis de Isolamento da Transao em SQL

Nvel de Isolamento
Dirty Read
Nonrepeatable
Phanton Read
Read Uncommited
SIM
SIM
SIM
Read Commited
NO
SIM
SIM
Repeatable Read
NO
NO
SIM
Serializable
NO
NO
NO
A escolha do nvel de isolamento Read Uncommited no recomendada

para banco de dados relacionais, j que permite ler inconsistncias e informaes
parciais (mudanas realizadas por uma transao ainda no finalizada podem ser
lidas por outra transao). Se a primeira transao no for concluda, mudanas na
base de dados realizadas pela segunda transao podem deix-la com um estado
inconsistente.
Com o nvel Read Commited, uma transao somente visualiza mudanas
feitas por outras transaes quando confirmadas, permitindo que transaes s
acessem estados consistentes do banco. No caso de uma atualizao/excluso de
uma linha de alguma tabela por uma transao, pode ser que a mesma tenha
acabado de ser modificada por uma transao concorrente. Nesta situao, a
transao que pretende atualizar fica esperando a transao de atualizao que
iniciou primeiro ser efetivada ou desfeita. Se as atualizaes da primeira transao
forem desfeitas, seus efeitos sero desconsiderados e a segunda transao
84
efetivar suas mudanas considerando a linha da tabela anteriormente lida. Caso

contrrio, a segunda transao ir ignorar a atualizao caso a linha tenha sido
excluda ou aplicar a sua atualizao na verso atualizada da linha.
O nvel Repeatable Read no permite que uma transao sobrescreva os
dados alterados por uma transao concorrente. Uma transao pode obter uma
imagem completa da base de dados quando iniciada. Este nvel ideal para a
gerao de relatrios, pois em uma mesma transao, um registro lido diversas
vezes e seu valor se mantm o mesmo at que a prpria transao altere seu
valor.
Em relao ao nvel Serializable, ele fornece o nvel de isolamento de
transao mais rigoroso. Ele permite uma execuo serial das transaes, como se
todas as transaes fossem executadas uma atrs da outra. Dessa forma, pode-se
perder um pouco do desempenho da aplicao.
17.9 Configurando o nvel de isolamento

No Hibernate cada nvel de isolamento identificado por um nmero:
1: Read Uncommited
2: Read Commited
4: Repeatable Read
8: Serializable
Para configur-lo basta incluir a linha presente na Listagem 81 no arquivo de

configurao *.cfg.xml. Neste exemplo, o nvel de isolamento foi definido como
Repeatable Read.
<property name=" hibernate.connection.isolation">4</property>
Listagem 81 Configurao do Nvel de Isolamento
18. Concorrncia
Em algumas situaes pode acontecer que duas ou mais transaes que
ocorrem paralelamente leiam e atualizem o mesmo dado. Considerando que duas
transaes leiam um mesmo dado x quase que simultaneamente. Ambas as
transaes vo manipular esse mesmo dado com operaes diferentes e atualiz-lo
85
na base de dados. Para exemplificar, a Listagem 82 apresenta um exemplo de duas

transaes concorrentes manipulando o mesmo dado x.
No primeiro passo, ambas as transaes lem o dado x com o mesmo valor
(2). Em seguida, T1 soma o valor x que leu com 1 e o valor de x para T1 passa a
ser 3 (2 + 1). J T2, soma o valor de x lido a 3 e x passa a ter o valor 5 (2 + 3).
Por fim, ambos T1 e T2 gravaro os novos valores de x calculados na base de
dados, respectivamente. Como no h controle de concorrncia de acesso ao dado
x, o seu valor final corresponder a 5, ou seja, o valor calculado por T2,
significando que as alteraes feitas por T1 foram descartadas.
1) Transao 1 (T1) l x = 2
2) Transao 2 (T2) l x = 2
3) T1 faz x = x + 1
4) T2 faz x = x + 3
5) T1 armazena o valor de x na base de dados
6) T2 armazena o valor de x na base de dados
Listagem 82 Exemplo de Transaes Concorrentes
Para evitar a situao descrita anteriormente, deve-se controlar o acesso

concorrente ao dado, ou seja, deve-se implementar o mecanismo de Locking. O
gerenciamento de locking e da concorrncia pode ser feito de duas formas:
Pessimista: utilizar o controle pessimista significa que se uma transao T1

l um dado e tem a inteno de atualiz-lo, esse dado ser bloqueado
(nenhuma outra transao poder l-lo) at que T1 o libere, normalmente
aps a sua atualizao.
Otimista: utilizar o controle otimista significa que se T1 l e altera um dado

ele no ser bloqueado durante o intervalo entre a leitura e atualizao.
Caso uma outra transao T2 tenha lido esse mesmo dado antes de T1 o
atualiz-lo tente alter-lo em seguida na base de dados, um erro de violao
de concorrncia deve ser gerado.
18.1 Lock Otimista
Para ilustrar o gerenciamento do tipo otimista, um exemplo dado a partir

das Figura 22 e Figura 23.
86
O problema mostrado na Figura 22, onde, inicialmente, duas transaes

(ilustradas por Thread 1 e Thread 2) acessam um mesmo dado na base de dados
(SELECT Dado), uma seguida da outra. Logo em seguida, a primeira transao
(Thread 1) atualiza este dado na base de dados e depois quem tambm o atualiza
a segunda transao (Thread 2). Nesta abordagem otimista, acontece que a
atualizao do dado feita pela segunda transao sobrescreve a atualizao
realizada pela primeira, ou seja, a atualizao feita pela primeira transao
perdida.
Figura 22 - Loocking Otimista: Atualizao Sobrescrita
Para resolver o problema descrito anteriormente com a abordagem otimista,

pode-se utilizar o conceito de Version Number, que um padro utilizado para
versionar numericamente os dados de uma linha de uma tabela na base de dados.
Por exemplo, na Figura 23, tambm, inicialmente, duas transaes (ilustradas por
App 1 e App 2) acessam um mesmo dado na base de dados (SELECT Dado), uma
seguida da outra. Com isso, esse mesmo dado nas duas transaes so rotulados
com a verso atual dele na base de dados, no caso, Verso 1. Logo em seguida, a
segunda transao atualiza este dado. Quando a atualizao vai ser feita,
verificado se a verso do dado na transao corresponde verso dele na base de
dados. Nesta primeira atualizao, a verso da transao 1 e a da base de dados
tambm. Como elas so iguais, a atualizao efetivada e a verso do dado na
base de dados passa a ser a Verso 2. Por fim, a primeira transao vai tambm
atualizar este mesmo dado. Dessa forma, tambm feita uma comparao entre as
verses do dado na transao e na base de dados. Neste caso, a verso na
transao a 1 e na base de dados 2, ou seja, as verses no correspondem.
87
Assim, um erro disparado e a atualizao desejada pela primeira transao no

concretizada, evitando que a atualizao feita pela segunda transao no seja
desfeita.
Figura 23 - Loocking Otimista: Abodargem com Version Number
Com o Hibernate, uma forma de utilizar o versionamento dos dados

utilizar a anotao @Version no mapeamento das tabelas. Para exemplificar o seu
uso, considera-se a classe ContaCorrente presente na Listagem 83 que ser
mapeada para a tabela conta_corrente na base de dados. Dentre os diversos
atributos da classe t o atributo denominado versao do tipo inteiro que ir guardar
a verso atual das linhas da tabela.
@Entity
@Table(name = "conta_corrente", schema = "anotacoes")
public class ContaCorrente {
//Atributo utilizado para o versionamento

@Version
@Column(name = "versao")
private int versao;
//Demais atributos
@Id
88
@Column(name = "id_conta_corrente")
@GeneratedValue(strategy = GenerationType.AUTO)
private int id;
private double saldo;
//Outros atributos
//...
public int getVersao(){

return versao;
}
public void setVersao(int versao){
this.versao = versao;
}
//Outros mtodos getters e setters
//...
}
Listagem 83 - Classe de Domnio: ContaCorrente. Primeira Estratgia
Locking Otimista
A tabela conta_corrente tambm deve ter uma coluna para onde esse
atributo versao ser mapeado, como mostrado no script de criao da tabela na
Listagem 84. De acordo com o mapeamento feito na classe ContaCorrente, toda
vez que uma determinada linha for atualizada na base de dados, a sua coluna
versao ser incrementada de uma unidade, indicando a nova verso dos dados.
CREATE TABLE anotacoes.conta_corrente

(
id_conta_corrente integer NOT NULL,
saldo numeric(16,2) NOT NULL,
versao integer NOT NULL,
CONSTRAINT pk_conta_corrente PRIMARY KEY (id_conta_corrente)
)
WITHOUT OIDS;
ALTER TABLE anotacoes.conta_corrente OWNER TO postgres;
Listagem 84 - Script para a Criao da Tabela conta_corrente
89
Considerando o exemplo apresentado na Listagem 85, em que um objeto

ContaCorrente criado e persistido na base de dados, observa-se o resultado
presente na Figura 24 da insero do mesmo como linha da tabela correspondente.
No caso, a linha foi inserida e a verso atual da mesma assumiu o valor zero,
correspondendo primeira verso.
//...
ContaCorrente conta = new ContaCorrente();
conta.setSaldo(1000);
//Persistncia do objeto conta

session.save(conta);
tx.commit();
//...
Listagem 85 Persistindo Objeto com Atributo Version Number
Figura 24 - Resultado da Execuo do Cdigo Presente na Listagem 85

Caso a prxima operao seja uma atualizao do objeto que corresponde a
esta linha, como mostrado na Listagem 86, verifica-se o resultado na Figura 25,
onde os dados da conta corrente foram atualizados. Tambm teve-se a coluna
versao sendo incrementada de uma unidade, atualizando a informao de
versionamento da linha da tabela.
//...
ContaCorrente conta = (ContaCorrente)

session.get(ContaCorrente.class, 65);
//Modificando valor do saldo
conta.setSaldo(12250);
90
//Atualizacao
do objeto conta corrente
session.saveOrUpdate(conta);
tx.commit();
//...
Listagem 86 Atualizando Objeto com Atributo Version Number
Figura 25 - Resultado da Execuo do Cdigo Presente na Listagem 86
Outra forma de implementar o lock otimista utilizando o atributo que

representa a verso do dado como sendo do tipo timestamp. Neste caso, a classe
ContaCorrente do exemplo anterior ao invs de ter um atributo inteiro para
guardar a verso do dado, teria uma atributo do tipo java.util.Date para guardar o
instante no tempo da ltima atualizao. Neste caso, a classe de domnio com o
mapeamento seria equivalente mostrada na Listagem 87. Neste exemplo, a
tabela conta_corrente deve conter uma coluna do tipo timestamp denominada
data_ultima_atualizacao.
import java.util.Date;
@Entity
//Atributo utilizado para o versionamento

@Version
@Column(name = "data_ultima_atualizacao")
@Temporal(TemporalType.TIMESTAMP)
private Date data;
//Demais atributos
91
@Id
private int id;
//Outros atributos
//...
public Date getData(){
return data;
}
public void setData(Date Data){
this.data = data;
}
//Outros mtodos getters e setters
//...
}
Listagem 87 - Classe de Domnio: ContaCorrente. Segunda Estratgia
Locking Otimista
Se a tabela no possuir uma coluna para guardar a verso do dado ou a

data da ltima atualizao, com Hibernate, h uma outra forma de implementar o
lock otimista, porm essa abordagem s deve ser utilizada para objetos que so
modificados e atualizados em uma mesma sesso (Session). Se este no for o
caso, deve-se utilizar uma das duas abordagens citadas anteriormente.
Com essa ltima abordagem, quando uma determinada linha vai ser
atualizada, o Hibernate verifica se os dados dessa linha correspondem aos mesmos
dados que foi recuperado. Caso afirmativo, a atualizao efetuada. Para isso, no
mapeamento
da
tabela,
OptimisticLockType.ALL
deve-se
da
utilizar
anotao
atributo
optimisticLock
@org.hibernate.annotations.Entity
(Alm da anotao javax.persistence.Entity), como mostrado na Listagem 91.
@Entity
@org.hibernate.annotations.Entity(
optimisticLock = OptimisticLockType.ALL , dynamicUpdate = true)
92
//Atributos da classe
@Id
private int id;
//Outros atributos
//...

//...
}
Listagem 88 - Classe de Domnio: ContaCorrente. Terceira Estratgia
Locking Otimista
Dessa maneira, quando uma linha dessa tabela fosse atualizada, o SQL
equivalente gerado para a atualizao seria como o exibido na Listagem 89. Neste
exemplo, considera-se a atualizao do saldo para
R$ 1.500,00 de uma
determinada conta de saldo R$ 1.000,00.
UPDATE CONTA_CORRENTE SET SALDO = 1500

WHERE ID_CONTA = 104 AND
SALDO = 1000 AND
DESCRICAO = "DESCRICAO DA CONTA" AND
ID_CORRENTISTA = 23
Listagem 89 - Exemplo com Lockin Otimista: optimisticLock =
OptimisticLockType.ALL
18.2 Lock Pessimista

A estratgia de lock pessimista para proibir o acesso concorrente a um
mesmo dado da base de dados feita bloqueando o mesmo at que a transao
seja finalizada.
Alguns banco de dados, como o Oracle e PostgreSQL, utilizam a construo
SQL SELECT FOR UPDATE para bloquear o dado at que o mesmo seja atualizado.
O Hibernate fornece um conjunto de modos de lock (constantes disponveis na
classe LockMode) que podem ser utilizados para implementar o lock pessimista.
93
Considerando o exemplo da Listagem 90, onde um determinado aluno

consultado na base de dados e tem seu nome atualizado. Neste caso, no h um
bloqueio ao dado, ento qualquer outra transao pode acessar este mesmo dado
concorrentemente e modific-lo, de forma que poder ocorrer uma incosistncia
dos dados. Na Listagem 91, h um exemplo de uso do lock pessimista para resolver
este problema, bastando passar a constante LockMode.UPGRADE como terceiro
argumento do mtodo get do objeto Session.
Aluno aluno = (Aluno) session.get(Aluno.class, alunoId);
aluno.setNome("Novo Nome");
tx.commit();
Listagem 90 - Exemplo de Transao sem Lock
Aluno aluno =
(Aluno) session.get(Aluno.class, alunoId, LockMode.UPGRADE);
aluno.setNome("Novo Nome");
tx.commit();
Listagem 91 - Exemplo de Transao com Lock Pessimista:
LockMode.UPGRADE
O mtodo get do objeto Session pode receber como terceiro argumento
para implementar o lock pessimista as seguintes constantes:
Lock.NONE: S realiza a consulta ao banco se o objeto no estiver no

cache1.
Lock.READ: Ignora os dados no cache e faz verificao de verso para

assegurar-se de que o objeto em memria o mesmo que est no banco.
Lock.UPDGRADE: Ignora os dados no cache, faz verificao de verso (se

aplicvel) e obtm lock pessimista do banco (se suportado).
Lock.UPDGRADE_NOWAIT: Mesmo que UPGRADE, mas desabilita a

espera por liberao de locks, e dispara uma exceo se o lock no puder
ser obtido. Caso especial do Oracle que utiliza a clusula SELECT ... FOR
UPDATE NOWAIT para realizar locks.
uma tcnica comumente utilizada para aprimorar o desempenho da

Conceito apresentado na
prxima sesso.
O cache
aplicao no que diz respeito ao acesso ao banco de dados.
94
Lock.WRITE: Obtida automaticamente quando o Hibernate realiza alguma

insero ou atualizao na base de dados.
19. Caching
O cache uma tcnica comumente utilizada para aprimorar o desempenho
da aplicao no que diz respeito ao acesso ao banco de dados. Com o cache
possvel fazer uma cpia local dos dados, evitando acesso ao banco sempre que a
aplicao precise, por exemplo, acessar dados que nunca ou raramente so
alterados e dados no crticos. O uso do cache no indicado para manipulao de
dados crticos, de dados que mudam freqentemente ou de dados que so
compartilhados com outras aplicaes legadas. Uma m escolha das classes que
tero objetos em cache pode gerar inconsistncias na base de dados.
Existem trs tipos principais de chache:
Escopo de Transao: utilizado no escopo da transao, ou seja, cada

transao possui seu prprio cache. Duas transaes diferentes no
compartilham o mesmo cache.
Escopo de Processo: h o compartilhamento do cache entre uma ou mais

transaes. Os dados no escopo do cache de uma transao podem ser
acessados
por
uma
outra
transao
que
executa
concorrentemente,
podendo provocar implicaes relacionadas ao nvel de isolamento.
Escopo de Cluster: cache compartilhado por vrios processos pertencentes

a mquinas virtuais distintas e deve ser replicado por todos os ns do
cluster.
Considerando o cache no escopo da transao, se na transao houver mais

de uma consulta a dados com mesmas identidades de banco de dados, a
mesma instncia do objeto Java ser retornada.
Pode ser tambm que o mecanismo de persistncia opte por implementar
identidade no escopo do processo, de forma que a identidade do objeto seja
equivalente identidade do banco de dados. Assim, se a consulta a dados em
transaes que executam concorrentemente for feita a partir de identificadores
95
de banco de dados iguais, o resultado tambm ser o mesmo objeto Java.

Outra forma de se proceder retornar os dados em forma de novos objetos.
Assim, cada transao teria seu prprio objeto Java representando o mesmo
dado no banco.
No escopo de cluster, necessrio haver comunicao remota, em que os
dados so sempre manipulados por cpias. Em geral, utiliza-se o JavaGroups,
que consiste em uma plataforma utilizada como infra-estrutura para a
sincronizao do cache no no cluster.
Nas situaes em que estratgias de MOR permitem que vrias transaes
manipulem uma mesma instncia de objeto persistente, importante ter um
controle de concorrncia eficiente, por exemplo, bloqueando um dado enquanto
ele no atualizado. Utilizando o Hibernate, ter-se- um conjunto diferente de
instncias para cada transao, ou seja, tem-se identidade no escopo da
transao.
19.1 Arquitetura de Cache com Hibernate
A Figura 26 apresenta a arquiteura de cache com o Hibernate. Existem dois

nveis de caches. O primeiro nvel encontra-se em nvel de uma sesso
(Session), ou em nvel de transao de banco de dados ou at mesmo de uma
transao de aplicao. Este nvel no pode ser desabilitado e garante a
identifidade do objeto dentro da sesso/transao. Dessa forma, dentro de uma
mesma sesso, garantida que se a aplicao requisitar o mesmo objeto
persistente duas vezes, ela receber de volta mesma instncia, evitando um
trfego maior na base de dados.
Com o uso do cache em nvel de transao, nunca podero existir diferentes
representaes do mesmo registro de banco de dados ao trmino de uma
transao, tendo apenas um objeto representando qualquer registro. Mudanas
realizadas em um objeto, dentro de uma transao, so sempre visveis para
qualquer outro cdigo executado dentro da mesma transao.
Quando so feitas chamadas atravs dos mtodos: load(), find(), list(),
iterate() ou filter() o contedo do objeto primeiramente procurado no nvel
de cache.
96
O segundo nvel de cache opcional e pode abranger o nvel do escopo do

processo ou do cluster. um cache de estado e no de instncias persistentes.
Por ser opcional, preciso configurar este nvel de cache para ser usado na
aplicao. Cada classe que precisar ter objetos em cache possui uma
configurao individual, pois cada uma ter particularidade de mapeamento.
Figura 26 - Arquitetura de Cache
O Cache Provider utilizado para informar qual poltica de cache de segundo

nvel
ser
utilizada
na
aplicao.
Essa
poltica
definida
no
arquivo
hibernate.cfg.xml a partir da propriedade hibernate.cache.provider_class

e pode assumir algum dos valores abaixo:
EHCache
(org.hibernate.cache.EhCacheProvider):
gerenciamento de caches
usado
para
no escopo do processo. Possui uma
boa
documentao e fcil de configurar. Alm disso, suporta cache de

consultas que ser apresentado na prxima sesso;
OSCache
(org.hibernate.cache.OSCacheProvider):
usado
para
gerenciamento de caches no escopo do processo ou do cluster;
SwarmCache
(org.hibernate.cache.SwarmCacheProvider):
usado
para
gerenciamento de caches no escopo do cluster. No suporta cache de

consultas.
97
JBossCache
(org.hibernate.cache.TreeCacheProvider):
usado
para
gerenciamento de caches no escopo do cluster. um servio de replicao

por cluster transacional. Suporta cache de consultas.
19.2
Mapeando Cache
Quando se utiliza o segundo nvel de cache, importante utilizar uma
estratgia para gerenciar o nvel de concorrncia dos dados. A estratgia de

concorrncia uma mediadora, responsvel por armazenar e recuperar os dados
no cache. Com o Hibernate, possvel utilizar uma de quatro estratgias:
Transacional: utilizado em ambiente JTA (gerencivel) e para manter dados

em cache so mais consultados do que atualizados. Garante o nvel de
isolamento da transao at o nvel repeatable-read, em que o valor
mantido durante toda a transao.
Leitura/Escrita (Read-Write): utilizada se a aplicao precisar atualizar os

dados que esto em cache. No deve ser utilizada quando o nvel de
isolamento da transao for do tipo Serializable. Utilizado em ambientes que
no utilizam cluters.
Nonstrict Read-Write: utilizada se os dados em cache dificilmente sejam

atualizados, ou seja, se for quase que improvvel duas transaes
atualizarem o mesmo dado simultaneamente. importante tambm a
utilizao de um nvel rgido de isolamento da transao. No garante que o
estado do cache seja sincronizado com o do banco de dados;
Read-Only: utilizada se o cache for aplicado a dados da aplicao que

somente so lidos, ou seja, nunca so modificados. Estratgia simples,
segura em nvel de escopo de cluster e apresenta melhor performance.
A Tabela 5 apresenta quais nveis de cache so suportados por quais polticas

de cache.
98
Tabela 5 Polticas X Nveis de Cache
19.3 Utilizando o Cache
Toda vez que um objeto consultado no banco atravs do Hibernate e dos

mtodos get e load, o resultado da consulta armazenado no primeiro nvel de
chache, ou seja, no cache do objeto Session.
Considerando o exemplo presente no diagrama da Figura 27, onde objetos
da classe Categoria so atualizados na base de dados raramente. Ento, pode-se
utilizar cache na classe Categoria.
Figura 27 - Exemplo de Uso de Cache
99
Primeiramente, para exemplificar, considere o mapeamento da classe

Categoria apresentado na Listagem 96. Neste caso, a classe foi mapeada
considerando apenas o cache de primeiro nvel (habilitado por padro), ou seja,
mapeada utilizando as anotaes j apresentadas nesta apostila.
@Entity
@Table(schema = "anotacoes")
public class Categoria {
@Id
@SequenceGenerator(allocationSize = 1, name="SEQ")
@GeneratedValue(
strategy = GenerationType.AUTO,
generator = "SEQ")
private int id;

private String denominacao;
@OneToMany(mappedBy = "categoria", fetch = FetchType.LAZY)

private Collection<SubCategoria> subCategorias;

//...
}
Listagem 92 - Mapeamento de Cache
Considera-se o cdigo fonte apresentado na Listagem 93. Neste cdigo, um

objeto Categoria de valor de chave primria igual a 1 recuperado trs vezes do
banco de dados. Em cada recuperao, o objeto atribudo a trs objetos
diferentes Categoria cat1, Categoria cat2 e Categoria cat3, onde cat1 e cat2
so recuperados dentro da mesma sesso, session1, e cat3 recuperado dentro
de uma outra sesso, session2, aberta aps o fechamento de session1.
//...
Session session1 = sf.openSession();

System.out.println("ABRIU SESSION 1\n");
System.out.println("Consulta cat1 (id = 1) -- Objeto session1 ");

Categoria cat1 = (Categoria) session1.get(Categoria.class, 1);
100

session1.close();
System.out.println("\nFECHOU SESSION 1\n");
System.out.println("ABRIU SESSION 2\n ");

Session session2 = sf.openSession();

session2.close();
System.out.println("\nFECHOU SESSION 2");
//...
Listagem 93 Exemplificando o Uso de Cache
A Listagem 94 apresenta o resultado aps a execuo do cdigo presente na

Listagem 93. Pode-se observar, que dentro da primeira sesso (session1), a
linha correspondete tabela categoria com valor de chave primria igual a 1
recuperada duas vezes (representado pelos objetos cat1 e cat2), porm o
Hibernate s faz a consulta no banco uma nica vez (representada por apenas um
SQL gerado durante a existncia de session1. Em seguida, a primeira sesso
fechada (session1.close()) e uma segunda sesso aberta (sessao2). Dessa
forma, quando necessrio consultar mais uma vez a linha na tabela categoria
que possui chave primria igual a 1, como a consulta est dentro de outra sesso,
um novo comando SQL gerado, j que at o momento no h cache para o
objeto Session session2.
ABRIU SESSION 1
Consulta cat1 (id = 1) -- Objeto session1

Hibernate: select categoria0_.id as id0_0_, categoria0_.denominacao as
denomina2_0_0_ from anotacoes.Categoria categoria0_
where categoria0_.id=?
101
FECHOU SESSION 1
ABRIU SESSION 2

Hibernate: select categoria0_.id as id0_0_, categoria0_.denominacao as
denomina2_0_0_ from anotacoes.Categoria categoria0_
FECHOU SESSION 2
Listagem 94 - Resultado da Execuo do Cdigo Presente na Listagem 93:
Cache em Primeiro Nvel
Para se utilizar o artifcio do cache em segundo nvel, ou seja, em nvel do

processo ou de cluster, necessrio habilit-lo quando se usa Hibernate. Para
exemplificar, ser utilizado o Provider EHCache, que mantm cache em nvel de
processo. Para isso, necessrio incluir o jar ehcache.jar no classpath da
aplicao.
Deve-se informar ao Hibernate que se est utilizando o cache de segundo
nvel, para isso, preciso incluir as linhas apresentadas na Listagem 95 no
arquivo de configurao hibernate.cfg.xml. A primeira propriedade habilita o
cache em segundo nvel, j a segunda, informa qual o provider utilizado.
<property name="cache.use_second_level_cache">true</property>
<property name="cache.provider_class">
net.sf.ehcache.hibernate.EhCacheProvider
</property>
Listagem 95 Configurando o Cache no Arquivo de Configurao *.cfg.xml
Feitas estas alteraes, preciso informar quais entidades tero suas

informaes armazenadas no cache de segundo nvel. Para isso, necessrio
inserir anotaes extras no mapeamento dessas entidades.
Para
exemplificar,
considera-se
mapeamento
de
cache
na
classe
Categoria, como mostrado na Listagem 96. Para isso, utiliza-se a anotao

@Cache, onde a estratgia para o nvel de isolamento definida pelo atributo
usage e pode assumir um dos seguintes valores:
102
CacheConcurrencyStrategy.NONE;
CacheConcurrencyStrategy.READ_WRITE;
CacheConcurrencyStrategy.READ_ONLY;
CacheConcurrencyStrategy.TRANSACTIONAL;
CacheConcurrencyStrategy.NONSTRICT_READ_WRITE.
@Entity
@Table(schema = "anotacoes")
@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
public class Categoria {
@Id
@SequenceGenerator(allocationSize = 1, name="SEQ")
@GeneratedValue(
strategy = GenerationType.AUTO,
generator = "SEQ")
private int id;

private String denominacao;
@OneToMany(mappedBy = "categoria", fetch = FetchType.LAZY)

@Cache(usage = CacheConcurrencyStrategy.READ_WRITE)
private Collection<SubCategoria> subCategorias;

//...
}
Listagem 96 - Mapeamento de Cache na Classe Categoria
Observa-se que a classe Categoria possui uma coleo de subcategorias

(atributo subCategorias). O cache no se extende a colees. Se for necessrio
aplicar cache tambm em seu contedo, deve-se tambm utilizar a anotao
@Cache no atributo que represente a coleo, como tambm foi feito na Listagem
96.
Alm de incluir as anotaes de cache nas classes, tambm necessrio
configurar as propriedades de classe para cada classe. Essa configurao feita em
um arquivo ehcache.xml que deve se encontrar no classpath da aplicao, como
apresentado na Listagem 97.
No caso, se for desejado configurar as propriedades de cache para todas as
classes anotadas com @Cache, preciso incluir essas propriedades na tag
103
<cache> no arquivo ehcache.xml. Se para alguma classe no for inserida esta

tag,
Hibernate
considerar
configurao
padro
definida
na
tag
<defaultCache>.
<ehcache>
<diskStore path="java.io.tmpdir"/>
<cache
name="br.com.jeebrasil.hibernate.anotacoes.dominio.Categoria"
maxElementsInMemory="500"
eternal="false"
timeToIdleSeconds="300"
timeToLiveSeconds="600"
overflowToDisk="false"
/>
<defaultCache
maxElementsInMemory="1000"
eternal="false"
timeToIdleSeconds="120"
timeToLiveSeconds="120"
overflowToDisk="true"
/>
</ehcache>
Listagem 97 Arquivo de Configurao ehcache.xml
Abaixo a explicao das configuraes presentes nas tags <cache> e

<defaultCache> no arquivo ehcache.xml:
maxElementsInMemory: nmero mximo permitido de objetos que

podem ficar armazenados em memria;
eternal: se configurado para true, significa que o cache nunca vai expirar;
timeToIdleSeconds: tempo em segundos que um objeto pode permanecer

inutilizado no cache;
timeToLiveSeconds: tempo em segundos que um objeto pode ficar em

cache;
104
overflowToDisk: se configurado para true e caso o limite de objetos em

memria
seja
superior
ao
definido
pela
propriedade
maxElementsInMemory, as informaes sero armazenadas em disco.
A configurao <diskStore path="java.io.tmpdir"/> informa em que local

sero armazenados os objetos se o nmero mximo permitido de objetos que
podem ficar armazenados em memria ultrapassar o definido na propriedade
maxElementsInMemory.
Para
esse
armazenamento,
propriedade
overflowToDisk deve ter sido configurada como true.

Para exemplificar, considere o resultado da execuo do cdigo presente na
Listagem 93 apresentado na Listagem 98. Observa-se que o cache de segundo
nvel foi considerado e apenas um comando SQL foi gerado dentro da primeira
sesso (session1) ao se consultar a categoria de chave primria igual a 1.
ABRIU SESSION 1

Hibernate: select categoria0_.id as id0_0_, categoria0_.denominacao
as denomina2_0_0_ from anotacoes.Categoria categoria0_
FECHOU SESSION 1
ABRIU SESSION 2
FECHOU SESSION 2
Listagem 98 - Resultado da Execuo do Cdigo Presente na Listagem 93:
Cache em Segundo Nvel
105

Apostila de Hibernate - 3

Enviado por

Dados do documento

Título original

Direitos autorais

Formatos disponíveis

Compartilhar este documento

Compartilhar ou incorporar documento

Opções de compartilhamento

Você considera este documento útil?

Este conteúdo é inapropriado?

Direitos autorais:

Formatos disponíveis

Apostila de Hibernate - 3

Enviado por

Direitos autorais:

Formatos disponíveis

Hibernate com

Natal, Maio de 2007

CONCEITOS GERAIS DE PERSISTNCIA .................................................................................4

MAPEAMENTO OBJETO RELACIONAL ...................................................................................4

INTRODUO AO HIBERNATE ........................................................................................8

SESSION (ORG.HIBERNATE.SESSION) .............................................................................................9

IDENTIDADE/IGUALDADE ENTRE OBJETOS..............................................................................12

OBJETOS PERSISTENTES, TRANSIENTES E DETACHED ..................................................14

COMO UTILIZAR O HIBERNATE ANNOTATION ...................................................................15

INTRODUO A ANOTAES (ANNOTATIONS) ..................................................................16

TIPOS DE ANOTAES SUPORTADAS PELO JAVA 5.0 ............................................................17

PRIMEIRO EXEMPLO COM HIBERNATE ANNOTATIONS ..................................................19

MANIPULANDO OBJETOS PERSISTENTES .......................................................................25

MAPEANDO ATRIBUTOS DA CLASSE .................................................................................29

13.1 ASSOCIAES 1-N (ONE-TO-MANY).............................................................................................32

DEFINIO DE CHAVE PRIMRIA UTILIZANDO UMA SEQNCIA PRPRIA .....55

TABELA POR HIERARQUIA ..........................................................................................................70

1. Conceitos Gerais de Persistncia

2. Mapeamento Objeto Relacional

Por vrios anos os projetos de aplicaes corporativas tiveram uma forte

mapeamento objeto relacional.

Mapeamento objeto relacional

com a transformao dos dados de um objeto em uma linha de uma tabela de um

Figura 1 - Exemplo de mapeamento de tipos bsicos

2.1.2 Mapeamento de objetos que contm uma coleo de objetos

Figura 2 - Relacionamento entre as classes Fabricante e Veiculo

ser implementado atravs de uma chave estrangeira (referncia a uma outra

Figura 3 Exemplo de mapeamento 1 para N

Com a idia do MOR vrios projetos de ferramenta comearam a ser

Interfaces responsveis por executar operaes de criao, deleo,

Interface utilizada pela aplicao para configurar o Hibernate:

Interfaces responsveis por realizar a interao entre os eventos do

Figura 4 - Arquitetura do Hibernate

De todas as interfaces apresentadas na Figura 4, as principais so: Session,

4.1 Session (org.hibernate.Session)

O objeto SessionFactory aquele que mantm o mapeamento objeto

4.3 Configuration (org..hibernate.Configuration)

Hibernate, como por exemplo: o driver do banco de dados a ser utilizado, o

4.4 Transaction (org.hibernate.Transaction)

A interface Transaction utilizada para representar uma unidade indivisvel

4.5 Interfaces Criteria e Query

public class Pessoa {

private int id;

public int getId() { return id; }

public long getCpf(){ return cpf; }

public Date getDataNascimento() { return dataNascimento; }

public String getNome () { return nome; }

public int getIdade(){ return idade;

O Hibernate requer que toda classe persistente possua um construtor

Observe que a classe Pessoa apresenta mtodos setters e getters

A classe Pessoa possui um atributo id que o seu identificador

independentes da lgica de negcio da aplicao.

5.1 Identidade/Igualdade entre Objetos

Em aplicaes Java, a identidade entre objetos pode ser obtida a partir do

5.2 Escolhendo Chaves Primrias

Um passo importante ao utilizar o Hibernate inform-lo sobre a estratgia

satisfazer as seguintes propriedades:

Nunca ser nula;

Tabela 1 - Mecanismo de Gerao de Chaves Primrias

Mapeado para colunas identity no DB2, MySQL, MSSQL, Sybase,

Mapeado em seqncias no DB2, PostgreSQL, Oracle, SAP DB,

L o valor mximo da chave primria e incrementa um. Deve ser

Usa algoritmo high/low para gerao de chaves nicas.