Algaworks Ebook Jpa e Hibernate 1a Edicao 20150731

JPA e Hibernate
por Thiago Faria e Normandes Junior

1 Edio, 31/07/2015
2015 AlgaWorks Softwares, Treinamentos e Servios Ltda. Todos os direitos

reservados.
Nenhuma parte deste livro pode ser reproduzida ou transmitida em qualquer
forma, seja por meio eletrnico ou mecnico, sem permisso por escrito da
AlgaWorks, exceto para resumos breves em revises e anlises.
AlgaWorks Softwares, Treinamentos e Servios Ltda
www.algaworks.com
contato@algaworks.com
+55 (11) 2626-9415
Siga-nos nas redes sociais e fique por dentro de tudo!
Sobre os autores
Thiago Faria de Andrade
Fundador, instrutor e consultor da AlgaWorks.
Graduado em Sistemas de Informao e certificado
como programador Java pela Sun. Iniciou seu
interesse por programao em 1995, quando
desenvolveu um software para entretenimento e se
tornou um dos mais populares no Brasil e outros
pases de lngua portuguesa. J foi scio e trabalhou em outras empresas de
software como programador, gerente e diretor de tecnologia, mas nunca deixou
de programar.
LinkedIn: https://www.linkedin.com/in/thiagofa
Normandes Jos Moreira Junior

Scio e instrutor da AlgaWorks, formado em
Engenharia Eltrica pela Universidade Federal de
Uberlndia e detentor das certificaes LPIC-1, SCJP
e SCWCD. Palestrante internacional reconhecido por
contribuir e liderar projetos open source.
LinkedIn: https://www.linkedin.com/in/normandesjr
Antes de comear...
Antes que voc comece a ler esse livro, ns gostaramos de combinar algumas
coisas com voc, para que tenha um excelente aproveitamento do contedo.
Vamos l?
O que voc precisa saber?

Voc s conseguir absorver o contedo desse livro se j conhecer pelo menos o
bsico de SQL e Java e Orientao a Objetos. Caso voc ainda no domine Java e
OO, pode ser interessante estudar por nosso curso online.
Como obter ajuda?

Durante os seus estudos, temos certeza de uma coisa: voc vai ter muitas dvidas
e problemas para resolver!
Ns gostaramos muito de te ajudar pessoalmente nesses problemas e sanar todas
as suas dvidas, mas infelizmente no conseguimos fazer isso com todos os
leitores do livro, afinal, ocupamos grande parte do dia ajudando os nossos alunos
de cursos online na AlgaWorks.
Ento, quando voc tiver alguma dvida e no conseguir encontrar a soluo no
Google ou com seu prprio conhecimento, nossa recomendao que voc poste
no StackOverflow em portugus. s acessar:
http://pt.stackoverflow.com/
Para aumentar as chances de receber uma resposta para seu problema, veja
algumas dicas:
http://pt.stackoverflow.com/help/how-to-ask
Ao perguntar sobre um problema no seu cdigo, voc conseguir melhores
respostas se mostrar s pessoas cdigo que elas possam usar para reproduzir o
problema. Veja algumas recomendaes no link a seguir:
http://pt.stackoverflow.com/help/mcve
Voc tambm pode ajudar outras pessoas com o conhecimento que adquiriu,
assim todos sero ajudados de alguma forma.
Comunidade Java da AlgaWorks no Facebook

Outra forma de obter ajuda, contribuir com o seu conhecimento e manter contato
com outros programadores Java ingressando na Comunidade Java da
AlgaWorks (Facebook). Acesse:
http://alga.works/comunidade-java-algaworks/
Como sugerir melhorias ou reportar erros no livro?

Se voc encontrar algum erro no contedo desse livro ou se tiver alguma
sugesto para melhorar a prxima edio, vamos ficar muito felizes se voc
puder nos dizer.
Envie um e-mail para livros@algaworks.com.
Ajude na continuidade desse trabalho

Escrever um livro como esse d muito trabalho, por isso, esse projeto s faz
sentido se muitas pessoas tiverem acesso a ele.
Ajude a divulgar esse livro para seus amigos que tambm se interessam por
programao Java. Compartilhe no Facebook e Twitter!
Sumrio
1 Introduo
1.1
O que persistncia? ................................................................................. 13
1.2
Mapeamento Objeto Relacional (ORM) .................................................. 13
1.3
Porque usar ORM? ..................................................................................... 15
1.4
Java Persistence API e Hibernate ............................................................. 16
2 Primeiros passos com JPA e Hibernate

2.1
Download e configurao do Hibernate ORM ...................................... 17
2.2
Criao do Domain Model ....................................................................... 19
2.3
Implementao do equals() e hashCode() .............................................. 21
2.4
Mapeamento bsico ................................................................................... 22
2.5
O arquivo persistence.xml ........................................................................ 24
2.6
Gerando as tabelas do banco de dados ................................................... 26
2.7
Definindo detalhes fsicos de tabelas ...................................................... 27
2.8
Criando EntityManager ............................................................................ 30
2.9
Persistindo objetos ..................................................................................... 31
2.10 Buscando objetos pelo identificador ....................................................... 34

2.11 Listando objetos ......................................................................................... 36
2.12 Atualizando objetos ................................................................................... 38
2.13 Excluindo objetos ....................................................................................... 40
3 Gerenciando estados
3.1
Estados e ciclo de vida .............................................................................. 42
3.2
Contexto de persistncia ........................................................................... 44
3.3
Sincronizao de dados ............................................................................. 46
3.4
Salvando objetos desanexados com merge() ......................................... 49
4 Mapeamento
4.1
Identificadores ............................................................................................ 52
4.2
Chaves compostas ...................................................................................... 54
4.3
Enumeraes ............................................................................................... 57
4.4
Propriedades temporais ............................................................................ 58
4.5
Propriedades transientes .......................................................................... 59
4.6
Objetos grandes .......................................................................................... 60
4.7
Objetos embutidos ..................................................................................... 64
4.8
Associaes um-para-um .......................................................................... 67
4.9
Associaes muitos-para-um ................................................................... 75
4.10 Colees um-para-muitos ......................................................................... 77

4.11 Colees muitos-para-muitos .................................................................. 79
4.12 Colees de tipos bsicos e objetos embutidos ...................................... 85
4.13 Herana ....................................................................................................... 90
4.14 Modos de acesso ...................................................................................... 101
5 Recursos avanados
5.1
Lazy loading e eager loading ................................................................. 105
5.2
Operaes em cascata .............................................................................. 113
5.3
Excluso de objetos rfos ...................................................................... 117
5.4
Operaes em lote .................................................................................... 118
5.5
Concorrncia e locking ............................................................................ 121
5.6
Mtodos de callback e auditores de entidades .................................... 125
5.7
Cache de segundo nvel .......................................................................... 129
6 Java Persistence Query Language

6.1
Introduo JPQL ................................................................................... 134
6.2
Consultas simples e iterao no resultado ........................................... 140
6.3
Usando parmetros nomeados .............................................................. 141
6.4
Consultas tipadas ..................................................................................... 142
6.5
Paginao .................................................................................................. 142
6.6
Projees .................................................................................................... 144
6.7
Resultados complexos e o operador new ............................................. 146
6.8
Funes de agregao .............................................................................. 147
6.9
Queries que retornam um resultado nico .......................................... 148
6.10 Associaes e joins ................................................................................... 149

6.11 Queries nomeadas ................................................................................... 154
6.12 Queries SQL nativas ................................................................................ 156
7 Criteria API
7.1
Introduo e estrutura bsica ................................................................. 158
7.2
Filtros e queries dinmicas ..................................................................... 159
7.3
Projees .................................................................................................... 162
7.4
Funes de agregao .............................................................................. 162
7.5
Resultados complexos, tuplas e construtores ...................................... 163
7.6
Funes ...................................................................................................... 165
7.7
Ordenao de resultado .......................................................................... 166
7.8
Join e fetch ................................................................................................. 167
7.9
Subqueries ................................................................................................. 168
7.10 Metamodel ................................................................................................ 170
8 Concluso
8.1
Prximos passos ....................................................................................... 172
Captulo 1
Introduo
1.1. O que persistncia?
A maioria dos sistemas desenvolvidos em uma empresa precisa de dados
persistentes, portanto persistncia um conceito fundamental no
desenvolvimento de aplicaes. Se um sistema de informao no preservasse os
dados quando ele fosse encerrado, o sistema no seria prtico e usual.
Quando falamos de persistncia de dados com Java, normalmente falamos do
uso de sistemas gerenciadores de banco de dados relacionais e SQL, porm
existem diversas outras alternativas para persistir dados, como em arquivos
XML, arquivos texto e etc.
1.2. Mapeamento Objeto Relacional (ORM)

Mapeamento objeto relacional (object-relational mapping, ORM, O/RM ou O/R
mapping) uma tcnica de programao para converso de dados entre banco
de dados relacionais e linguagens de programao orientada a objetos.
Em banco de dados, entidades so representadas por tabelas, que possuem
colunas que armazenam propriedades de diversos tipos. Uma tabela pode se
associar com outras e criar relacionamentos diversos.
www.algaworks.com
13
Em uma linguagem orientada a objetos, como Java, entidades so classes, e

objetos dessas classes representam elementos que existem no mundo real.
Por exemplo, um sistema de faturamento possui a classe NotaFiscal, que no
mundo real existe e todo mundo j viu alguma pelo menos uma vez, alm de
possuir uma classe que pode se chamar Imposto. Essas classes so chamadas
de classes de domnio do sistema, pois fazem parte do negcio que est sendo
desenvolvido.
Em banco de dados, podemos ter as tabelas nota_fiscal e tambm imposto, mas
a estrutura de banco de dados relacional est longe de ser orientado a objetos, e
por isso a ORM foi inventada para suprir a necessidade que os desenvolvedores
tm de visualizar tudo como objetos para programarem com mais facilidade.
Podemos comparar o modelo relacional com o modelo orientado a objetos
conforme a tabela abaixo:
Modelo relacional
Modelo OO
Tabela
Classe
Linha
Objeto
Coluna
Atributo
Mtodo
Chave estrangeira
Associao
Essa comparao feita em todo o tempo quando estamos desenvolvendo

usando algum mecanismo de ORM. O mapeamento feito usando metadados
que descrevem a relao entre objetos e banco de dados.
Uma soluo ORM consiste de uma API para executar operaes CRUD simples
em objetos de classes persistentes, uma linguagem ou API para especificar
queries que se referem a classes e propriedades de classes, facilidades para
especificar metadados de mapeamento e tcnicas para interagir com objetos
www.algaworks.com
14
transacionais para identificarem automaticamente alteraes realizadas,

carregamento de associaes por demanda e outras funes de otimizao.
Em um ambiente ORM, as aplicaes interagem com APIs e o modelo de classes
de domnio e os cdigos SQL/JDBC so abstrados. Os comandos SQL so
automaticamente gerados a partir dos metadados que relacionam objetos a banco
de dados.
1.3. Porque usar ORM?

Apesar de no parecer, uma implementao ORM mais complexa que outro
framework qualquer para desenvolvimento web, porm os benefcios de
desenvolver utilizando esta tecnologia so grandes.
Cdigos de acesso a banco de dados com queries SQL so chatos de escrever.
JPA elimina muito do trabalho e deixa voc se concentrar na lgica de negcio,
possibilitando uma produtividade imensa para voc.
A manutenabilidade de sistemas desenvolvidos com ORM excelente, pois o
mecanismo faz com que menos linhas de cdigo sejam necessrias. Alm de
facilitar o entendimento, menos linhas de cdigo deixam o sistema mais fcil de
ser alterado.
Existem outras razes que fazem com que um sistema desenvolvido utilizando
JPA seja melhor de ser mantido. Em sistemas com a camada de persistncia
desenvolvida usando JDBC e SQL, existe um trabalho na implementao para
representar tabelas como objetos de domnio, e alteraes no banco de dados ou
no modelo de domnio geram um esforo de readequao que pode custar caro.
ORM abstrai sua aplicao do banco de dados e do dialeto SQL. Com JPA,
voc pode desenvolver um sistema usando um banco de dados e coloc-lo em
produo usando diversos outros bancos de dados, sem precisar alterar cdigosfontes para adequar sintaxe de queries que s funcionam em SGBDs de
determinados fornecedores.
www.algaworks.com
15
1.4. Java Persistence API e Hibernate

A Java Persistence API (JPA) um framework para persistncia em Java, que
oferece uma API de mapeamento objeto-relacional e solues para integrar
persistncia com sistemas corporativos escalveis.
Com JPA, os objetos so POJO (Plain Old Java Objects), ou seja, no necessrio
nada de especial para tornar os objetos persistentes. Basta adicionar algumas
anotaes nas classes que representam as entidades do sistema e comear a
persistir ou consultar objetos.
JPA uma especificao, e no um produto. Para trabalhar com JPA, precisamos
de uma implementao.
O projeto do Hibernate ORM possui alguns mdulos, sendo que o Hibernate
EntityManager a implementao da JPA que encapsula o Hibernate Core.
O Hibernate Core a base para o funcionamento da persistncia, com APIs
nativas e metadados de mapeamentos em arquivos XML, uma linguagem de
consultas chamada HQL (parecido com SQL), um conjunto de interfaces para
consultas usando critrios (Criteria API), etc.
www.algaworks.com
16
Captulo 2
Primeiros passos com JPA e

Hibernate
2.1. Download e configurao do Hibernate ORM
Antes de criarmos um projeto, precisamos fazer o download do Hibernate ORM
no site www.hibernate.org. O arquivo fornecido no site possui todos os mdulos
e dependncias necessrias.
www.algaworks.com
17
Depois de concluir o download, descompacte o arquivo em um diretrio

temporrio.
Crie um novo projeto no Eclipse do tipo Java Project e crie uma pasta dentro
dele chamada lib, para que possamos colocar os JARs necessrios.
Copie todos os arquivos das pastas required e jpa para a pasta lib do
projeto.
Estas bibliotecas que voc acabou de copiar fazem parte da distribuio do
Hibernate ORM e so obrigatrias para seu funcionamento. As demais so
requeridas apenas para casos especficos.
Como usaremos o MySQL neste livro, precisaremos colocar tambm o driver
JDBC do MySQL na pasta lib. Baixe em http://dev.mysql.com/downloads/
connector/j/.
Agora que temos todas as bibliotecas necessrias na pasta lib do projeto,
precisamos adicon-las ao Build Path do projeto. Encontre e selecione todos os
arquivos JAR que esto dentro do seu projeto no Eclipse, clique com o boto
direito, acesse a opo Build Path e Add to Build Path.
Seu projeto deve ficar com as seguintes bibliotecas referenciadas:
www.algaworks.com
18
2.2. Criao do Domain Model

Em nosso projeto de exemplo, queremos gravar e consultar informaes de
veculos de uma concessionria no banco de dados. Antes de qualquer coisa,
precisamos criar nosso modelo de domnio para o negcio em questo.
Inicialmente, nosso sistema possuir uma classe simples chamada
representa o veculo venda pela concessionria.
Veiculo,
que
package com.algaworks.veiculos.dominio;
import java.math.BigDecimal;
public class Veiculo {
private Long codigo;
private String fabricante;
private String modelo;
private Integer anoFabricacao;
private Integer anoModelo;
private BigDecimal valor;
public Long getCodigo() {
return codigo;
}
public void setCodigo(Long codigo) {
this.codigo = codigo;
}
public String getFabricante() {
return fabricante;
}
public void setFabricante(String fabricante) {
this.fabricante = fabricante;
}
public String getModelo() {
return modelo;
}
www.algaworks.com
19
public void setModelo(String modelo) {

this.modelo = modelo;
}
public Integer getAnoFabricacao() {
return anoFabricacao;
}
public void setAnoFabricacao(Integer anoFabricacao) {
this.anoFabricacao = anoFabricacao;
}
public Integer getAnoModelo() {
return anoModelo;
}
public void setAnoModelo(Integer anoModelo) {
this.anoModelo = anoModelo;
}
public BigDecimal getValor() {
return valor;
}
public void setValor(BigDecimal valor) {
this.valor = valor;
}
}
A classe Veiculo possui os seguintes atributos:
codigo:
identificador nico do veculo

fabricante: nome do fabricante do veculo
modelo: descrio do modelo do veculo
anoFabricacao: nmero do ano de fabricao do veculo
anoModelo: nmero do ano do modelo do veculo
valor: valor que est sendo pedido para venda do veculo
O atributo identificador (chamado de codigo) referente chave primria da

tabela de veculos no banco de dados. Se existirem duas instncias de Veiculo
com o mesmo identificador, eles representam a mesma linha no banco de dados.
www.algaworks.com
20
As classes persistentes devem seguir o estilo de JavaBeans, com mtodos getters e

setters. obrigatrio que esta classe possua um construtor sem argumentos.
Como voc pode ver, a classe persistente Veiculo um POJO, o que significa que
podemos instanci-la sem necessidade de containeres especiais.
Observao: nas sees e captulos seguintes, podemos desenvolver novos
exemplos para o projeto da concessionria, sem acumular todos os recursos
estudados, para no dificultar o entendimento de cada um desses recursos.
2.3. Implementao do equals() e hashCode()

Para que os objetos persistentes sejam diferenciados uns de outros, precisamos
implementar os mtodos equals() e hashCode().
No banco de dados, as chaves primrias diferenciam registros distintos. Quando
mapeamos uma entidade de uma tabela, devemos criar os mtodos equals()
e hashCode(), levando em considerao a forma em que os registros so
diferenciados no banco de dados.
O Eclipse possui um gerador desses mtodos que usa uma propriedade (ou
vrias, informadas por voc) para criar o cdigo-fonte. Veja como deve ficar a
implementao dos mtodos para a entidade Veiculo.
@Override
public int hashCode() {
final int prime = 31;
int result = 1;
result = prime * result + ((codigo == null) ? 0 : codigo.hashCode());
return result;
}
@Override
public boolean equals(Object obj) {
if (this == obj)
return true;
if (obj == null)
return false;
if (getClass() != obj.getClass())
www.algaworks.com
21
return false;
final Veiculo other = (Veiculo) obj;
if (codigo == null) {
if (other.codigo != null)
return false;
} else if (!codigo.equals(other.codigo))
return false;
return true;
}
Agora o Hibernate conseguir comparar objetos para descobrir se so os mesmos.
Qual a real importncia dos mtodos equals e hashCode??

Entender os motivos por trs da implementao desses mtodos muito
importante. Assista uma vdeo aula gratuita sobre esse assunto no nosso
blog.
http://blog.algaworks.com/entendendo-o-equals-e-hashcode/
2.4. Mapeamento bsico

Para que o mapeamento objeto/relacional funcione, precisamos informar
implementao do JPA mais informaes sobre como a classe Veiculo deve se
tornar persistente, ou seja, como instncias dessa classe podem ser gravadas
e consultadas no banco de dados. Para isso, devemos anotar os getters ou os
atributos, alm da prpria classe.
import javax.persistence.Entity;
import javax.persistence.GeneratedValue;
import javax.persistence.GenerationType;
import javax.persistence.Id;
@Entity
www.algaworks.com
22

@Id
@GeneratedValue
return codigo;
}
}
return fabricante;
}
}
return modelo;
}
}
}
}
return anoModelo;
www.algaworks.com
23
}
}
return valor;
}
this.valor = valor;
}
// equals e hashCode
}
Voc deve ter percebido que as anotaes foram importadas do pacote

javax.persistence. Dentro desse pacote esto todas as anotaes padronizadas
pela JPA.
A anotao @Entity diz que a classe uma entidade, que representa uma tabela
do banco de dados.
As anotaes nos mtodos getters configuram a relao dos atributos da classe
com as colunas do banco de dados. As anotaes @Id e @GeneratedValue so
usadas para declarar o identificador do banco de dados, e esse identificador deve
ter um valor gerado no momento de insero (auto-incremento).
2.5. O arquivo persistence.xml

O persistence.xml um arquivo de configurao padro da JPA. Ele deve ser
criado no diretrio META-INF da aplicao ou do mdulo que contm os beans
de entidade.
O arquivo persistence.xml define unidades de persistncia, conhecidas como
persistence units.
www.algaworks.com
24
<?xml version="1.0" encoding="UTF-8"?>

<persistence version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
<persistence-unit name="AlgaWorksPU">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost/ebook-jpa" />
<property name="javax.persistence.jdbc.user"
value="usuario" />
<property name="javax.persistence.jdbc.password"
value="senha" />
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver" />
<property name="hibernate.dialect"
value="org.hibernate.dialect.MySQL5Dialect" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="update" />
</properties>
</persistence-unit>
</persistence>
O nome da unidade de persistncia foi definido como AlgaWorksPU. Precisaremos

desse nome daqui a pouco, quando formos colocar tudo para funcionar.
O provider diz qual a implementao que ser usada como provedor de
persistncia.
Existem vrias opes de configurao que podem ser informadas neste arquivo
XML. Vejamos as principais propriedades que usamos em nosso arquivo de
configurao:
javax.persistence.jdbc.url:
descrio da URL de conexo com o banco
de dados
www.algaworks.com
25
javax.persistence.jdbc.driver:
nome completo da classe do driver
JDBC
javax.persistence.jdbc.user:
nome do usurio do banco de dados

senha do usurio do banco de dados
hibernate.dialect: dialeto a ser usado na construo de comandos SQL
hibernate.show_sql: informa se os comandos SQL devem ser exibidos na
console (importante para debug, mas deve ser desabilitado em ambiente
de produo)
hibernate.format_sql: indica se os comandos SQL exibidos na console
devem ser formatados (facilita a compreenso, mas pode gerar textos
longos na sada)
hibernate.hbm2ddl.auto: cria ou atualiza automaticamente a estrutura
das tabelas no banco de dados
javax.persistence.jdbc.password:
2.6. Gerando as tabelas do banco de dados

Como ainda no temos a tabela representada pela classe
dados, precisamos cri-la.
O
Hibernate
pode
hibernate.hbm2ddl.auto
Veiculo
fazer isso pra gente, graas

com valor update, que inclumos
no banco de
propriedade
no arquivo
persistence.xml.
Precisamos apenas criar um EntityManagerFactory, que todas as tabelas
mapeadas pelas entidades sero criadas ou atualizadas.
import javax.persistence.Persistence;
public class CriaTabelas {
public static void main(String[] args) {
Persistence.createEntityManagerFactory("AlgaWorksPU");
}
}
www.algaworks.com
26
O parmetro do mtodo createEntityManagerFactory deve ser o mesmo nome

que informamos no atributo name da tag persistence-unit, no arquivo
persistence.xml.
Ao executar o cdigo, a tabela Veiculo criada.
...
Jul 11, 2015 1:27:19 AM org.hibernate.tool.hbm2ddl.SchemaUpdate execute
INFO: HHH000228: Running hbm2ddl schema update
INFO: HHH000102: Fetching database metadata
INFO: HHH000396: Updating schema
Jul 11, 2015 1:27:19 AM org.hibernate.tool.hbm2ddl.DatabaseMetadata [...]
INFO: HHH000262: Table not found: Veiculo
INFO: HHH000232: Schema update complete
2.7. Definindo detalhes fsicos de tabelas

A estrutura da tabela que foi criada no banco de dados bastante simples.
Veja que todas as propriedades com getters foram mapeadas automaticamente,
mesmo sem incluir qualquer anotao JPA.
Com exceo da chave primria, todas as colunas aceitam valores nulos e as
colunas fabricante e modelo aceitam at 255 caracteres.
www.algaworks.com
27
Podemos definir melhor estes detalhes fsicos no mapeamento de nossa entidade.

Alm disso, queremos que nomes de colunas usem underscore na separao de
palavras, que o nome da tabela seja tab_veiculo e a preciso da coluna valor seja
10, com 2 casas decimais.
import javax.persistence.Column;
import javax.persistence.Entity;
import javax.persistence.Table;
@Entity
@Table(name = "tab_veiculo")
@Id
@GeneratedValue
return codigo;
}
}
@Column(length = 60, nullable = false)
return fabricante;
}
}
www.algaworks.com
28

return modelo;
}
}
@Column(name = "ano_fabricacao", nullable = false)
}
}
@Column(name = "ano_modelo", nullable = false)
return anoModelo;
}
}
@Column(precision = 10, scale = 2, nullable = true)
return valor;
}
this.valor = valor;
}
// equals e hashCode
}
Podemos executar o cdigo main anterior, que cria um EntityManagerFactory, e a

nova tabela ser gerada.
www.algaworks.com
29
A tabela antiga, chamada Veiculo, no ser excluda. Voc precisar fazer isso na
mo, se quiser elimin-la.
Agora, vamos analisar as alteraes que fizemos individualmente.
Especificamos o nome da tabela como tab_veiculo. Se no fizermos isso, o nome

da tabela ser considerado o mesmo nome da classe.
Definimos o tamanho da coluna com 60 e com restrio not null.

Especificamos o nome da coluna como ano_fabricacao e com restrio not null. Se

o nome da coluna no for especificado, por padro, ela receber o mesmo nome
do atributo mapeado.
Atribumos a preciso de 10 com escala de 2 casas na coluna de nmero decimal,

especificando, ainda, que ela pode receber valores nulos.
2.8. Criando EntityManager

Os sistemas que usam JPA precisam de apenas uma instncia de
EntityManagerFactory,
que pode ser criada durante a inicializao da aplicao.

Esta nica instncia pode ser usada por qualquer cdigo que queira obter um
EntityManager.
Um EntityManager responsvel por gerenciar entidades no contexto de

persistncia (que voc aprender mais a frente). Atravs dos mtodos dessa
interface, possvel persistir, pesquisar e excluir objetos do banco de dados.
www.algaworks.com
30
A inicializao de EntityManagerFactory pode demorar alguns segundos, por isso

a instncia dessa interface deve ser compartilhada na aplicao.
Precisaremos de um lugar para colocar a instncia compartilhada de
EntityManagerFactory, onde qualquer cdigo tenha acesso fcil e rpido.
Criaremos a classe JpaUtil para armazenar a instncia em uma varivel esttica.
import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Persistence;
public class JpaUtil {
private static EntityManagerFactory factory;
static {
factory = Persistence.createEntityManagerFactory("AlgaWorksPU");
}
public static EntityManager getEntityManager() {
return factory.createEntityManager();
}
public static void close() {
factory.close();
}
}
Criamos um bloco esttico para inicializar a fbrica de Entity Manager. Isso

ocorrer apenas uma vez, no carregamento da classe. Agora, sempre que
precisarmos de uma EntityManager, podemos chamar:
EntityManager manager = JpaUtil.getEntityManager();
2.9. Persistindo objetos

Chegou a hora de persistir objetos, ou seja, inserir registros no banco de dados.
www.algaworks.com
31
O cdigo abaixo deve inserir um novo veculo na tabela do banco de dados. Se

no funcionar, no se desespere, volte nos passos anteriores e encontre o que voc
fez de errado.
import javax.persistence.EntityTransaction;
public class PersistindoVeiculo {
EntityTransaction tx = manager.getTransaction();
tx.begin();
Veiculo veiculo = new Veiculo();
veiculo.setFabricante("Honda");
veiculo.setModelo("Civic");
veiculo.setAnoFabricacao(2012);
veiculo.setAnoModelo(2013);
veiculo.setValor(new BigDecimal(71300));
manager.persist(veiculo);
tx.commit();
manager.close();
JpaUtil.close();
}
}
Execute a classe InsercaoVeiculos e veja a sada no console.

Hibernate:
insert
into
tab_veiculo
(ano_fabricacao, ano_modelo, fabricante, modelo, valor)
values
(?, ?, ?, ?, ?)
O Hibernate gerou o SQL de insero e nos mostrou na sada, pois configuramos

isso no arquivo persistence.xml.
www.algaworks.com
32
Consulte os dados da tabela tab_veiculo usando qualquer ferramenta de

gerenciamento do seu banco de dados e veja que as informaes que definimos
nos atributos da instncia do veculo, atravs de mtodos setters, foram
armazenadas.
Agora vamos entender o que cada linha significa.

O cdigo abaixo obtm um EntityManager da classe JpaUtil.
Agora iniciamos uma nova transao.

tx.begin();
Instanciamos um novo veculo e atribumos alguns valores, chamando os

mtodos setters.
veiculo.setValor(new BigDecimal(71300));
Executamos o mtodo persist, passando o veculo como parmetro. Isso far

com que o JPA insira o objeto no banco de dados. No informamos o cdigo
do veculo, porque ele ser obtido automaticamente atravs do auto-increment do
MySQL.
Agora fazemos commit da transao, para efetivar a insero do veculo no banco

de dados.
tx.commit();
www.algaworks.com
33
Finalmente, fechamos o EntityManager
e o EntityManagerFactory.
manager.close();
JpaUtil.close();
Viu? Nenhum cdigo SQL e JDBC! Trabalhamos apenas com classes, objetos e a
API de JPA.
2.10. Buscando objetos pelo identificador

Podemos recuperar objetos atravs do identificador (chave primria) da
entidade. O cdigo abaixo busca um veculo com o cdigo igual a 1.
public class BuscandoVeiculo1 {
Veiculo veiculo = manager.find(Veiculo.class, 1L);
System.out.println("Veculo de cdigo " + veiculo.getCodigo()
+ " um " + veiculo.getModelo());
manager.close();
JpaUtil.close();
}
}
O resultado na console o seguinte:

Hibernate:
select
veiculo0_.codigo as codigo1_0_0_,
veiculo0_.ano_fabricacao as ano_fabr2_0_0_,
veiculo0_.ano_modelo as ano_mode3_0_0_,
veiculo0_.fabricante as fabrican4_0_0_,
veiculo0_.modelo as modelo5_0_0_,
veiculo0_.valor as valor6_0_0_
from
tab_veiculo veiculo0_
www.algaworks.com
34
where
veiculo0_.codigo=?
Veculo de cdigo 1 um Civic
Veja que o SQL gerado possui a clusula where, para filtrar apenas o veculo de
cdigo igual a 1.
Podemos tambm buscar um objeto pelo identificador usando o mtodo
getReference.
Veiculo veiculo = manager.getReference(Veiculo.class, 1L);
manager.close();
JpaUtil.close();
}
}
O resultado na console o mesmo, deixando a impresso que os mtodos find

e getReference fazem a mesma coisa, mas na verdade, esses mtodos possuem
comportamentos um pouco diferentes.
O mtodo
busca o objeto imediatamente no banco de dados, enquanto

s executa o SQL quando o primeiro mtodo getter for chamado,
find
getReference
desde que no seja o getCodigo.

Veja esse exemplo:
Veiculo veiculo = manager.getReference(Veiculo.class, 1L);
System.out.println("Buscou veculo. Ser que j executou o SELECT?");
www.algaworks.com
35

manager.close();
JpaUtil.close();
}
}
A execuo do cdigo exibe na sada:

Buscou veculo. Ser que j executou o SELECT?
Hibernate:
select
from
where
veiculo0_.codigo=?
Veculo de cdigo 1 um Civic
Note que o SQL foi executado apenas quando um getter foi invocado, e no na
chamada de getReference.
2.11. Listando objetos

Agora, voc ir aprender como fazer consultas simples de entidades com a
linguagem JPQL (Java Persistence Query Language). Aprofundaremos um pouco
mais nessa linguagem em outro captulo, porm j usaremos o bsico para
conseguirmos consultar no banco de dados.
A JPQL uma extenso da SQL, porm com caractersticas da orientao a
objetos. Com essa linguagem, no referenciamos tabelas do banco de dados, mas
apenas entidades de nosso modelo, que foram mapeadas para tabelas.
www.algaworks.com
36
Quando fazemos pesquisas em objetos, no precisamos selecionar as colunas do

banco de dados, como o caso da SQL. O cdigo em SQL a seguir:
select * from veiculo
Fica da seguinte forma em JPQL:

from Veiculo
A sintaxe acima em JPQL significa que queremos buscar os objetos persistentes

da classe Veiculo.
Antes de ver como fica no cdigo Java, insira outros veculos na tabela para que
os testes fiquem mais interessantes.
import java.util.List;
import javax.persistence.Query;
public class ListandoVeiculos {
Query query = manager.createQuery("from Veiculo");
List<Veiculo> veiculos = query.getResultList();
for (Veiculo veiculo : veiculos) {
System.out.println(veiculo.getCodigo() + " - "
+ veiculo.getFabricante() + " "
+ veiculo.getModelo() + ", ano "
+ veiculo.getAnoFabricacao() + "/"
+ veiculo.getAnoModelo() + " por "
+ "R$" + veiculo.getValor());
}
manager.close();
JpaUtil.close();
}
}
O resultado na console foi o seguinte:

www.algaworks.com
37
Hibernate:
select
veiculo0_.codigo as codigo1_0_,
veiculo0_.ano_fabricacao as ano_fabr2_0_,
veiculo0_.ano_modelo as ano_mode3_0_,
veiculo0_.fabricante as fabrican4_0_,
veiculo0_.modelo as modelo5_0_,
veiculo0_.valor as valor6_0_
from
1 - Honda Civic, ano 2012/2013 por R$71300.00
2 - GM Corsa Sedan, ano 2005/2005 por R$16500.00
3 - VW Gol, ano 2009/2009 por R$21000.00
A consulta SQL foi gerada baseada nas informaes do mapeamento, e todos os

veculos da tabela foram listados.
A nica novidade no cdigo-fonte que usamos so as seguintes linhas:
Query query = manager.createQuery("from Veiculo");
Veja que criamos uma query com a JPQL e armazenamos em uma varivel query.
Depois, executamos o mtodo getResultList desse objeto e obtemos uma lista de
veculos.
As IDEs, como o Eclipse, podem mostrar um alerta de Type safety em
query.getResultList(). Por enquanto voc pode ignorar isso, porque em breve
voc vai aprender sobre TypedQuery.
2.12. Atualizando objetos

Os atributos de entidades podem ser manipulados atravs dos mtodos setters,
e todas as alteraes sero detectadas e persistidas automaticamente, quando o
contexto de persistncia for descarregado para o banco de dados.
Vamos a um exemplo:
www.algaworks.com
38
public class AtualizandoVeiculo {

tx.begin();
System.out.println("Valor atual: " + veiculo.getValor());
veiculo.setValor(veiculo.getValor().add(new BigDecimal(500)));
System.out.println("Novo valor: " + veiculo.getValor());
tx.commit();
manager.close();
JpaUtil.close();
}
}
O cdigo acima executa o comando select no banco de dados para buscar o

veculo de cdigo 1, imprime o valor atual do veculo, atribui um novo valor
(soma 500,00 reais) e imprime um novo valor.
Veja que no precisamos chamar nenhum mtodo para a atualizao no banco
de dados. A alterao foi identificada automaticamente e refletida no banco de
dados, atravs do comando update.
A sada abaixo foi apresentada na console:
Hibernate:
select
from
where
veiculo0_.codigo=?
www.algaworks.com
39
Valor atual: 71300.00

Novo valor: 71800.00
Hibernate:
update
tab_veiculo
set
ano_fabricacao=?,
ano_modelo=?,
fabricante=?,
modelo=?,
valor=?
where
codigo=?
2.13. Excluindo objetos

A excluso de objetos feita chamando o mtodo
passando como parmetro o objeto.
remove
de
EntityManager,
public class ExcluindoVeiculo {

tx.begin();
manager.remove(veiculo);
tx.commit();
manager.close();
JpaUtil.close();
}
}
O resultado na console o seguinte:

Hibernate:
select
www.algaworks.com
40
from
where
veiculo0_.codigo=?
Hibernate:
delete
from
tab_veiculo
where
codigo=?
www.algaworks.com
41
Captulo 3
Gerenciando estados
3.1. Estados e ciclo de vida
Objetos de entidades so instncias de classes mapeadas usando JPA, que ficam
na memria e representam registros do banco de dados. Essas instncias
possuem um ciclo de vida, que gerenciado pelo JPA.
Os estados do ciclo de vida das entidades so: transient (ou new), managed,
detached e removed.
As transies entre os estados so feitas atravs de mtodos do EntityManager.

Vamos aprender o que significa cada estado do ciclo de vida dos objetos.
www.algaworks.com
42
Objetos transientes
Objetos transientes (transient) so instanciados usando o operador new. Isso
significa que eles ainda no esto associados com um registro na tabela do banco
de dados, e podem ser perdidos e coletados pelo garbage collector quando no
estiver mais sendo usado.
Objetos gerenciados
Objetos gerenciados (managed) so instncias de entidades que possuem um
identificador e representam um registro da tabela do banco de dados.
As instncias gerenciadas podem ser objetos que foram persistidos atravs da
chamada de um mtodo do EntityManager, como por exemplo o persist. Eles
tambm podem ter se tornado gerenciados atravs de mtodos de consulta do
EntityManager, que buscam registros da base de dados e instanciam objetos
diretamente no estado managed.
Objetos gerenciados esto sempre associados a um contexto de persistncia,
portanto, quaisquer alteraes nesses objetos so sincronizadas com o banco de
dados.
Objetos removidos
Uma instncia de uma entidade pode ser excluda atravs do mtodo
EntityManager.
remove
do
Um objeto entra no estado removed quando ele marcado para ser eliminado, mas
fisicamente excludo durante a sincronizao com o banco de dados.
Objetos desanexados
Um objeto sempre inicia no estado transiente e depois pode se tornar gerenciado.
Quando o Entity Manager fechado, continua existindo uma instncia do objeto,
mas j no estado detached.
www.algaworks.com
43
Esse estado existe para quando os objetos esto desconectados, no tendo mais
sincronia com o banco de dados. A JPA fornece operaes para reconectar esses
objetos a um novo EntityManager, que veremos adiante.
3.2. Contexto de persistncia

O contexto de persistncia uma coleo de objetos gerenciados por um
EntityManager.
Se uma entidade pesquisada, mas ela j existe no contexto de persistncia,
o objeto existente retornado, sem acessar o banco de dados. Esse recurso
chamado de cache de primeiro nvel
nvel.
Uma mesma entidade pode ser representada por diferentes objetos na memria,
desde que seja em diferentes instncias de EntityManagers. Em uma nica
instncia de EntityManager, apenas um objeto que representa determinada
entidade (com o mesmo identificador) pode ser gerenciada.
Veiculo veiculo1 = manager.find(Veiculo.class, 2L);
System.out.println("Buscou veiculo pela primeira vez...");
System.out.println("Buscou veiculo pela segunda vez...");
System.out.println("Mesmo veculo? " + (veiculo1 == veiculo2));
manager.close();
JpaUtil.close();
O cdigo acima busca o mesmo veculo duas vezes, dentro do mesmo contexto
de persistncia. A consulta SQL foi executada apenas na primeira vez, pois na
segunda, o objeto j estava no cache de primeiro nvel. Veja a sada:
Hibernate:
select
www.algaworks.com
44
from
where
veiculo0_.codigo=?
Buscou veiculo pela primeira vez...
Buscou veiculo pela segunda vez...
Mesmo veculo? true
O mtodo contains de EntityManager verifica se o objeto est sendo gerenciado

pelo contexto de persistncia do EntityManager. O mtodo detach pra de
gerenciar a entidade no contexto de persistncia, colocando ela no estado
detached.
System.out.println("Buscou veiculo pela primeira vez...");
System.out.println("Gerenciado? " + manager.contains(veiculo1));
manager.detach(veiculo1);
System.out.println("E agora? " + manager.contains(veiculo1));
System.out.println("Buscou veiculo pela segunda vez...");
System.out.println("Mesmo veculo? " + (veiculo1 == veiculo2));
manager.close();
JpaUtil.close();
A execuo do cdigo acima imprime na sada:

Hibernate:
select
www.algaworks.com
45
from
where
veiculo0_.codigo=?
Buscou veiculo pela primeira vez...
Gerenciado? true
E agora? false
Hibernate:
select
from
where
veiculo0_.codigo=?
Buscou veiculo pela segunda vez...
Mesmo veculo? false
Veja que agora a consulta foi executada duas vezes, pois desanexamos o veculo
que estava sendo gerenciado pelo contexto de persistncia.
3.3. Sincronizao de dados

Os estados de entidades so sincronizados com o banco de dados quando ocorre
o commit da transao associada.
Vamos usar um exemplo anterior, para entender melhor.
tx.begin();
www.algaworks.com
46

tx.commit();
manager.close();
JpaUtil.close();
Veja na sada abaixo que o comando update foi executado apenas no final da
execuo, exatamente durante o commit da transao.
Hibernate:
select
from
where
veiculo0_.codigo=?
Hibernate:
update
tab_veiculo
set
ano_fabricacao=?,
ano_modelo=?,
fabricante=?,
modelo=?,
valor=?
where
codigo=?
Podemos forar a sincronizao antes mesmo do commit, chamando o mtodo

flush de EntityManager.
www.algaworks.com
47

tx.begin();
manager.flush();
tx.commit();
manager.close();
JpaUtil.close();
Agora, o comando update foi executado antes do ltimo print que fizemos, que
exibe o novo valor.
Hibernate:
select
from
where
veiculo0_.codigo=?
Hibernate:
update
tab_veiculo
set
ano_fabricacao=?,
ano_modelo=?,
fabricante=?,
modelo=?,
valor=?
where
www.algaworks.com
48
codigo=?
3.4. Salvando objetos desanexados com merge()

Objetos desanexados so objetos em um estado que no gerenciado pelo
EntityManager, mas ainda representa uma entidade no banco de dados. As
alteraes em objetos desanexados no so sincronizadas com o banco de dados.
Quando estamos desenvolvendo sistemas, existem diversos momentos que
somos obrigados a trabalhar com objetos desanexados, por exemplo, quando eles
so expostos para alterao atravs de pginas web e apenas em um segundo
momento o usurio solicita a gravao das alteraes do objeto.
No cdigo abaixo, alteramos o valor de um veculo em um momento que o objeto
est no estado detached, por isso, a modificao no sincronizada.
tx.begin();
tx.commit();
manager.close();
// essa alterao no ser sincronizada
veiculo.setValor(new BigDecimal(5_000));
JpaUtil.close();
Podemos reanexar objetos em qualquer EntityManager usando o mtodo merge.

tx.begin();
tx.commit();
www.algaworks.com
49
manager.close();
manager = JpaUtil.getEntityManager();
tx = manager.getTransaction();
tx.begin();
// reanexamos o objeto ao novo EntityManager
veiculo = manager.merge(veiculo);
tx.commit();
manager.close();
JpaUtil.close();
O contedo do objeto desanexado copiado para um objeto gerenciado com a

mesma identidade. Se o EntityManager ainda no estiver gerenciando um objeto
com a mesma identidade, ser realizada uma consulta para encontr-lo, ou ainda,
ser persistida uma nova entidade.
O retorno do mtodo
merge
uma instncia de um objeto gerenciado. O objeto
desanexado no muda de estado, ou seja, continua detached.

A execuo do cdigo acima exibe na sada:
Hibernate:
select
from
where
veiculo0_.codigo=?
Hibernate:
select
www.algaworks.com
50
from
where
veiculo0_.codigo=?
Hibernate:
update
tab_veiculo
set
ano_fabricacao=?,
ano_modelo=?,
fabricante=?,
modelo=?,
valor=?
where
codigo=?
www.algaworks.com
51
Captulo 4
Mapeamento
4.1. Identificadores
A propriedade de identificao representa a chave primria de uma tabela do
banco de dados. Nos exemplos anteriores, a propriedade codigo de instncias de
veculos representava o cdigo do veculo (chave primria) no banco de dados.
Um exemplo tpico de mapeamento de identificadores o seguinte:
@Id
@GeneratedValue
return codigo;
}
O identificador mapeado para a chave primria codigo. Podemos alterar o nome

da coluna usando @Column.
@Id
@GeneratedValue
@Column(name = "cod_veiculo")
return codigo;
}
A anotao @Id no mtodo getter marca a propriedade como um identificador,

e a anotao @GeneratedValue diz que o valor do identificador ser gerado
www.algaworks.com
52
automaticamente usando uma estratgia nativa do banco de dados, que no caso

do MySQL, o auto-incremento.
Este ltimo mapeamento poderia ser modificado para a seguinte forma (e o
significado seria o mesmo):
@Id
@GeneratedValue(strategy = GenerationType.AUTO)
return codigo;
}
A nica mudana realizada foi a incluso da propriedade strategy na anotao

@GeneratedValue. Quando essa propriedade no informada, considerada a
estratgia AUTO como padro.
Existe um gerador de chave prprio do Hibernate chamado increment
increment, que
o famoso select max + 1. Para us-lo, inclumos a anotao @GenericGenerator
e informamos a propriedade strategy igual a increment, damos um nome a
esse gerador informando o atributo name e depois associamos esse gerador na
anotao @GeneratedValue, informando na propriedade generator o mesmo nome
escolhido para o gerador.
...
import javax.persistence.Column;
import org.hibernate.annotations.GenericGenerator;
...
@Id
@GeneratedValue(generator = "inc")
@GenericGenerator(name = "inc", strategy = "increment")
return codigo;
}
Apartir de agora, antes de fazer um insert de veculo, o framework executar

um comando select para buscar o ltimo identificador usado, e ento far um
www.algaworks.com
53
incremento para utilizar como prximo cdigo. Veja a query gerada quando
persistimos um novo veculo:
Hibernate:
select
max(cod_veiculo)
from
tab_veiculo
Esses so os identificadores mais usados. Consulte a documentao caso precise

de outro tipo de gerador. Se mesmo assim no encontrar um que atenda suas
necessidades, voc poder desenvolver o seu prprio gerador customizado.
4.2. Chaves compostas

Para exemplificar o uso de chaves compostas, incluiremos os atributos cidade
e placa como identificador de Veiculo. O atributo codigo no ser mais o
identificador, por isso precisaremos elimin-lo.
Criaremos uma classe chamada
chave composta) da entidade.
VeiculoId
para representar o identificador (a
import java.io.Serializable;
import javax.persistence.Embeddable;
@Embeddable
public class VeiculoId implements Serializable {
private static final long serialVersionUID = 1L;
private String placa;
private String cidade;
public VeiculoId() {
}
public VeiculoId(String placa, String cidade) {
super();
this.placa = placa;
this.cidade = cidade;
www.algaworks.com
54
}
public String getPlaca() {
return placa;
}
public void setPlaca(String placa) {
this.placa = placa;
}
public String getCidade() {
return cidade;
}
public void setCidade(String cidade) {
this.cidade = cidade;
}
// hashCode e equals
}
Veja que anotamos a classe VeiculoId com @Embeddable, pois ela ser sempre
utilizada de forma embutida em outra classe.
Na classe Veiculo, criamos um atributo
mtodo getter apenas com @EmbeddedId.
id
do tipo
VeiculoId
e anotamos seu
...
import javax.persistence.EmbeddedId;
@Entity
private VeiculoId id;
www.algaworks.com
55
@EmbeddedId
public VeiculoId getId() {
return id;
}
// getters, setters, hashCode e equals
}
Para persistir um novo veculo, preciso informar a cidade e placa, que faz parte
do identificador. Instanciaremos um VeiculoId e atribuiremos ao id do veculo.
veiculo.setId(new VeiculoId("ABC-1234", "Uberlndia"));
Para buscar um veculo pela chave, precisamos tambm instanciar um VeiculoId

e chamar o mtodo find de EntityManager, passando como parmetro a instncia
de VeiculoId.
VeiculoId id = new VeiculoId("ABC-1234", "Uberlndia");
Veiculo veiculo = manager.find(Veiculo.class, id);
System.out.println("Placa: " + veiculo.getId().getPlaca());
System.out.println("Cidade: " + veiculo.getId().getCidade());
System.out.println("Fabricante: " + veiculo.getFabricante());
System.out.println("Modelo: " + veiculo.getModelo());
Dica: para recriar a tabela, configure no arquivo persistence.xml a propriedade

hibernate.hbm2ddl.auto com valor igual a create.
<property name="hibernate.hbm2ddl.auto" value="create" />
Nos prximos exemplos deste livro, voltaremos a usar chaves simples.
www.algaworks.com
56
4.3. Enumeraes
Enumeraes em Java um tipo que define um nmero finito de valores
(instncias), como se fossem constantes.
Na classe Veiculo, incluiremos uma enumerao TipoCombustivel, para
representar os possveis tipos de combustveis que os veculos podem suportar.
Primeiro, definimos a enum:
public enum TipoCombustivel {
ALCOOL,
GASOLINA,
DIESEL,
BICOMBUSTIVEL
}
Depois, criamos a propriedade tipoCombustivel do tipo TipoCombustivel na classe

Veiculo
e configuramos seu mapeamento:

...
private TipoCombustivel tipoCombustivel;
...
@Column(name = "tipo_combustivel", nullable = false)
@Enumerated(EnumType.STRING)
public TipoCombustivel getTipoCombustivel() {
return tipoCombustivel;
}
public void setTipoCombustivel(TipoCombustivel tipoCombustivel) {
this.tipoCombustivel = tipoCombustivel;
}
...
www.algaworks.com
57
O novo atributo foi mapeado como uma coluna normal, porm inclumos a
anotao @Enumerated, para configurar o tipo da enumerao como string.
Fizemos isso para que a coluna do banco de dados armazene o nome da
constante, e no o nmero que representa a opo na enumerao.
Para inserir um novo veculo no banco de dados, atribumos tambm o tipo do
combustvel, como voc pode ver no exemplo abaixo:
veiculo.setFabricante("Ford");
veiculo.setModelo("Focus");
veiculo.setTipoCombustivel(TipoCombustivel.BICOMBUSTIVEL);
Se o parmetro da anotao @Enumerated for alterado para EnumType.ORDINAL

(padro), ser inserido o nmero que representa a opo na enumerao. No caso
da gasolina, esse valor seria igual a 1.
@Enumerated(EnumType.ORDINAL)
}
4.4. Propriedades temporais

O tipo de uma propriedade automaticamente detectado, mas para uma
propriedade do tipo Date ou Calendar, voc pode precisar definir a preciso da
data/hora, com a anotao @Temporal.
@Temporal(TemporalType.DATE)
@Column(name = "data_cadastro", nullable = false)
public Date getDataCadastro() {
www.algaworks.com
58
return dataCadastro;
}
O mapeamento acima, do atributo dataCadastro, diz que apenas a data

importante, por isso, ao criarmos/atualizarmos a tabela usando o hbm2ddl, uma
coluna do tipo DATE ser criada, se usarmos MySQL.
veiculo.setFabricante("GM");
veiculo.setModelo("Celta");
veiculo.setTipoCombustivel(TipoCombustivel.GASOLINA);
veiculo.setDataCadastro(new Date());
A JPA no define a preciso que deve ser usada se @Temporal no for especificada,
mas quando usamos Hibernate, as propriedades de datas usam a definio
TemporalType.TIMESTAMP por padro. Outras opes so TemporalType.TIME e
TemporalType.DATE.
4.5. Propriedades transientes

As propriedades de uma entidade so automaticamente mapeadas, se no
especificarmos nenhuma anotao. Por diversas vezes, podemos precisar criar
atributos e/ou mtodos getters que no representam uma coluna no banco de
dados. Nestes casos, devemos anotar com @Transient.
@Transient
public String getDescricao() {
return this.getFabricante() + " " + this.getModelo()
+ " " + this.getAnoFabricacao() + "/" + this.getAnoModelo()
+ " por apenas " + this.getValor();
}
www.algaworks.com
59
A propriedade ser ignorada totalmente pelo mecanismo de persistncia. O

mtodo getDescricao apenas um mtodo de negcio, que retorna uma descrio
comercial do veculo.
System.out.println(veiculo.getDescricao());
4.6. Objetos grandes

Quando precisamos armazenar muitos dados em uma coluna, por exemplo um
texto longo, um arquivo qualquer ou uma imagem, mapeamos a propriedade
com a anotao @Lob.
Objeto grande em caracteres (CLOB)

Um CLOB (Character Large Object) um tipo de dado em bancos de dados que
pode armazenar objetos grandes em caracteres (textos muito longos).
Para mapear uma coluna CLOB em JPA, definimos uma propriedade com o tipo
String, char[]
ou Character[] e anotamos com @Lob.

...
private String especificacoes;
...
@Lob
public String getEspecificacoes() {
return especificacoes;
}
...
}
Vamos persistir um novo veculo, incluindo uma especificao.
www.algaworks.com
60

tx.begin();
StringBuilder especificacoes = new StringBuilder();
especificacoes.append("Carro em excelente estado.\n");
especificacoes.append("Completo, menos ar.\n");
especificacoes.append("Primeiro dono, com manual de instruo ");
especificacoes.append("e todas as revises feitas.\n");
especificacoes.append("IPVA pago, aceita financiamento.");
veiculo.setFabricante("VW");
veiculo.setModelo("Gol");
veiculo.setEspecificacoes(especificacoes.toString());
tx.commit();
manager.close();
JpaUtil.close();
Poderamos incluir um texto muito maior para a especificao do veculo.

A coluna criada na tabela do tipo LONGTEXT, que um tipo de CLOB do MySQL.
Podemos buscar um veculo normalmente e imprimir na sada as especificaes.

System.out.println("Veculo: " + veiculo.getModelo());
System.out.println("-------");
System.out.println(veiculo.getEspecificacoes());
www.algaworks.com
61
manager.close();
Veja a sada da execuo:

Veculo: Gol
------Carro em excelente estado.
Completo, menos ar.
Primeiro dono, com manual de instruo e todas as revises feitas.
IPVA pago, aceita financiamento
Objeto grande binrio (BLOB)

Um BLOB (Binary Large Object) um tipo de dado em bancos de dados que pode
armazenar objetos grandes em binrio (arquivos diversos, incluindo executveis,
msicas, imagens, etc).
Para mapear uma coluna BLOB em JPA, definimos uma propriedade com o tipo
byte[] ou Byte[] e anotamos com @Lob.
...
private byte[] foto;
...
@Lob
public byte[] getFoto() {
return foto;
}
...
}
Vamos persistir um novo veculo, incluindo uma foto.

// l bytes do arquivo da imagem
Path path = FileSystems.getDefault().getPath("/caminho/da/imagem/ix35.jpg");
byte[] foto = Files.readAllBytes(path);
www.algaworks.com
62

tx.begin();
veiculo.setFabricante("Hyundai");
veiculo.setModelo("ix35");
veiculo.setFoto(foto);
tx.commit();
manager.close();
JpaUtil.close();
A coluna criada na tabela do tipo LONGBLOG, que um tipo de BLOB do MySQL.

Podemos buscar um veculo normalmente, obter os bytes da imagem e exibir
usando a classe javax.swing.JOptionPane.
import java.awt.image.BufferedImage;
import java.io.ByteArrayInputStream;
import java.io.IOException;
import javax.imageio.ImageIO;
import javax.swing.ImageIcon;
import javax.swing.JLabel;
import javax.swing.JOptionPane;
public class ExibindoImagem {
public static void main(String[] args) throws IOException {
if (veiculo.getFoto() != null) {
BufferedImage img = ImageIO.read(new ByteArrayInputStream(
www.algaworks.com
63
veiculo.getFoto()));
JOptionPane.showMessageDialog(null, new JLabel(
new ImageIcon(img)));
} else {
System.out.println("Vei
culo na
o possui foto.");
}
manager.close();
JpaUtil.close();
}
}
4.7. Objetos embutidos

Objetos embutidos so componentes de uma entidade, cujas propriedades so
mapeadas para a mesma tabela da entidade.
Em algumas situaes, queremos usar a orientao a objetos para componentizar
nossas entidades, mas manter os dados em uma nica tabela. Isso pode ser
www.algaworks.com
64
interessante para evitar muitas associaes entre tabelas, e por consequncia,

diversos joins durante as consultas.
Outra situao comum o mapeamento de tabelas de sistemas legados, onde no
permitido alterar a estrutura das tabelas.
Queremos incluir novas colunas na tabela de veculos para armazenar alguns
dados do proprietrio. Para no ficar tudo na entidade Veiculo, criaremos uma
classe Proprietario, que representa um proprietrio.
@Embeddable
public class Proprietario {
private String nome;
private String telefone;
private String email;
@Column(name = "nome_proprietario", nullable = false)
public String getNome() {
return nome;
}
public void setNome(String nome) {
this.nome = nome;
}
@Column(name = "telefone_proprietario", nullable = false)
public String getTelefone() {
return telefone;
}
public void setTelefone(String telefone) {
this.telefone = telefone;
}
@Column(name = "email_proprietario")
public String getEmail() {
return email;
}
public void setEmail(String email) {
this.email = email;
}
www.algaworks.com
65
Como as colunas sero criadas na tabela de veculos, mapeamos as propriedades

de Proprietario e definimos outros nomes de colunas.
Note que a classe Proprietario foi anotada com @Embeddable.
Na classe Veiculo, incluimos um novo atributo do tipo Proprietario com o getter
anotado com @Embedded.
...
private Proprietario proprietario;
...
@Embedded
public Proprietario getProprietario() {
return proprietario;
}
...
}
Agora, para persistir um novo veculo, precisamos instanciar e relacionar com

um Proprietario.
tx.begin();
Proprietario proprietario = new Proprietario();
proprietario.setNome("Joo das Couves");
proprietario.setTelefone("(34) 1234-5678");
www.algaworks.com
66
veiculo.setProprietario(proprietario);
tx.commit();
manager.close();
JpaUtil.close();
Veja as novas colunas que foram criadas na tabela.
4.8. Associaes um-para-um

O relacionamento um-para-um, tambm conhecido como one-to-one, pode ser
usado para dividir uma entidade em duas (criando duas tabelas), para ficar mais
normalizado e fcil de entender.
Esse tipo de associao poderia ser usado entre Veiculo e Proprietario.
Precisamos apenas anotar a classe Proprietario com

@Table. Alm disso, inclumos tambm um atributo
www.algaworks.com
e, opcionalmente,
codigo, para armazenar o
@Entity
67
identificador da entidade (chave primria) e implementamos os mtodos

hashCode e equals.
@Entity
@Table(name = "proprietario")
@Id
@GeneratedValue
return codigo;
}
}
return nome;
}
this.nome = nome;
}
return telefone;
}
}
@Column(length = 255)
return email;
www.algaworks.com
68
}
this.email = email;
}
}
Na classe
Veiculo,
adicionamos a propriedade
proprietario
e mapeamos com
@OneToOne.
...
...
@OneToOne
}
...
}
Podemos tentar persistir um novo veculo associado a um proprietrio.

tx.begin();
www.algaworks.com
69
tx.commit();
manager.close();
JpaUtil.close();
Quando executamos o cdigo acima, recebemos uma exceo, dizendo que o

objeto do tipo Veiculo possui uma propriedade que faz referncia a um objeto
transiente do tipo Proprietario.
Caused by: org.hibernate.TransientPropertyValueException: object
references an unsaved transient instance - save the transient
instance before flushing: Veiculo.proprietario -> Proprietario
Precisamos de uma instncia persistida de proprietrio para atribuir ao veculo.

manager.persist(proprietario);
Veja a sada da execuo:
www.algaworks.com
70
Hibernate:
insert
into
proprietario
(email, nome, telefone)
values
(?, ?, ?)
Hibernate:
insert
into
tab_veiculo
(ano_fabricacao, ano_modelo, data_cadastro, fabricante, modelo,
proprietario_codigo, tipo_combustivel, valor)
values
(?, ?, ?, ?, ?, ?, ?, ?)
Note que foi criada uma coluna proprietario_codigo na tabela tab_veiculo.

Por padro, o nome da coluna definido com o nome do atributo da associao,
mais underscore, mais o nome do atributo do identificador da entidade destino.
Podemos mudar isso com a anotao @JoinColumn.
@OneToOne
@JoinColumn(name = "cod_proprietario")
}
O relacionamento one-to-one aceita referncias nulas, por padro. Podemos

obrigar a atribuio de proprietrio durante a persistncia de Veiculo, incluindo
o atributo optional com valor false, na anotao @OneToOne.
@OneToOne(optional = false)
}
Dessa forma, se tentarmos persistir um veculo sem proprietrio, uma exceo

lanada.
Caused by: org.hibernate.PropertyValueException: not-null property
references a null or transient value: Veiculo.proprietario
www.algaworks.com
71
Consultando veculos
Quando consultamos veculos, o provedor JPA executa uma consulta do
proprietrio para cada veculo encontrado:
List<Veiculo> veiculos = manager.createQuery("from Veiculo", Veiculo.class)
.getResultList();
System.out.println(veiculo.getModelo() + " - "
+ veiculo.getProprietario().getNome());
}
manager.close();
JpaUtil.close();
Veja as queries executadas:

Hibernate:
select
veiculo0_.data_cadastro as data_cad4_1_,
veiculo0_.proprietario_codigo as propriet9_1_,
veiculo0_.tipo_combustivel as tipo_com7_1_,
from
Hibernate:
select
proprietar0_.codigo as codigo1_0_0_,
proprietar0_.email as email2_0_0_,
proprietar0_.nome as nome3_0_0_,
proprietar0_.telefone as telefone4_0_0_
from
proprietario proprietar0_
www.algaworks.com
72
where
proprietar0_.codigo=?
Podemos mudar esse comportamento padro e executar apenas uma query

usando recursos da JPQL, mas ainda no falaremos sobre isso.
Se consultarmos um veculo pelo identificador, a query inclui um left join ou
inner join com a tabela de proprietrios, dependendo do atributo optional do
mapeamento @OneToOne.
manager.close();
JpaUtil.close();
Veja a query executada com @OneToOne(optional
= false).
select
veiculo0_.data_cadastro as data_cad4_1_1_,
veiculo0_.proprietario_codigo as propriet9_1_1_,
veiculo0_.tipo_combustivel as tipo_com7_1_1_,
veiculo0_.valor as valor8_1_1_,
from
inner join
on veiculo0_.proprietario_codigo=proprietar1_.codigo
www.algaworks.com
73
where
veiculo0_.codigo=?
Associao bidirecional
A associao que fizemos entre veculo e proprietrio unidirecional, ou seja,
podemos obter o proprietrio a partir de um veculo, mas no conseguimos obter
o veculo a partir de um proprietrio.
Para tornar a associao um-para-um bidirecional e ento conseguirmos obter
o veculo a partir de um proprietrio, precisamos apenas incluir uma nova
propriedade na classe Proprietario e mapearmos com @OneToOne usando o
atributo mappedBy.
@Entity
...
private Veiculo veiculo;
...
@OneToOne(mappedBy = "proprietario")
public Veiculo getVeiculo() {
return veiculo;
}
...
}
O valor de mappedBy deve ser igual ao nome da propriedade na classe Veiculo que
associa com Proprietario.
Agora, podemos consultar um proprietrio e obter o veculo dele.
Proprietario proprietario = manager.find(Proprietario.class, 1L);
www.algaworks.com
74
System.out.println(proprietario.getVeiculo().getModelo() + " - "

+ proprietario.getNome());
4.9. Associaes muitos-para-um

Na ltima seo, mapeamos a propriedade
proprietario
na entidade
Veiculo
com um-para-um. Mudaremos o relacionamento agora para many-to-one. Dessa

forma, um veculo poder possuir apenas um proprietrio, mas um proprietrio
poder estar associado a muitos veculos.
Vamos remover a propriedade veiculo da entidade

mapeamento de proprietario na classe Veiculo.
Proprietario
e alterar o

...
...
@ManyToOne
}
...
}
A anotao @ManyToOne indica a multiplicidade do relacionamento entre veculo e

proprietrio.
Vamos persistir um proprietrio e 2 veculos, que pertencem ao mesmo dono.
www.algaworks.com
75

tx.begin();
Veiculo veiculo1 = new Veiculo();
veiculo1.setFabricante("GM");
veiculo1.setModelo("Celta");
veiculo1.setAnoFabricacao(2006);
veiculo1.setAnoModelo(2006);
veiculo1.setValor(new BigDecimal(11_000));
veiculo1.setTipoCombustivel(TipoCombustivel.GASOLINA);
veiculo1.setDataCadastro(new Date());
veiculo1.setProprietario(proprietario);
manager.persist(veiculo1);
veiculo2.setFabricante("VW");
veiculo2.setModelo("Gol");
veiculo2.setTipoCombustivel(TipoCombustivel.BICOMBUSTIVEL);
veiculo2.setProprietario(proprietario);
tx.commit();
manager.close();
JpaUtil.close();
Para deixar a associao bidirecional, precisamos mapear um atributo na

entidade Proprietario, usando a @OneToMany. Veremos isso na prxima seo.
www.algaworks.com
76
4.10. Colees um-para-muitos

A anotao @OneToMany deve ser utilizada para mapear colees.
Mapearemos o inverso da associao many-to-one, que fizemos na ltima seo,
indicando que um proprietrio pode ter muitos veculos.
Incluiremos a propriedade veiculos na entidade Proprietario, do tipo List.

...
private List<Veiculo> veiculos;
...
@OneToMany(mappedBy = "proprietario")
public List<Veiculo> getVeiculos() {
return veiculos;
}
...
}
Para testar esse relacionamento, execute o cdigo abaixo, que busca um

proprietrio e lista todos os veculos dele.
System.out.println("Proprietrio: " + proprietario.getNome());
for (Veiculo veiculo : proprietario.getVeiculos()) {
www.algaworks.com
77
}
manager.close();
JpaUtil.close();
Veja a sada da execuo do cdigo acima:

Hibernate:
select
from
where
Proprietrio: Joo das Couves
Hibernate:
select
veiculos0_.cod_proprietario as cod_prop9_0_1_,
veiculos0_.codigo as codigo1_1_1_,
veiculos0_.codigo as codigo1_1_0_,
veiculos0_.ano_fabricacao as ano_fabr2_1_0_,
veiculos0_.ano_modelo as ano_mode3_1_0_,
veiculos0_.data_cadastro as data_cad4_1_0_,
veiculos0_.fabricante as fabrican5_1_0_,
veiculos0_.modelo as modelo6_1_0_,
veiculos0_.cod_proprietario as cod_prop9_1_0_,
veiculos0_.tipo_combustivel as tipo_com7_1_0_,
veiculos0_.valor as valor8_1_0_
from
tab_veiculo veiculos0_
where
veiculos0_.cod_proprietario=?
Veculo: Celta
Veculo: Gol2
A primeira query foi executada para buscar o proprietrio. A segunda, para

pesquisar a lista de veculos do proprietrio.
www.algaworks.com
78
Note que a segunda consulta s foi executada quando chamamos o mtodo

getVeiculos. Esse comportamento chamado de lazy-loading, e ser estudado
mais adiante.
4.11. Colees muitos-para-muitos

Para praticar o relacionamento many-to-many, criaremos uma entidade Acessorio,
que representa os acessrios que um carro pode ter. Dessa forma, um veculo
poder possuir vrios acessrios e um acessrio poder estar associado a vrios
veculos.
A classe Acessorio uma entidade sem nenhuma novidade nos mapeamentos.

@Entity
@Table(name = "acessorio")
public class Acessorio {
private String descricao;
@Id
@GeneratedValue
return codigo;
}
}
return descricao;
}
www.algaworks.com
79
public void setDescricao(String descricao) {

this.descricao = descricao;
}
}
Na entidade Veiculo, criamos um atributo acessorios do tipo Set. Definimos

como um conjunto, pois um veculo no poder possuir o mesmo acessrio
repetido. Usamos a anotao @ManyToMany para mapear a propriedade de coleo.
...
private Set<Acessorio> acessorios = new HashSet<>();
...
@ManyToMany
public Set<Acessorio> getAcessorios() {
return acessorios;
}
...
}
Esse tipo de relacionamento precisar de uma tabela de associao para que a

multiplicidade muitos-para-muitos funcione. O recurso hbm2ddl poder criar as
tabelas automaticamente.
www.algaworks.com
80
Por padro, um mapeamento com @ManyToMany cria a tabela de associao com os

nomes das entidades relacionadas, separados por underscore, com duas colunas,
com nomes tambm gerados automaticamente.
Podemos customizar o nome da tabela de associao e das colunas com a
anotao @JoinTable.
@ManyToMany
@JoinTable(name = "veiculo_acessorios",
joinColumns = @JoinColumn(name = "cod_veiculo"),
inverseJoinColumns = @JoinColumn(name = "cod_acessorio"))
return acessorios;
}
Neste
exemplo,
definimos o nome da tabela de associao como

veiculo_acessorios, o nome da coluna que faz referncia para a tabela de veculos
como
cod_veiculo
e da coluna que referencia tabela de acessrios como

cod_acessorio (lado inverso).
Vamos inserir e relacionar alguns acessrios e veculos.
www.algaworks.com
81

tx.begin();
// instancia acessrios
Acessorio alarme = new Acessorio();
alarme.setDescricao("Alarme");
Acessorio arCondicionado = new Acessorio();
arCondicionado.setDescricao("Ar condicionado");
Acessorio bancosDeCouro = new Acessorio();
bancosDeCouro.setDescricao("Bancos de couro");
Acessorio direcaoHidraulica = new Acessorio();
direcaoHidraulica.setDescricao("Direo hidrulica");
// persiste acessrios
manager.persist(alarme);
manager.persist(arCondicionado);
manager.persist(bancosDeCouro);
manager.persist(direcaoHidraulica);
// instancia veculos
veiculo1.setFabricante("VW");
veiculo1.setModelo("Gol");
veiculo1.getAcessorios().add(alarme);
veiculo1.getAcessorios().add(arCondicionado);
veiculo2.setFabricante("Hyundai");
veiculo2.setModelo("i30");
veiculo2.getAcessorios().add(alarme);
www.algaworks.com
82
veiculo2.getAcessorios().add(arCondicionado);
veiculo2.getAcessorios().add(bancosDeCouro);
veiculo2.getAcessorios().add(direcaoHidraulica);
veiculo2.getAcessorios().add(direcaoHidraulica);
// persiste veculos
tx.commit();
manager.close();
JpaUtil.close();
O provedor de persistncia incluir os registros nas 3 tabelas.
Consultando acessrios de um veculo

Podemos iterar nos acessrios de um veculo usando o mtodo getAcessorios da
classe Veiculo.
for (Acessorio acessorio : veiculo.getAcessorios()) {
System.out.println("Acessrio: " + acessorio.getDescricao());
}
manager.close();
JpaUtil.close();

Hibernate:
select
www.algaworks.com
83
from
veiculo veiculo0_
where
veiculo0_.codigo=?
Veculo: i30
Hibernate:
select
acessorios0_.cod_veiculo as cod_veic1_1_1_,
acessorios0_.cod_acessorio as cod_aces2_2_1_,
acessorio1_.codigo as codigo1_0_0_,
acessorio1_.descricao as descrica2_0_0_
from
veiculo_acessorios acessorios0_
inner join
acessorio acessorio1_
on acessorios0_.cod_acessorio=acessorio1_.codigo
where
acessorios0_.cod_veiculo=?
Acessrio: Bancos de couro
Acessrio: Direo hidrulica
Acessrio: Alarme
Acessrio: Ar condicionado
Mapeamento bidirecional
Para fazer o mapeamento bidirecional, o lado inverso deve apenas fazer
referncia ao nome da propriedade que mapeou a coleo na entidade dona da
relao, usando o atributo mappedBy.
...
private Set<Veiculo> veiculos = new HashSet<>();
...
@ManyToMany(mappedBy = "acessorios")
public Set<Veiculo> getVeiculos() {
www.algaworks.com
84
return veiculos;
}
...
}
4.12. Colees de tipos bsicos e objetos embutidos

Em algumas situaes, no precisamos criar e relacionar duas entidades, pois
uma coleo de tipos bsicos ou embutveis seria suficiente. Para esses casos,
usamos @ElementCollection.
Para nosso exemplo, voltaremos a usar a entidade Proprietario. Um proprietrio
pode ter vrios nmeros de telefones, que so do tipo String. Tudo que
precisamos de um List.
@Entity
private List<String> telefones = new ArrayList<>();
@Id
@GeneratedValue
return codigo;
}
}
@Column(name = "nome", length = 60, nullable = false)
return nome;
}
www.algaworks.com
85
this.nome = nome;
}
@ElementCollection
@CollectionTable(name = "proprietario_telefones",
joinColumns = @JoinColumn(name = "cod_proprietario"))
@Column(name = "numero_telefone", length = 20, nullable = false)
public List<String> getTelefones() {
return telefones;
}
public void setTelefones(List<String> telefones) {
this.telefones = telefones;
}
}
A tabela que armazena os dados da coleo foi customizada atravs da anotao

@CollectionTable. Personalizamos tambm o nome da coluna que faz referncia
tabela de proprietrio usando o atributo joinColumns.
A anotao @Column foi usada para personalizar o nome da coluna que armazena
o nmero do telefone na tabela da coleo.
Agora, podemos persistir um proprietrio com diversos telefones.
tx.begin();
proprietario.setNome("Sebastio");
proprietario.getTelefones().add("(34) 1234-5678");
proprietario.getTelefones().add("(11) 9876-5432");
tx.commit();
manager.close();
JpaUtil.close();
www.algaworks.com
86
E tambm podemos listar todos os telefones de um proprietrio especfico.

for (String telefone : proprietario.getTelefones()) {
System.out.println("Telefone: " + telefone);
}
manager.close();
JpaUtil.close();
Objetos embutidos
Podemos usar @ElementCollection para mapear tambm tipos de objetos
embutveis. Por exemplo, suponha que queremos separar o nmero do telefone
em DDD + nmero e armazenar tambm o ramal (opcional). Para isso, criamos
uma classe Telefone e anotamos com @Embeddable.
@Embeddable
public class Telefone {
private String prefixo;
private String numero;
private String ramal;
public Telefone() {
}
public Telefone(String prefixo, String numero, String ramal) {
super();
this.prefixo = prefixo;
this.numero = numero;
this.ramal = ramal;
}
public String getPrefixo() {
return prefixo;
}
www.algaworks.com
87
public void setPrefixo(String prefixo) {

this.prefixo = prefixo;
}
public String getNumero() {
return numero;
}
public void setNumero(String numero) {
this.numero = numero;
}
@Column(length = 5)
public String getRamal() {
return ramal;
}
public void setRamal(String ramal) {
this.ramal = ramal;
}
}
Na entidade Proprietario, criamos um atributo do tipo List e mapeamos o getter

com @ElementCollection.
...
private List<Telefone> telefones = new ArrayList<>();
...
@ElementCollection
@CollectionTable(name = "proprietario_telefones",
joinColumns = @JoinColumn(name = "cod_proprietario"))
@AttributeOverrides({ @AttributeOverride(name = "numero",
column = @Column(name = "num_telefone", length = 20, nullable = false)) })
public List<Telefone> getTelefones() {
return telefones;
www.algaworks.com
88
}
...
}
A anotao @AttributeOverrides foi usada para substituir o mapeamento da

propriedade numero, alterando o nome da coluna para num_telefone.
Agora, podemos persistir um proprietrio com telefones.
tx.begin();
proprietario.setNome("Sebastio");
proprietario.getTelefones().add(new Telefone("34", "1234-5678", "104"));
proprietario.getTelefones().add(new Telefone("11", "9876-5432", null));
tx.commit();
manager.close();
JpaUtil.close();
Para listar todos os telefones de um veculo, obtemos a coleo de telefones e

chamamos os getters das propriedades.
for (Telefone telefone : proprietario.getTelefones()) {
System.out.println("Telefone: (" + telefone.getPrefixo() + ") "
+ telefone.getNumero()
+ (telefone.getRamal() != null ? " x" + telefone.getRamal() : ""));
}
manager.close();
JpaUtil.close();
www.algaworks.com
89
4.13. Herana
Mapear herana de classes que representam tabelas no banco de dados pode ser
uma tarefa complexa e nem sempre pode ser a melhor soluo. Use este recurso
com moderao. Muitas vezes melhor voc mapear usando associaes do que
herana.
A JPA define 3 formas de se fazer o mapeamento de herana:
Tabela nica para todas as classes (single table)
Uma tabela para cada classe da hierarquia (joined)
Uma tabela para cada classe concreta (table per class)
Tabela nica para todas as classes

Essa estratgia de mapeamento de herana a melhor em termos de performance
e simplicidade, porm seu maior problema que as colunas das propriedades
declaradas nas classes filhas precisam aceitar valores nulos. A falta da constraint
NOT NULL pode ser um problema srio no ponto de vista de integridade de
dados.
Para implementar essa estratgia, criaremos uma classe abstrata Pessoa.
@Entity
@Table(name = "pessoa")
@Inheritance(strategy = InheritanceType.SINGLE_TABLE)
@DiscriminatorColumn(name = "tipo")
public abstract class Pessoa {
private Long id;
@Id
@GeneratedValue
public Long getId() {
return id;
}
public void setId(Long id) {
this.id = id;
www.algaworks.com
90
}
return nome;
}
this.nome = nome;
}
}
Definimos a estratgia SINGLE_TABLE com a anotao @Inheritance. Esse tipo de

herana o padro, ou seja, no precisaramos anotar a classe com @Inheritance,
embora seja melhor deixar explcito para facilitar o entendimento.
A anotao @DiscriminatorColumn foi usada para informar o nome de coluna de
controle para discriminar de qual classe o registro.
Agora, criaremos as subclasses Cliente e Funcionario.
@Entity
@DiscriminatorValue("C")
public class Cliente extends Pessoa {
private BigDecimal limiteCredito;
private BigDecimal rendaMensal;
private boolean bloqueado;
@Column(name = "limite_credito", nullable = true)
public BigDecimal getLimiteCredito() {
return limiteCredito;
}
public void setLimiteCredito(BigDecimal limiteCredito) {
this.limiteCredito = limiteCredito;
}
@Column(name = "renda_mensal", nullable = true)
public BigDecimal getRendaMensal() {
www.algaworks.com
91
return rendaMensal;
}
public void setRendaMensal(BigDecimal rendaMensal) {
this.rendaMensal = rendaMensal;
}
@Column(nullable = true)
public boolean isBloqueado() {
return bloqueado;
}
public void setBloqueado(boolean bloqueado) {
this.bloqueado = bloqueado;
}
}
@Entity
@DiscriminatorValue("F")
public class Funcionario extends Pessoa {
private BigDecimal salario;
private String cargo;
@Column(nullable = true)
public BigDecimal getSalario() {
return salario;
}
public void setSalario(BigDecimal salario) {
this.salario = salario;
}
@Column(length = 60, nullable = true)
public String getCargo() {
return cargo;
}
public void setCargo(String cargo) {
this.cargo = cargo;
}
}
www.algaworks.com
92
As subclasses foram anotadas com

discriminador de cada tipo.
@DiscriminatorValue
para definir o valor
Veja a nica tabela criada, que armazena os dados de todas as subclasses.
Podemos persistir um cliente e um funcionrio normalmente.

tx.begin();
Funcionario funcionario = new Funcionario();
funcionario.setNome("Fernando");
funcionario.setCargo("Gerente");
funcionario.setSalario(new BigDecimal(12_000));
Cliente cliente = new Cliente();
cliente.setNome("Mariana");
cliente.setRendaMensal(new BigDecimal(8_500));
cliente.setLimiteCredito(new BigDecimal(2_000));
cliente.setBloqueado(true);
manager.persist(funcionario);
manager.persist(cliente);
tx.commit();
manager.close();
JpaUtil.close();
www.algaworks.com
93
Veja na sada da execuo do cdigo acima que 2 inserts foram feitos.

Hibernate:
insert
into
pessoa
(nome,
values
(?, ?,
Hibernate:
insert
into
pessoa
(nome,
values
(?, ?,
cargo, salario, tipo)

?, 'F')
bloqueado, limite_credito, renda_mensal, tipo)

?, ?, 'C')
Repare que os valores discriminatrios F e C foram includos no comando de

insero.
Podemos consultar apenas clientes ou funcionrios, sem nenhuma novidade no
cdigo.
List<Cliente> clientes = manager.createQuery("from Cliente",
Cliente.class).getResultList();
for (Cliente cliente : clientes) {
System.out.println(cliente.getNome() + " - " + cliente.getRendaMensal());
}
Essa consulta gera um SQL com uma condio na clusula where:

Hibernate:
select
cliente0_.id as id2_0_,
cliente0_.nome as nome3_0_,
cliente0_.bloqueado as bloquead4_0_,
cliente0_.limite_credito as limite_c5_0_,
cliente0_.renda_mensal as renda_me6_0_
from
pessoa cliente0_
www.algaworks.com
94
where
cliente0_.tipo='C'
possvel tambm fazer uma consulta polimrfica de pessoas.

List<Pessoa> pessoas = manager.createQuery("from Pessoa",
Pessoa.class).getResultList();
for (Pessoa pessoa : pessoas) {
System.out.print(pessoa.getNome());
if (pessoa instanceof Cliente) {
System.out.println(" - um cliente");
} else {
System.out.println(" - um funcionrio");
}
}
Essa consulta busca todas as pessoas (clientes e funcionrios), executando a

consulta abaixo:
Hibernate:
select
pessoa0_.id as id2_0_,
pessoa0_.nome as nome3_0_,
pessoa0_.bloqueado as bloquead4_0_,
pessoa0_.limite_credito as limite_c5_0_,
pessoa0_.renda_mensal as renda_me6_0_,
pessoa0_.cargo as cargo7_0_,
pessoa0_.salario as salario8_0_,
pessoa0_.tipo as tipo1_0_
from
pessoa pessoa0_
Uma tabela para cada classe da hierarquia

Outra forma de fazer herana usar uma tabela para cada classe da hierarquia
(subclasses e superclasse).
Alteramos a estratgia de herana para JOINED na entidade Pessoa.
www.algaworks.com
95
@Entity
@Table(name = "pessoa")
@Inheritance(strategy = InheritanceType.JOINED)
...
}
Nas
classes
e Funcionario, podemos adicionar a anotao

@PrimaryKeyJoinColumn para informar o nome da coluna que faz referncia
tabela pai, ou seja, o identificador de Pessoa. Se o nome dessa coluna for igual ao
nome da coluna da tabela pai, essa anotao no presisa ser utilizada.
Cliente
@Entity
@Table(name = "funcionario")
@PrimaryKeyJoinColumn(name = "pessoa_id")
...
}
@Entity
@Table(name = "cliente")
@PrimaryKeyJoinColumn(name = "pessoa_id")
...
}
Este tipo de mapeamento criar 3 tabelas.
www.algaworks.com
96
Podemos persistir funcionrios e clientes e depois executar uma pesquisa

polimrfica, para listar todas as pessoas. Veja a consulta SQL usada:
Hibernate:
select
pessoa0_1_.bloqueado as bloquead1_0_,
pessoa0_1_.limite_credito as limite_c2_0_,
pessoa0_1_.renda_mensal as renda_me3_0_,
pessoa0_2_.cargo as cargo1_1_,
pessoa0_2_.salario as salario2_1_,
case
when pessoa0_1_.pessoa_id is not null then 1
when pessoa0_2_.pessoa_id is not null then 2
when pessoa0_.id is not null then 0
end as clazz_
from
pessoa pessoa0_
left outer join
cliente pessoa0_1_
on pessoa0_.id=pessoa0_1_.pessoa_id
left outer join
www.algaworks.com
97
funcionario pessoa0_2_
on pessoa0_.id=pessoa0_2_.pessoa_id
O Hibernate usou left outer join para relacionar a tabela pai s tabelas filhas e
tambm fez um case para controlar de qual tabela/classe pertence o registro.
Uma tabela para cada classe concreta

Uma outra opo de mapeamento de herana ter tabelas apenas para classes
concretas (subclasses). Cada tabela deve possuir todas as colunas, incluindo as da
superclasse.
Para utilizar essa forma de mapeamento, devemos anotar a classe
maneira apresentada abaixo:
Pessoa
da
@Entity
@Inheritance(strategy = InheritanceType.TABLE_PER_CLASS)
private Long id;
@Id
@GeneratedValue(generator = "inc")
@GenericGenerator(name = "inc", strategy = "increment")
return id;
}
...
}
Tivemos que mudar a estratgia de gerao de identificadores. No podemos

usar a gerao automtica de chaves nativa do banco de dados.
Veja a estrutura das tabelas criadas:
www.algaworks.com
98
Agora, a consulta polimrfica por objetos do tipo Pessoa gera a seguinte consulta:
Hibernate:
select
pessoa0_.bloqueado as bloquead1_1_,
pessoa0_.limite_credito as limite_c2_1_,
pessoa0_.renda_mensal as renda_me3_1_,
pessoa0_.cargo as cargo1_2_,
pessoa0_.salario as salario2_2_,
pessoa0_.clazz_ as clazz_
from
( select
id,
nome,
bloqueado,
limite_credito,
renda_mensal,
null as cargo,
null as salario,
1 as clazz_
from
cliente
union
select
id,
nome,
null as bloqueado,
null as limite_credito,
null as renda_mensal,
cargo,
www.algaworks.com
99
salario,
2 as clazz_
from
funcionario
) pessoa0_
Herana de propriedades da superclasse

Pode ser til, em algumas situaes, compartilhar propriedades atravs de uma
superclasse, sem consider-la como uma entidade mapeada. Para isso, podemos
usar a anotao @MappedSuperclass.
@MappedSuperclass
private Long id;
@Id
@GeneratedValue
return id;
}
....
}
As subclasses so mapeadas normalmente, sem nada especial:

@Entity
@Table(name = "cliente")
...
}
@Entity
@Table(name = "funcionario")
www.algaworks.com
100
...
}
Apenas as tabelas cliente e funcionario sero criadas. Como esse tipo de

mapeamento no uma estratgia de herana da JPA, no conseguimos fazer
uma consulta polimrfica. Veja a mensagem de erro se tentarmos isso:
Caused by: org.hibernate.hql.internal.ast.QuerySyntaxException:
Pessoa is not mapped [from Pessoa]
4.14. Modos de acesso

O estado das entidades precisam ser acessveis em tempo de execuo pelo
provedor JPA, para poder ler e alterar os valores e sincronizar com o banco de
dados.
Existem duas formas de acesso ao estado de uma entidade: field access e property
access.
Field access
Se anotarmos os atributos de uma entidade, o provedor JPA ir usar o modo field
access para obter e atribuir o estado da entidade. Os mtodos getters e setters no
so obrigatrios, neste caso, mas caso eles existam, sero ignorado pelo provedor
JPA.
recomendado que os atributos tenham o modificador de acesso protegido,
privado ou padro. O modificador pblico no recomendado, pois expe
demais os atributos para qualquer outra classe.
No exemplo abaixo, mapeamos a entidade Tarefa usando field access.
@Entity
@Table(name = "tarefa")
public class Tarefa {
@Id
www.algaworks.com
101
@GeneratedValue
private Long id;
@Temporal(TemporalType.TIMESTAMP)
@Column(nullable = false)
private Date dataLimite;
return id;
}
this.id = id;
}
return descricao;
}
}
public Date getDataLimite() {
return dataLimite;
}
public void setDataLimite(Date dataLimite) {
this.dataLimite = dataLimite;
}
}
Quando a anotao @Id colocada no atributo, fica automaticamente definido

que o modo de acesso pelos atributos (field access).
www.algaworks.com
102
Property access
Quando queremos usar o acesso pelas propriedades da entidade (property access),
devemos fazer o mapeamento nos mtodos getters, como fizemos nos exemplos
das sees anteriores. Neste caso, obrigatrio que existam os mtodos getters e
setters, pois o acesso aos atributos feito por eles.
Veja a mesma entidade Tarefa mapeada com property access.
@Entity
@Table(name = "tarefa")
public class Tarefa {
private Long id;
private Date dataLimite;
@Id
@GeneratedValue
return id;
}
this.id = id;
}
return descricao;
}
}
@Column(nullable = false)
public Date getDataLimite() {
return dataLimite;
}
www.algaworks.com
103
public void setDataLimite(Date dataLimite) {

this.dataLimite = dataLimite;
}
}
www.algaworks.com
104
Captulo 5
Recursos avanados
5.1. Lazy loading e eager loading
Podemos definir a estratgia de carregamento de relacionamentos de entidades,
podendo ser lazy (tardia) ou eager (ansiosa).
Para exemplificar, criaremos as entidades
cdigos abaixo.
Produto
Categoria,
conforme os
@Entity
@Table(name = "produto")
public class Produto {
private Long id;
private Categoria categoria;
@Id
@GeneratedValue
return id;
}
this.id = id;
}
www.algaworks.com
105

return nome;
}
this.nome = nome;
}
@ManyToOne(optional = false)
public Categoria getCategoria() {
return categoria;
}
public void setCategoria(Categoria categoria) {
this.categoria = categoria;
}
}
@Entity
@Table(name = "categoria")
public class Categoria {
private Long id;
private List<Produto> produtos = new ArrayList<>();
@Id
@GeneratedValue
return id;
}
this.id = id;
}
return nome;
}
www.algaworks.com
106

this.nome = nome;
}
@OneToMany(mappedBy = "categoria")
public List<Produto> getProdutos() {
return produtos;
}
public void setProdutos(List<Produto> produtos) {
this.produtos = produtos;
}
}
Como voc pode perceber, um produto tem uma categoria, e uma categoria pode
ter muitos produtos.
Vamos inserir uma categoria e alguns produtos, para podermos testar.
tx.begin();
Categoria categoria = new Categoria();
categoria.setNome("Bebidas");
Produto produto1 = new Produto();
produto1.setNome("Refrigerante");
produto1.setCategoria(categoria);
produto2.setNome("gua");
produto3.setNome("Cerveja");
manager.persist(categoria);
manager.persist(produto1);
www.algaworks.com
107
tx.commit();
manager.close();
JpaUtil.close();
Lazy loading
O cdigo-fonte abaixo obtm um produto com o identificador igual a 3 e exibe o
nome dele.
Produto produto = manager.find(Produto.class, 3L);
System.out.println("Nome: " + produto.getNome());
manager.close();
JpaUtil.close();
A sada da execuo do cdigo acima foi:

Hibernate:
select
produto0_.id as id1_1_1_,
produto0_.categoria_id as categori3_1_1_,
produto0_.nome as nome2_1_1_,
categoria1_.id as id1_0_0_,
categoria1_.nome as nome2_0_0_
from
produto produto0_
inner join
categoria categoria1_
on produto0_.categoria_id=categoria1_.id
where
produto0_.id=?
Nome: Cerveja
Note que a query SQL fez um join na tabela categoria, pois um produto possui
uma categoria, mas ns no usamos informaes dessa entidade em momento
www.algaworks.com
108
algum. Neste caso, as informaes da categoria do produto foram carregadas

ansiosamente, mas no foram usadas.
Podemos mudar a estratgia de carregamento para lazy, no mapeamento da
associao de produto com categoria.
@ManyToOne(optional = false, fetch = FetchType.LAZY)
return categoria;
}
Quando executamos a consulta anterior novamente, veja a sada:

Hibernate:
select
produto0_.nome as nome2_1_0_
from
produto produto0_
where
produto0_.id=?
Nome: Cerveja
O provedor JPA no buscou as informaes de categoria, pois o carregamento

passou a ser tardia, ou seja, apenas se for necessrio que uma consulta SQL
separada ser executada. Vamos ver um exemplo:
System.out.println("Categoria: " + produto.getCategoria().getNome());
manager.close();
JpaUtil.close();
Agora, duas consultas SQL foram executadas, sendo que a segunda (que busca a
categoria do produto), foi executada apenas no momento que o provedor notou
a necessidade de informaes da categoria.
www.algaworks.com
109
Hibernate:
select
produto0_.nome as nome2_1_0_
from
produto produto0_
where
produto0_.id=?
Nome: Cerveja
Hibernate:
select
from
where
categoria0_.id=?
Categoria: Bebidas
Esse comportamento de carregamento tardio chamado de lazy loading, e til

para evitar consultas desnecessrias, na maioria dos casos.
Quando usamos lazy loading, precisamos tomar cuidado com o estado da
entidade no ciclo de vida. Se tivermos uma instncia detached, no conseguiremos
obter um relacionamento lazy ainda no carregado.
// quando fechamos o EntityManager,
// todas as instncias se tornam detached
manager.close();
System.out.println("Categoria: " + produto.getCategoria().getNome());
JpaUtil.close();
O cdigo acima gera um erro na sada:
www.algaworks.com
110
Exception in thread "main" org.hibernate.LazyInitializationException:

could not initialize proxy - no Session
Lazy loading em mapeamento OneToOne

Antes de configurar o mapeamento one-to-one para usar lazy loading,
voc precisa assistir essa vdeo aula gratuita em nosso blog.
http://blog.algaworks.com/lazy-loading-com-mapeamento-onetoone/
Eager loading
Todos os relacionamentos qualquer-coisa-para-muitos, ou seja, one-to-many e manyto-many, possuem o lazy loading como estratgia padro. Os demais
relacionamentos (que so qualquer-coisa-para-um) possuem a estratgia eager
loading como padro.
A propriedade categoria, na entidade Produto, possua eager loading como
estratgia padro, mas depois alteramos para lazy loading.
Eager loading carrega o relacionamento ansiosamente, mesmo se a informao no
for usada. Isso pode ser bom se, na maioria das vezes, precisarmos de alguma
informao do relacionamento, mas tambm pode ser ruim, se na maioria das
vezes as informaes desse relacionamento no forem necessrias e mesmo assim
consultadas por causa do eager loading.
No exemplo abaixo, consultamos uma categoria pelo identificador e, atravs do
objeto da entidade retornado, iteramos nos produtos.
Categoria categoria = manager.find(Categoria.class, 1L);
System.out.println("Categoria: " + categoria.getNome());
for (Produto produto : categoria.getProdutos()) {
www.algaworks.com
111
System.out.println("Produto: " + produto.getNome());

}
manager.close();
JpaUtil.close();
Como a propriedade produtos na entidade Categoria um tipo de coleo

(mapeado com @OneToMany), duas consultas SQL foram executadas, sendo que
a segunda, apenas no momento em que o relacionamento de produtos foi
necessrio.
Hibernate:
select
from
where
categoria0_.id=?
Categoria: Bebidas
Hibernate:
select
produtos0_.categoria_id as categori3_0_1_,
produtos0_.id as id1_1_1_,
produtos0_.nome as nome2_1_0_
from
produto produtos0_
where
produtos0_.categoria_id=?
Produto: Refrigerante
Produto: gua
Produto: Cerveja
Embora no recomendado na maioria dos casos, podemos mudar a estratgia de

carregamento de produtos na entidade Categoria para eager.
@OneToMany(mappedBy = "categoria", fetch = FetchType.EAGER)
return produtos;
}
www.algaworks.com
112
Agora, quando consultamos um produto e iteramos nas categorias, apenas uma

query executada, incluindo um join com a tabela de produtos:
Hibernate:
select
categoria0_.nome as nome2_0_1_,
produtos1_.nome as nome2_1_0_
from
left outer join
produto produtos1_
on categoria0_.id=produtos1_.categoria_id
where
categoria0_.id=?
Categoria: Bebidas
Produto: Refrigerante
Produto: gua
Produto: Cerveja
Saber escolher a melhor estratgia muito importante para uma boa performance
do software que est sendo desenvolvido.
5.2. Operaes em cascata

Nesta seo, usaremos como base o mesmo mapeamento dos exemplos sobre lazy
loading e eager loading, ou seja, as entidades Produto e Categoria.
As operaes chamadas nos
EntityManagers
so aplicadas apenas na entidade
informada como parmetro, por padro. Por exemplo, vamos tentar persistir um
produto relacionado a uma categoria transiente no cdigo abaixo:
tx.begin();
www.algaworks.com
113

Produto produto = new Produto();
produto.setNome("Refrigerante");
produto.setCategoria(categoria);
manager.persist(produto);
tx.commit();
manager.close();
JpaUtil.close();
Como a associao entre produto e categoria no pode ser nula e a categoria no

persistida automaticamente, a exceo abaixo ser lanada:
Caused by: org.hibernate.TransientPropertyValueException:
Not-null property references a transient value - transient instance
must be saved before current operation: Produto.categoria -> Categoria
Persistncia em cascata
Em diversas situaes, quando persistimos uma entidade, queremos tambm que
seus relacionamentos sejam persistidos. Podemos chamar o mtodo persist para
cada entidade relacionada, mas essa uma tarefa um pouco chata.
Felizmente, a JPA fornece um mecanismo para facilitar a persistncia de

entidades e seus relacionamentos transientes, sempre que o mtodo persist for
chamado. Esse recurso se chama cascade, e para configur-lo, basta adicionarmos
www.algaworks.com
114
um atributo
cascade
na anotao de relacionamento e adicionar a operao
CascadeType.PERSIST.
@ManyToOne(optional = false, cascade = CascadeType.PERSIST)
return categoria;
}
Agora, quando persistirmos um produto, a categoria ser persistida tambm,

automaticamente.
As operaes do EntityManager so identificadas pela enumerao CascadeType

com as constantes PERSIST, REFRESH, REMOVE, MERGE e DETACH. A constante ALL um
atalho para declarar que todas as operaes devem ser em cascata.
Legal, agora queremos adicionar produtos em uma categoria e persistir a
categoria, atravs do mtodo persist de EntityManager.
categoria.setNome("Carnes");
produto.setNome("Picanha");
categoria.getProdutos().add(produto);
Sabe qual o resultado disso? Apenas a categoria inserida no banco de dados.

Os produtos foram ignorados, simplesmente.
www.algaworks.com
115
Para o cascading funcionar nessa operao, precisamos configur-lo no lado

inverso do relacionamento, ou seja, no mtodo getProdutos da classe Categoria.
@OneToMany(mappedBy = "categoria", cascade = CascadeType.PERSIST)
return produtos;
}
Agora sim, o ltimo exemplo ir inserir a categoria e o produto associado a ela.
Excluso em cascata
Quando exclumos uma entidade, por padro, apenas a entidade passada por
parmetro para o mtodo remove removida.
manager.remove(categoria);
O provedor JPA tentar remover apenas a categoria, mas isso no ser possvel,
pois o banco de dados posui integridade.
Caused by: com.mysql.jdbc.exceptions.jdbc4.
MySQLIntegrityConstraintViolationException:
Cannot delete or update a parent row: a foreign key constraint fails
(`ebookjpa`.`produto`, CONSTRAINT `FK_el0d58htywfs914w4grf6aoa0`
FOREIGN KEY (`categoria_id`) REFERENCES `categoria` (`id`))
Vamos configurar a operao de excluso em cascata no relacionamento produtos

da entidade Categoria. Para isso, basta adicionar a constante CascadeType.REMOVE
no atributo cascade do mapeamento.
@OneToMany(mappedBy = "categoria", cascade = { CascadeType.PERSIST,
CascadeType.REMOVE })
return produtos;
}
O ltimo exemplo, que tenta excluir apenas uma categoria, excluir todos os
produtos relacionados, antes de remover a categoria.
www.algaworks.com
116
5.3. Excluso de objetos rfos

Usaremos como base o mesmo mapeamento dos exemplos sobre lazy loading e
eager loading, ou seja, as entidades Produto e Categoria.
Para no influenciar nosso exemplo nesta seo, deixe o mapeamento de
categoria na entidade Produto da seguinte forma:
@ManyToOne(optional = false)
return categoria;
}
A operao de excluso em cascata, que voc estudou na ltima seo, remove a

entidade passada como parmetro para o mtodo remove de EntityManager, mas,
e se o vnculo entre duas entidades for desfeito, sem que haja uma excluso de
entidade pelo EntityManager?
tx.begin();
categoria.getProdutos().remove(produto);
tx.commit();
manager.close();
JpaUtil.close();
No exemplo acima, consideramos que temos uma categoria de identificador 1 e

um produto tambm com identificador 1, e que ambos esto relacionados. Ao
remover o produto da coleo de produtos de uma categoria, nada acontece!
Deixamos o produto rfo de um pai (categoria), por isso, o produto poderia ser
excludo automaticamente.
Podemos configurar a remoo de rfos, incluindo o atributo orphanRemoval no
mapeamento.
www.algaworks.com
117
@OneToMany(mappedBy = "categoria", cascade = CascadeType.PERSIST,

orphanRemoval = true)
return produtos;
}
A partir de agora, quando deixarmos um produto rfo de categoria, ele ser

excludo automaticamente do banco de dados.
5.4. Operaes em lote

Quando precisamos atualizar ou remover centenas ou milhares de registros do
banco de dados, pode se tornar invivel fazer isso objeto por objeto.
Neste caso, podemos usar bulk operations, ou operaes em lote. JPA suporta esse
tipo de operao atravs da JPQL.
Para este exemplo, criamos uma entidade Usuario.
@Entity
@Table(name = "usuario")
public class Usuario {
private Long id;
private boolean ativo;
@Id
@GeneratedValue
return id;
}
this.id = id;
}
return email;
}
www.algaworks.com
118

this.email = email;
}
public boolean isAtivo() {
return ativo;
}
public void setAtivo(boolean ativo) {
this.ativo = ativo;
}
}
Inserimos alguns usurios para nosso teste:

Usuario u1 = new Usuario();
u1.setEmail("joao@algaworks.com");
u1.setAtivo(true);
u2.setEmail("manoel@algaworks.com");
u2.setAtivo(true);
u3.setEmail("sebastiao123@gmail.com");
u3.setAtivo(true);
manager.persist(u1);
Queremos inativar todos os usurios que possuem e-mails do domnio

@algaworks.com. Para isso, fazemos uma operao em lote, criando um objeto
do tipo Query e chamando o mtodo executeUpdate.
tx.begin();
www.algaworks.com
119
Query query = manager.createQuery(

"update Usuario set ativo = false where email like :email");
query.setParameter("email", "%@algaworks.com");
int linhasAfetadas = query.executeUpdate();
System.out.println(linhasAfetadas + " registros atualizados.");
tx.commit();
manager.close();
JpaUtil.close();
O texto :email no contedo da query JPQL um placeholder para o parmetro de

e-mail. Definimos o seu valor usando o mtodo setParameter.
Todos os usurios com e-mails do domnio @algaworks.com sero inativados
de uma nica vez, sem carregar os objetos em memria, o que muito mais
rpido.
Temos que tomar cuidado quando fazemos operaes em lote, pois o contexto de
persistncia no atualizado de acordo com as operaes executadas, portanto,
sempre bom fazer esse tipo de operao em uma transao isolada, onde
nenhuma outra alterao nas entidades feita.
Para fazer uma excluso em lote, basta usarmos o comando DELETE da JPQL.
tx.begin();
Query query = manager.createQuery("delete from Usuario where ativo = false");
int linhasExcluidas = query.executeUpdate();
System.out.println(linhasExcluidas + " registros removidos.");
tx.commit();
manager.close();
JpaUtil.close();
www.algaworks.com
120
5.5. Concorrncia e locking

Em sistemas reais, comum existir concorrncia em entidades por dois ou mais
EntityManagers. Simularemos o problema com a entidade Usuario, que usamos na
seo anterior.
No cdigo abaixo, abrimos dois EntityManagers, buscamos usurios
representados pelo identificador 1 em cada EntityManager e depois alteramos o email em cada objeto.
// obtm primeiro EntityManager e inicia transao
EntityManager manager1 = JpaUtil.getEntityManager();
EntityTransaction tx1 = manager1.getTransaction();
tx1.begin();
// obtm segundo EntityManager e inicia transao
EntityTransaction tx2 = manager2.getTransaction();
tx2.begin();
// altera objeto associado primeira transao
Usuario u1 = manager1.find(Usuario.class, 1L);
u1.setEmail("maria@algaworks.com");
// altera objeto associado segunda transao
Usuario u2 = manager2.find(Usuario.class, 1L);
u2.setEmail("jose@algaworks.com");
// faz commit na primeira transao
tx1.commit();
manager1.close();
// faz commit na segunda transao
tx2.commit();
manager2.close();
JpaUtil.close();
Como buscamos os usurios usando EntityManagers diferentes, os objetos no so

os mesmos na memria da JVM.
www.algaworks.com
121
Hibernate:
select
usuario0_.id as id1_0_0_,
usuario0_.ativo as ativo2_0_0_,
usuario0_.email as email3_0_0_
from
usuario usuario0_
where
usuario0_.id=?
Hibernate:
select
usuario0_.email as email3_0_0_
from
usuario usuario0_
where
usuario0_.id=?
Hibernate:
update
usuario
set
ativo=?,
email=?
where
id=?
Hibernate:
update
usuario
set
ativo=?,
email=?
where
id=?
Como voc pode imaginar, quando fizemos commit no primeiro EntityManager,

a alterao foi sincronizada com o banco de dados. O outro commit, do segundo
EntityManager, tambm sincronizou a alterao feita no usario associado a este
contexto de persistncia, substituindo a modificao anterior.
www.algaworks.com
122
Se uma situao como essa ocorrer em valores monetrios, por exemplo, voc
pode ter srios problemas. Imagine fazer sua empresa perder dinheiro por
problemas com transaes?
Locking otimista
Uma das formas de resolver o problema de concorrncia usando locking
otimista. Este tipo de locking tem como filosofia que, dificilmente, outro
EntityManager estar fazendo uma alterao no mesmo objeto ao mesmo tempo,
ou seja, uma estratgia otimista que entende que o problema de concorrncia
uma exceo.
No momento que uma alterao for sincronizada com o banco de dados, o
provedor JPA verifica se o objeto foi alterado por outra transao e lana uma
exceo OptimisticLockException, caso exista concorrncia.
Mas como o provedor JPA sabe se houve uma alterao no objeto? A resposta
que o provedor mantm um controle de verso simples da entidade. Para isso
funcionar, precisamos mapear uma propriedade para armazenar a verso da
entidade, usando a anotao @Version.
public class Usuario {
...
private Long versao;
...
@Version
public Long getVersao() {
return versao;
}
...
}
Agora, se houver concorrncia na alterao do mesmo registro, uma exceo ser

lanada:
www.algaworks.com
123
Caused by: javax.persistence.OptimisticLockException:

org.hibernate.StaleObjectStateException: Row was updated or deleted
by another transaction (or unsaved-value mapping was incorrect):
[Usuario#1]
Vdeo aula sobre Lock Otimista

Para no ficar qualquer dvida, assista a vdeo aula gratuita no blog da
AlgaWorks que explica, atravs de um projeto web, como usar locking
otimista.
http://blog.algaworks.com/entendendo-o-lock-otimista-do-jpa/
Locking pessimista
O locking pessimista trava o objeto imediatamente, ao invs de aguardar o
commit com otimismo, esperando que nada d errado.
Um lock pessimista garante que o objeto travado no ser modificado por outra
transao, at que a transao atual seja finalizada e libere a trava.
Usar essa abordagem limita a escalabilidade de sua aplicao, pois deixa as
operaes ocorrerem apenas em srie, por isso, deve ser usada com cuidado.
Na maioria dos sistemas, as operaes poderiam ocorrer em paralelo, usando
locking otimista.
Uma das formas de usar locking pessimista passando um parmetro para o
mtodo find, de EntityManager.
Usuario usuario = manager1.find(Usuario.class, 1L,
LockModeType.PESSIMISTIC_WRITE);
O lock feito adicionando for
update
na consulta SQL executada, veja:
Hibernate:
select
www.algaworks.com
124
usuario0_.email as email3_0_0_,
usuario0_.versao as versao4_0_0_
from
usuario usuario0_
where
usuario0_.id=? for update
5.6. Mtodos de callback e auditores de entidades

Em algumas situaes especficas, podemos precisar escutar e reagir a alguns
eventos que acontecem no mecanismo de persistncia, como por exemplo
durante o carregamento de uma entidade, antes de persistir, depois de persistir,
etc.
A especificao JPA fornece duas formas para fazer isso: mtodos de callback
e auditores de entidades, tambm conhecidos como callback methods e entity
listeners.
Mtodos de callback
Podemos criar um mtodo na entidade, que ser chamado quando algum evento
ocorrer. Tudo que precisamos fazer anotar o mtodo com uma ou mais
anotaes de callback.
Neste exemplo, usaremos a entidade
controla a idade dos animais.
Animal
do sistema de uma fazenda, que
@Entity
@Table(name = "animal")
public class Animal {
private Long id;
private Date dataNascimento;
private Date dataUltimaAtualizacao;
private Integer idade;
www.algaworks.com
125
@Id
@GeneratedValue
return id;
}
this.id = id;
}
return nome;
}
this.nome = nome;
}
@Column(name = "data_nascimento", nullable = false)
public Date getDataNascimento() {
return dataNascimento;
}
public void setDataNascimento(Date dataNascimento) {
this.dataNascimento = dataNascimento;
}
@Column(name = "data_ultima_atualizacao", nullable = false)
public Date getDataUltimaAtualizacao() {
return dataUltimaAtualizacao;
}
public void setDataUltimaAtualizacao(Date dataUltimaAtualizacao) {
this.dataUltimaAtualizacao = dataUltimaAtualizacao;
}
@Transient
public Integer getIdade() {
return idade;
}
www.algaworks.com
126
public void setIdade(Integer idade) {

this.idade = idade;
}
@PostLoad
@PostPersist
@PostUpdate
public void calcularIdade() {
long idadeEmMillis = new Date().getTime()
- this.getDataNascimento().getTime();
this.setIdade((int) (idadeEmMillis / 1000d / 60 / 60 / 24 / 365));
}
}
Veja que temos uma propriedade transient (no persistida) chamada idade. Essa
propriedade calculada automaticamente nos eventos @PostLoad, @PostPersist
e @PostUpdate, atravs do mtodo calcularIdade. Esses eventos representam,
respectivamente: aps o carregamento de uma entidade no contexto de
persistncia, aps a persistncia de uma entidade e aps a atualizao de uma
entidade.
Vamos testar o evento @PostPersist com o cdigo abaixo:
tx.begin();
Calendar dataNascimento = Calendar.getInstance();
dataNascimento.set(2011, 2, 1);
Animal animal = new Animal();
animal.setNome("Mimosa");
animal.setDataNascimento(dataNascimento.getTime());
animal.setDataUltimaAtualizacao(new Date());
System.out.println("Idade antes de persistir: " + animal.getIdade());
manager.persist(animal);
System.out.println("Idade depois de persistir: " + animal.getIdade());
www.algaworks.com
127
tx.commit();
manager.close();
JpaUtil.close();
Analisando a sada da execuo, notamos que o clculo da idade do animal foi

feito apenas aps a persistncia da entidade.
Idade antes de persistir: null
Hibernate:
insert
into
animal
(data_nascimento, data_ultima_atualizacao, nome)
values
(?, ?, ?)
Idade depois de persistir: 2
As anotaes de callback possveis so: @PrePersist,

@PostRemove, @PreUpdate, @PostUpdate e @PostLoad.
@PreRemove, @PostPersist,
Auditores de entidades
Voc pode tambm definir uma classe auditora de entidade, ao invs de criar
mtodos de callback diretamente dentro da entidade.
Criaremos um evento para alterar a data de ltima atualizao do animal
automaticamente, antes da persistncia e atualizao, para que no haja
necessidade de informar isso no cdigo toda vez.
public class AuditorAnimal {
@PreUpdate
@PrePersist
public void alterarDataUltimaAtualizacao(Animal animal) {
animal.setDataUltimaAtualizacao(new Date());
}
}
www.algaworks.com
128
Precisamos anotar a entidade com

escutaro os eventos da entidade.
@EntityListeners,
informando as classes que
@Entity
@Table(name = "animal")
@EntityListeners(AuditorAnimal.class)
public class Animal {
...
}
Agora, no existe mais a necessidade de informar a data de ltima atualizao de

um animal. Ao persistir um animal, a data ser calculada automaticamente.
Calendar dataNascimento = Calendar.getInstance();
dataNascimento.set(2009, 8, 20);
Animal animal = new Animal();
animal.setNome("Campeo");
animal.setDataNascimento(dataNascimento.getTime());
manager.persist(animal);
5.7. Cache de segundo nvel

Caching um termo usado quando armazenamos objetos em memria para
acesso mais rpido no futuro. O cache de segundo nvel (L2) compartilhado
entre todos os EntityManagers da aplicao.
Para ativar o cache de segundo nvel, precisamos selecionar uma implementao
de cache e adicionar algumas configuraes no arquivo persistence.xml.
<persistence version="2.1"
xmlns="http://xmlns.jcp.org/xml/ns/persistence"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence
http://xmlns.jcp.org/xml/ns/persistence/persistence_2_1.xsd">
www.algaworks.com
129
<persistence-unit name="ErpPU">
<provider>org.hibernate.ejb.HibernatePersistence</provider>
<shared-cache-mode>ENABLE_SELECTIVE</shared-cache-mode>
<properties>
<property name="javax.persistence.jdbc.url"
value="jdbc:mysql://localhost/erp" />
<property name="javax.persistence.jdbc.user"
value="usuario" />
<property name="javax.persistence.jdbc.password"
value="senha" />
<property name="javax.persistence.jdbc.driver"
value="com.mysql.jdbc.Driver" />
<property name="hibernate.dialect"
value="org.hibernate.dialect.MySQL5Dialect" />
<property name="hibernate.show_sql" value="true" />
<property name="hibernate.format_sql" value="true" />
<property name="hibernate.hbm2ddl.auto" value="update" />
<property name="hibernate.cache.region.factory_class"
value="org.hibernate.cache.ehcache.SingletonEhCacheRegionFactory" />
</properties>
</persistence-unit>
</persistence>
Usaremos o EhCache, que j vem na distribuio do Hibernate. Definimos a

implementao do cache no elemento hibernate.cache.region.factory_class do
arquivo persistence.xml. Adicione os arquivos JAR da pasta lib/optional/ehcache no
classpath do projeto.
O elemento shared-cache-mode aceita alguns valores, que configuram o cache de
segundo nvel:
ENABLE_SELECTIVE
(padro): as entidades no so armazenadas no cache,

a menos que sejam explicitamente anotadas com @Cacheable(true).
DISABLE_SELECTIVE: as entidades
so armazenadas no cache, a menos que

sejam explicitamente anotadas com @Cacheable(false).
www.algaworks.com
130
ALL:
todas as entidades so sempre armazenadas no cache.
NONE:
nenhuma entidade armazenada no cache (desabilita o cache de

segundo nvel).
Para exemplificar o uso de cache de segundo nvel, criaremos uma entidade

CentroCusto. Considerando que o centro de custo de um sistema de gesto
empresarial algo que no se altera com frequncia, podemos definir que as
entidades podem ser adicionadas ao cache de segundo nvel, usando a anotao
@Cacheable(true).
@Entity
@Table(name = "centro_custo")
@Cacheable(true)
public class CentroCusto {
private static final long serialVersionUID = 1L;
private Long id;
@Id
@GeneratedValue
return id;
}
this.id = id;
}
return nome;
}
this.nome = nome;
}
}
www.algaworks.com
131
Para testar, iremos inserir alguns centros de custo.

tx.begin();
CentroCusto cc1 = new CentroCusto();
cc1.setNome("Tecnologia");
CentroCusto cc2 = new CentroCusto();
cc2.setNome("Comercial");
manager.persist(cc1);
manager.persist(cc2);
tx.commit();
manager.close();
JpaUtil.close();
Agora, fazemos duas consultas da mesma entidade em EntityManagers diferentes.

CentroCusto centro1 = manager1.find(CentroCusto.class, 1L);
System.out.println("Centro de custo: " + centro1.getNome());
manager1.close();
System.out.println("-----");
CentroCusto centro2 = manager2.find(CentroCusto.class, 1L);
System.out.println("Centro de custo: " + centro2.getNome());
manager2.close();
JpaUtil.close();
Apenas uma consulta SQL foi gerada, graas ao cache de segundo nvel.
Hibernate:
select
centrocust0_.id as id1_0_0_,
centrocust0_.nome as nome2_0_0_
from
centro_custo centrocust0_
www.algaworks.com
132
where
centrocust0_.id=?
Centro de custo: Tecnologia
----Centro de custo: Tecnologia
Vdeo aula sobre cache de segundo nvel

No blog da AlgaWorks tem uma vdeo aula gratuita que explica um pouco
mais sobre cache de segundo nvel, demonstrado em um projeto web com
JSF e CDI.
http://blog.algaworks.com/introducao-ao-cache-de-segundo-nivel-dojpa/
www.algaworks.com
133
Captulo 6
Java Persistence Query

Language
6.1. Introduo JPQL
Se voc quer consultar um objeto e j sabe o identificador dele, pode usar os
mtodos find ou getReference de EntityManager, como j vimos anteriormente.
Agora, caso o identificador seja desconhecido ou voc quer consultar uma
coleo de objetos, voc precisar de uma query.
A JPQL (Java Persistence Query Language) a linguagem de consulta padro da
JPA, que permite escrever consultas portveis, que funcionam independente do
banco de dados.
Esta linguagem de query usa uma sintaxe parecida com a SQL, para selecionar
objetos e valores de entidades e os relacionamentos entre elas.
Os exemplos desse captulo usaro as entidades mapeadas a seguir.
@Entity
@Table(name = "veiculo")
www.algaworks.com
134

private TipoCombustivel tipoCombustivel;
private Date dataCadastro;
private Set<Acessorio> acessorios = new HashSet<>();
@Id
@GeneratedValue
return codigo;
}
}
return fabricante;
}
}
return modelo;
}
}
}
}
www.algaworks.com
135
@Column(name = "ano_modelo", nullable = false)

return anoModelo;
}
}
return valor;
}
this.valor = valor;
}
@Enumerated(EnumType.STRING)
}
public void setTipoCombustivel(TipoCombustivel tipoCombustivel) {
this.tipoCombustivel = tipoCombustivel;
}
@Column(name = "data_cadastro", nullable = false)
public Date getDataCadastro() {
return dataCadastro;
}
public void setDataCadastro(Date dataCadastro) {
this.dataCadastro = dataCadastro;
}
@ManyToOne
}
www.algaworks.com
136
public void setProprietario(Proprietario proprietario) {

this.proprietario = proprietario;
}
@ManyToMany
@JoinTable(name = "veiculo_acessorios",
joinColumns = @JoinColumn(name = "cod_veiculo"),
inverseJoinColumns = @JoinColumn(name = "cod_acessorio"))
return acessorios;
}
public void setAcessorios(Set<Acessorio> acessorios) {
this.acessorios = acessorios;
}
}
public enum TipoCombustivel {
ALCOOL, GASOLINA, DIESEL, BICOMBUSTIVEL
}
@Entity
private List<Veiculo> veiculos;
@Id
@GeneratedValue
return codigo;
}
www.algaworks.com
137
}
@Column(name = "nome_proprietario", length = 60, nullable = false)
return nome;
}
this.nome = nome;
}
@Column(name = "telefone_proprietario", length = 20, nullable = false)
return telefone;
}
}
@Column(name = "email_proprietario", length = 255)
return email;
}
this.email = email;
}
@OneToMany(mappedBy = "proprietario")
public List<Veiculo> getVeiculos() {
return veiculos;
}
public void setVeiculos(List<Veiculo> veiculos) {
this.veiculos = veiculos;
}
}
www.algaworks.com
138
@Entity
@Table(name = "acessorio")
private Set<Veiculo> veiculos = new HashSet<>();
@Id
@GeneratedValue
return codigo;
}
}
return descricao;
}
}
@ManyToMany(mappedBy = "acessorios", cascade = CascadeType.PERSIST)
public Set<Veiculo> getVeiculos() {
return veiculos;
}
public void setVeiculos(Set<Veiculo> veiculos) {
this.veiculos = veiculos;
}
}
www.algaworks.com
139
6.2. Consultas simples e iterao no resultado

O mtodo EntityManager.createQuery usado para consultar entidades e valores
usando JPQL. J usamos esse mtodo para fazer consultas simples em outros
captulos, mas no exploramos os detalhes.
As consultas criadas atravs do mtodo createQuery so chamadas de consultas
dinmicas
dinmicas, pois elas so definidas diretamente no cdigo da aplicao.
"select v from Veiculo v where anoFabricacao = 2012");
List veiculos = query.getResultList();
for (Object obj : veiculos) {
Veiculo veiculo = (Veiculo) obj;
System.out.println(veiculo.getModelo() + " " + veiculo.getFabricante()
+ ": " + veiculo.getAnoFabricacao());
}
O mtodo createQuery retorna um objeto do tipo Query, que pode ser consultado
atravs de getResultList. Este mtodo retorna um List no tipado, por isso
fizemos um cast na iterao dos objetos.
A consulta JPQL que escrevemos seleciona todos os objetos veculos que
possuem o ano de fabricao igual a 2012.
select v from Veiculo v where anoFabricacao = 2012
Essa consulta o mesmo que:

from Veiculo where anoFabricacao = 2012
Veja que no somos obrigados a incluir a instruo

informar um alias para a entidade Veiculo.
www.algaworks.com
select
neste caso, e nem
140
6.3. Usando parmetros nomeados

Se voc precisar fazer uma consulta filtrando por valores informados pelo
usurio, no recomendado que faa concatenaes na string da consulta,
principalmente para evitar SQL Injection. O ideal que use parmetros da Query.
"from Veiculo where anoFabricacao >= :ano and valor <= :preco");
query.setParameter("ano", 2009);
query.setParameter("preco", new BigDecimal(60_000));
List veiculos = query.getResultList();
for (Object obj : veiculos) {
Veiculo veiculo = (Veiculo) obj;
}
Nomeamos os parmetros com um prefixo :, e atribumos os valores para cada

parmetro usando o mtodo setParameter de Query.
Veja a consulta SQL gerada:
Hibernate:
select
veiculo0_.cod_proprietario as cod_prop9_2_,
from
veiculo veiculo0_
where
veiculo0_.ano_fabricacao>=?
and veiculo0_.valor<=?
www.algaworks.com
141
6.4. Consultas tipadas

Quando fazemos uma consulta, podemos obter o resultado de um tipo especfico,
sem precisar fazer casting dos objetos ou at mesmo converses no checadas
para colees genricas.
TypedQuery<Veiculo> query = manager.createQuery("from Veiculo",
Veiculo.class);
}
Usamos a interface TypedQuery, que um subtipo de Query. A diferena que o

mtodo getResultList j retorna uma lista do tipo que especificamos na criao
da query, no segundo parmetro.
6.5. Paginao
Uma consulta que retorna muitos objetos pode ser um problema para a maioria
das aplicaes. Se existir a necessidade de exibir um conjunto de dados grande,
interessante implementar uma paginao de dados e deixar o usurio navegar
entre as pginas.
As interfaces
suportam paginao atravs dos mtodos

setFirstResult e setMaxResults, que define a posio do primeiro registro
(comeando de 0) e o nmero mximo de registros que podem ser retornados,
respectivamente.
Query
TypedQuery

Veiculo.class);
query.setFirstResult(0);
query.setMaxResults(10);
www.algaworks.com
142

}
No cdigo acima, definimos que queremos receber apenas os

registros.
10
primeiros
Agora, vamos criar algo mais dinmico, onde o usurio pode digitar o nmero
de registros por pgina e navegar entre elas.
Scanner scanner = new Scanner(System.in);
System.out.print("Registros por pgina: ");
int registrosPorPagina = scanner.nextInt();
int numeroDaPagina = 0;
Veiculo.class);
do {
System.out.print("Nmero da pgina: ");
numeroDaPagina = scanner.nextInt();
if (numeroDaPagina != 0) {
int primeiroRegistro = (numeroDaPagina - 1) * registrosPorPagina;
query.setFirstResult(primeiroRegistro);
query.setMaxResults(registrosPorPagina);
System.out.println(veiculo.getModelo() + " "
+ veiculo.getFabricante()
}
}
} while (numeroDaPagina != 0);
scanner.close();
manager.close();
JpaUtil.close();
www.algaworks.com
143
6.6. Projees
Projees uma tcnica muito til para quando precisamos de apenas algumas
poucas informaes de entidades. Dependendo de como o mapeamento feito, o
provedor JPA pode gerar uma query SQL grande e complexa para buscar o estado
da entidade, podendo deixar o sistema lento.
Suponha que precisamos listar apenas os modelos dos veculos que temos
armazenados. No h necessidade de outras informaes dos veculos.
Veiculo.class);
System.out.println(veiculo.getModelo());
}
Tendo em vista que precisamos apenas das descries dos modelos dos veculos,
essa consulta muito cara! Alm de executar uma query SQL buscando todas as
informaes de veculos, o provedor ainda executou outras queries para buscar os
proprietrios deles.
Hibernate:
select
from
veiculo veiculo0_
Hibernate:
select
proprietar0_.email_proprietario as email_pr2_1_0_,
www.algaworks.com
144
proprietar0_.nome_proprietario as nome_pro3_1_0_,
proprietar0_.telefone_proprietario as telefone4_1_0_
from
where
Hibernate:
select
from
where
Podemos projetar apenas a propriedade da entidade que nos interessa usando a

clusula select.
TypedQuery<String> query = manager.createQuery(
"select modelo from Veiculo", String.class);
List<String> modelos = query.getResultList();
for (String modelo : modelos) {
System.out.println(modelo);
}
A query SQL executada muito mais simples:

Hibernate:
select
veiculo0_.modelo as col_0_0_
from
veiculo veiculo0_
www.algaworks.com
145
6.7. Resultados complexos e o operador new

Quando uma query projeta mais de uma propriedade ou expresso na clusula
select, o resultado da consulta um List, ou seja, uma lista de vetores de objetos.
Em nosso exemplo, buscaremos todos os nomes e valores de veculos, e
precisaremos trabalhar com posies de arrays para separar cada informao.
TypedQuery<Object[]> query = manager.createQuery(
"select modelo, valor from Veiculo", Object[].class);
List<Object[]> resultado = query.getResultList();
for (Object[] valores : resultado) {
String modelo = (String) valores[0];
BigDecimal valor = (BigDecimal) valores[1];
System.out.println(modelo + " - " + valor);
}
O operador new
Trabalhar com vetores de objetos no nada agradvel, propenso a erros e
deixa o cdigo muito feio. Podemos criar uma classe para representar o resultado
da consulta, com os atributos que desejamos e um construtor que recebe como
parmetro os dois valores.
public class PrecoVeiculo {
public PrecoVeiculo(String modelo, BigDecimal valor) {
super();
this.valor = valor;
}
// getters e setters
}
www.algaworks.com
146
Agora, basta usarmos o operador new na query JPQL, informando o nome

completo da classe que criamos para representar o resultado da consulta
(incluindo o nome do pacote) e passando como parmetro do construtor as
propriedades modelo e valor.
TypedQuery<PrecoVeiculo> query = manager.createQuery(
"select new com.algaworks.vo.PrecoVeiculo(modelo, valor) from Veiculo",
PrecoVeiculo.class);
List<PrecoVeiculo> precos = query.getResultList();
for (PrecoVeiculo preco : precos) {
System.out.println(preco.getModelo() + " - " + preco.getValor());
}
A consulta SQL no muda em nada, mas o provedor JPA instancia e retorna

objetos do tipo que especificamos.
6.8. Funes de agregao

A sintaxe para funes de agregao em JPQL similar a SQL. Voc pode usar
as funes avg, count, min, max e sum, e agrupar os resultados com a clusula group
by.
Para nosso exemplo, criaremos uma classe chamada

representar o resultado da consulta.
TotalCarroPorAno,
para
public class TotalCarroPorAno {

private Double mediaPreco;
private Long quantidadeCarros;
public TotalCarroPorAno(Integer anoFabricacao, Double mediaPreco,
Long quantidadeCarros) {
super();
this.mediaPreco = mediaPreco;
this.quantidadeCarros = quantidadeCarros;
}
www.algaworks.com
147
}
Na query JPQL, usamos as funes de agregao

group by.
avg
count,
alm da clusula
TypedQuery<TotalCarroPorAno> query = manager.createQuery(

"select new com.algaworks.vo.TotalCarroPorAno(v.anoFabricacao, "
+ "avg(v.valor), count(v)) "
+ "from Veiculo v group by v.anoFabricacao", TotalCarroPorAno.class);
List<TotalCarroPorAno> resultado = query.getResultList();
for (TotalCarroPorAno valores : resultado) {
System.out.println("Ano: " + valores.getAnoFabricacao()
+ " - Preo mdio: " + valores.getMediaPreco()
+ " - Quantidade: " + valores.getQuantidadeCarros());
}
Veja a consulta SQL executada pelo provedor JPA:

Hibernate:
select
veiculo0_.ano_fabricacao as col_0_0_,
avg(veiculo0_.valor) as col_1_0_,
count(veiculo0_.codigo) as col_2_0_
from
veiculo veiculo0_
group by
veiculo0_.ano_fabricacao
6.9. Queries que retornam um resultado nico

As interfaces Query e TypedQuery fornecem o mtodo getSingleResult, que deve
ser usado quando estamos esperando que a consulta retorne apenas um
resultado.
TypedQuery<Long> query = manager.createQuery(
"select count(v) from Veiculo v", Long.class);
www.algaworks.com
148
Long quantidadeVeiculos = query.getSingleResult();

System.out.println("Quantidade de veculos: " + quantidadeVeiculos);
O cdigo acima busca a quantidade de veculos cadastrados e atribui varivel

quantidadeVeiculos, do tipo Long.
6.10. Associaes e joins

Quando precisamos combinar resultados de mais de uma entidade, precisamos
usar join. Os joins da JPQL so equivalentes aos da SQL, com a diferena que, em
JPQL, trabalhamos com entidades, e no tabelas.
Inner join
Para fazer inner join entre duas entidades, podemos usar o operador
no relacionamento entre elas.
inner join
Queremos buscar todos os proprietrios que possuem veculos. Veja o exemplo:

TypedQuery<Proprietario> query = manager.createQuery(
"select p from Proprietario p inner join p.veiculos v",
Proprietario.class);
List<Proprietario> proprietarios = query.getResultList();
for (Proprietario proprietario : proprietarios) {
System.out.println(proprietario.getNome());
}

Hibernate:
select
proprietar0_.codigo as codigo1_1_,
proprietar0_.email_proprietario as email_pr2_1_,
proprietar0_.nome_proprietario as nome_pro3_1_,
proprietar0_.telefone_proprietario as telefone4_1_
from
www.algaworks.com
149
inner join
veiculo veiculos1_
on proprietar0_.codigo=veiculos1_.cod_proprietario
Se um proprietrio possuir dois ou mais veculos, ele repetir no resultado da

consulta, por isso, melhor usarmos o operador distinct.
select distinct p
from Proprietario p
inner join p.veiculos v
Veja outra forma de fazer a consulta retornar o mesmo resultado:

select distinct p
from Veiculo v
inner join v.proprietario p
Left join
Em nosso prximo exemplo, consultaremos a quantidade de veculos que cada
proprietrio possui. Usamos a funo de agregao count e a clusula group by,
que j estudamos anteriormente.
TypedQuery<Object[]> query = manager.createQuery(
"select p.nome, count(v) from Proprietario p "
+ "inner join p.veiculos v group by p.nome", Object[].class);
System.out.println(valores[0] + " - " + valores[1]);
}

Hibernate:
select
proprietar0_.nome_proprietario as col_0_0_,
count(veiculos1_.codigo) as col_1_0_
from
inner join
www.algaworks.com
150
veiculo veiculos1_
group by
proprietar0_.nome_proprietario
Nossa query funciona muito bem para proprietrios que possuem veculos, mas
aqueles que no possuem, no aparecem no resultado da consulta. Queremos
exibir tambm os nomes de proprietrios que no possuem nenhum veculo, pois
algum pode ter excludo do sistema ou ele j pode ter vendido seu veculo, mas
o cadastro continua ativo. Por isso, precisamos usar o operador left join.
select p.nome, count(v)
from Proprietario p
left join p.veiculos v
group by p.nome
Agora sim, a query SQL gerada retorna tambm os proprietrios sem veculos.
Hibernate:
select
proprietar0_.nome_proprietario as col_0_0_,
count(veiculos1_.codigo) as col_1_0_
from
left outer join
veiculo veiculos1_
group by
proprietar0_.nome_proprietario
Problema do N+1
Um problema bastante conhecido o Problema N+1
N+1. Esse anti-pattern ocorre
quando pesquisamos entidades e seus relacionamentos tambm so carregados
na sequncia. Cada objeto retornado gera pelo menos mais uma nova consulta
para pesquisar os relacionamentos. Veja um exemplo:
TypedQuery<Veiculo> query = manager.createQuery("from Veiculo v",
Veiculo.class);
www.algaworks.com
151

}
Embora esse cdigo funcione, ele extremamente ineficiente, pois diversas

consultas SQL so geradas para buscar o proprietrio do veculo.
Hibernate:
select
from
veiculo veiculo0_
Hibernate:
select
from
where
Hibernate:
select
from
where
...
www.algaworks.com
152
...
...
Para solucionar o problema, podemos usar os operadores inner join

fazer join com a entidade Proprietario e trazer os dados na consulta.
fetch
para
TypedQuery<Veiculo> query = manager.createQuery(

"from Veiculo v inner join fetch v.proprietario", Veiculo.class);
}
Agora, apenas um comando SQL executado, deixando nosso cdigo muito mais
eficiente.
Hibernate:
select
veiculo0_.cod_proprietario as cod_prop9_2_0_,
from
veiculo veiculo0_
inner join
on veiculo0_.cod_proprietario=proprietar1_.codigo
www.algaworks.com
153
Vdeo aula sobre o Problema do N+1

No blog da AlgaWorks tem uma vdeo aula gratuita sobre o Problema do
N+1
N+1, com uma simulao do problema e a correo dele em um projeto
web.
http://blog.algaworks.com/o-problema-do-n-mais-um/
6.11. Queries nomeadas

As queries nomeadas, tambm conhecidas como named queries, uma forma
de organizar as consultas JPQL que escrevemos em nossas aplicaes. Alm
de organizar as queries, ganhamos em performance, pois elas so estticas e
processadas apenas na inicializao da unidade de persistncia.
Uma named query definida com a anotao @NamedQuery, que pode ser colocada
na declarao da classe de qualquer entidade JPA. A anotao recebe o nome da
query e a prpria consulta JPQL.
@Entity
@NamedQuery(name = "Veiculo.comProprietarioPorValor",
query = "from Veiculo v "
+ "inner join fetch v.proprietario where v.valor > :valor")
...
}
Para facilitar e evitar conflitos, nomeamos a query com um prefixo Veiculo,

dizendo que a consulta est relacionada a essa entidade.
Para usar uma named query, chamamos o mtodo
EntityManager.
www.algaworks.com
createNamedQuery
de
154
TypedQuery<Veiculo> query = manager.createNamedQuery(

"Veiculo.comProprietarioPorValor", Veiculo.class);
query.setParameter("valor", new BigDecimal(10_000));
}
Para definir mais de uma named query em uma entidade, podemos agrup-las
com a anotao @NamedQueries.
@Entity
@NamedQueries({
@NamedQuery(name = "Veiculo.comProprietarioPorValor",
query = "from Veiculo v "
+ "inner join fetch v.proprietario where v.valor > :valor"),
@NamedQuery(name = "Veiculo.porModelo",
query = "from Veiculo where modelo like :modelo")
})
...
}
Queries nomeadas em arquivos externos

Voc j viu que definir named queries fcil, deixa nosso cdigo mais limpo
e ganhamos performance. Se voc quiser organizar ainda mais, eliminando
totalmente as queries de cdigo Java, pode externaliz-las para arquivos XML.
Podemos criar um arquivo chamado orm.xml em META-INF com o seguinte
contedo:
<entity-mappings xmlns="http://xmlns.jcp.org/xml/ns/persistence/orm"
xsi:schemaLocation="http://xmlns.jcp.org/xml/ns/persistence/orm
www.algaworks.com
155
http://xmlns.jcp.org/xml/ns/persistence/orm_2_1.xsd"
version="2.1">
<named-query name="Veiculo.anoFabricacaoMenor">
<query><![CDATA[
from Veiculo where anoFabricacao < :ano
]]></query>
</named-query>
</entity-mappings>
No
arquivo
acima,
definimos
uma
named
query
chamada
Veiculo.anoFabricacaoMenor, e podemos us-la normalmente.
Vdeo aula sobre named queries em arquivos externos

Para no ficar qualquer dvida, assista a vdeo aula gratuita no blog da
AlgaWorks que explica passo a passo como usar named queries em arquivos
externos.
http://blog.algaworks.com/named-queries-em-arquivos-externos/
6.12. Queries SQL nativas

JPQL flexvel suficiente para executar quase todas as queries que voc precisar,
e tem a vantagem de usar o modelo de objetos mapeados. Existem alguns casos
bastante especficos, em que voc precisar utilizar SQL nativo para consultar seu
banco de dados.
No exemplo abaixo, pesquisamos todos os veculos usando SQL, que retorna
entidades gerenciadas pelo contexto de persistncia.
Query query = manager.createNativeQuery("select * from veiculo",
Veiculo.class);
www.algaworks.com
156

}
As colunas retornadas pela query devem coincidir com os nomes definidos no

mapeamento. possvel configurar o mapeamento do result set usando
@SqlResultSetMapping,
www.algaworks.com
mas no entraremos em detalhes.
157
Captulo 7
Criteria API
7.1. Introduo e estrutura bsica
A Criteria API da JPA usada para definir queries dinmicas, criadas a partir
de objetos que definem uma consulta, ao invs de puramente texto, como a
JPQL. A principal vantagem da Criteria API poder construir consultas
programaticamente, de forma elegante e com maior integrao com a linguagem
Java.
Vamos comear com uma das consultas mais simples que poderamos fazer
usando Criteria API.
CriteriaBuilder builder =
manager.getCriteriaBuilder();
CriteriaQuery<Veiculo> criteriaQuery = builder.createQuery(Veiculo.class);

Root<Veiculo> veiculo = criteriaQuery.from(Veiculo.class);
criteriaQuery.select(veiculo);
TypedQuery<Veiculo> query = manager.createQuery(criteriaQuery);
for (Veiculo v : veiculos) {
System.out.println(v.getModelo());
}
A consulta acima busca todos os veculos cadastrados e imprime o modelo deles.

Seria o mesmo que fazer em JPQL:
www.algaworks.com
158
from Veiculo
Claro que, em uma consulta simples como essa, seria melhor usarmos JPQL, mas
voc conhecer a facilidade da API, em alguns casos, mais a frente.
Primeiramente,
pegamos
uma
instncia
do
tipo
CriteriaBuilder
do
EntityManager,
atravs do mtodo getCriteriaBuilder. Essa interface funciona

como uma fbrica de vrios objetos que podemos usar para definir uma consulta.
Usamos o mtodo createQuery de CriteriaBuilder para instanciar um
CriteriaQuery. A interface CriteriaQuery possui as clusulas da consulta.
Chamamos o mtodo from de CriteriaQuery para obtermos um objeto do tipo
Root. Depois, chamamos o mtodo da clusula select, informando como
parmetro o objeto do tipo
Veiculo.
Root,
dizendo que queremos selecionar a entidade
Criamos uma TypedQuery atravs do mtodo EntityManager.createQuery, e depois

recuperamos o resultado da consulta pelo mtodo getResultList.
Bastante burocrtico, n? Mas esse o preo que pagamos para ter uma API
muito dinmica.
7.2. Filtros e queries dinmicas

A clusula where uma parte importante de consultas, pois definem as condies
(predicados) que filtram o resultado.
Para filtrar o resultado usando Criteria API, precisamos de objetos do tipo
Predicate, para passar para a clusula where. Um objeto do tipo Predicate
obtido atravs do CriteriaBuilder.
No exemplo abaixo, consultamos todos os veculos que o tipo de combustvel no
seja desel.
www.algaworks.com
159

Predicate predicate = builder.not(builder.equal(veiculo.get("tipoCombustivel"),
TipoCombustivel.DIESEL));
criteriaQuery.where(predicate);
}
Queries dinmicas
A grande vantagem de Criteria API poder criar queries dinmicas, com filtros
condicionais, por exemplo. Neste caso, no sabemos qual ser a estrutura final da
consulta, pois ela montada em tempo de execuo.
No exemplo abaixo, criamos um mtodo pesquisarVeiculos que retorna uma lista
de veculos, dado o tipo do combustvel e o valor mximo. permitido passar
null para qualquer um dos parmetros do mtodo, portanto, os filtros da query
devem ser montados programaticamente.
public static List<Veiculo> pesquisarVeiculos(
TipoCombustivel tipoCombustivel, BigDecimal maiorValor) {
CriteriaQuery<Veiculo> criteriaQuery = builder.createQuery(

Veiculo.class);
List<Predicate> predicates = new ArrayList<>();
if (tipoCombustivel != null) {
ParameterExpression<TipoCombustivel> paramTipoCombustivel =
builder.parameter(TipoCombustivel.class, "tipoCombustivel");
predicates.add(builder.equal(veiculo.get("tipoCombustivel"),
www.algaworks.com
160
paramTipoCombustivel));
}
if (maiorValor != null) {
ParameterExpression<BigDecimal> paramValor = builder.parameter(
BigDecimal.class, "maiorValor");
predicates.add(builder.lessThanOrEqualTo(
veiculo.<BigDecimal>get("valor"), paramValor));
}
criteriaQuery.where(predicates.toArray(new Predicate[0]));
if (tipoCombustivel != null) {
query.setParameter("tipoCombustivel", tipoCombustivel);
}
if (maiorValor != null) {
query.setParameter("maiorValor", maiorValor);
}
manager.close();
return veiculos;
}
List<Veiculo> veiculos = pesquisarVeiculos(
TipoCombustivel.BICOMBUSTIVEL, new BigDecimal(50_000));
System.out.println(v.getModelo() + " - " + v.getValor());
}
}
Aproveitamos o exemplo para mostrar tambm o uso de parmetros, usando

o mtodo CriteriaBuilder.parameter, que recebe como argumento o tipo do
parmetro e o nome dele, que depois definido pelo mtodo
TypedQuery.setParameter.
www.algaworks.com
161
7.3. Projees
Suponha que precisamos listar apenas os modelos dos veculos que temos
armazenados. Podemos projetar essa propriedade chamando o mtodo Root.get
e passando para a clusula select.
CriteriaQuery<String> criteriaQuery = builder.createQuery(String.class);

criteriaQuery.select(veiculo.<String>get("modelo"));
TypedQuery<String> query = manager.createQuery(criteriaQuery);
List<String> modelos = query.getResultList();
for (String modelo : modelos) {
System.out.println(modelo);
}
7.4. Funes de agregao

As funes de agregao so representadas por mtodos de CriteriaBuilder,
incluindo max, greatest, min, least, avg, sum, sumAsLong, sumAsDouble, count e
countDistinct.
No exemplo abaixo, buscamos a soma dos valores de todos os veculos
armazenados.
CriteriaQuery<BigDecimal> criteriaQuery = builder.createQuery(

BigDecimal.class);
criteriaQuery.select(builder.sum(veiculo.<BigDecimal>get("valor")));
TypedQuery<BigDecimal> query = manager.createQuery(criteriaQuery);
BigDecimal total = query.getSingleResult();
System.out.println("Valor total: " + total);
www.algaworks.com
162
7.5. Resultados complexos, tuplas e construtores

Quando projetamos mais de uma propriedade em uma consulta, podemos
configurar como desejamos receber o resultado, sendo: uma lista de Object[],
uma lista de Tuple ou uma lista de um objeto de uma classe qualquer.
Lista de Object[]
No exemplo abaixo, projetamos duas propriedades de Veiculo usando o mtodo
multiselect de CriteriaQuery e obtemos o resultado da consulta como um List.
CriteriaQuery<Object[]> criteriaQuery = builder.createQuery(Object[].class);

criteriaQuery.multiselect(veiculo.<String>get("modelo"),
veiculo.<String>get("valor"));
TypedQuery<Object[]> query = manager.createQuery(criteriaQuery);
System.out.println(valores[0] + " - " + valores[1]);
}
Lista de tuplas
Trabalhar com ndices de arrays deixa o cdigo feio e a chance de errar muito
maior. Podemos retornar um array de Tuple, onde cada tupla representa um
registro encontrado.
CriteriaQuery<Tuple> criteriaQuery = builder.createTupleQuery();

criteriaQuery.multiselect(
veiculo.<String>get("modelo").alias("modeloVeiculo"),
veiculo.<String>get("valor").alias("valorVeiculo"));
TypedQuery<Tuple> query = manager.createQuery(criteriaQuery);
www.algaworks.com
163
List<Tuple> resultado = query.getResultList();

for (Tuple tupla : resultado) {
System.out.println(tupla.get("modeloVeiculo")
+ " - " + tupla.get("valorVeiculo"));
}
Veja que chamamos o mtodo createTupleQuery para receber uma instncia de

CriteriaQuery e apelidamos cada propriedade projetada com o mtodo alias.
Esses apelidos foram usados na iterao, atravs do mtodo get da tupla.
Construtores
O jeito mais elegante de retornar um resultado projetado criando uma classe
para representar os valores de cada tupla, com um construtor que recebe os
valores e atribui s variveis de instncia.
public class PrecoVeiculo {
public PrecoVeiculo(String modelo, BigDecimal valor) {
super();
this.valor = valor;
}
}
Depois, basta criar a consulta e passar como parmetro do mtodo select o

retorno de CriteriaBuilder.construct. Este ltimo mtodo deve receber a classe
de retorno e as propriedades projetadas.
CriteriaQuery<PrecoVeiculo> criteriaQuery = builder

.createQuery(PrecoVeiculo.class);
www.algaworks.com
164

criteriaQuery.select(builder.construct(PrecoVeiculo.class,
veiculo.<String>get("modelo"), veiculo.<String>get("valor")));
TypedQuery<PrecoVeiculo> query = manager.createQuery(criteriaQuery);
List<PrecoVeiculo> resultado = query.getResultList();
for (PrecoVeiculo tupla : resultado) {
System.out.println(tupla.getModelo() + " - " + tupla.getValor());
}
7.6. Funes
A Criteria API suporta diversas funes de banco de dados, que esto definidas
em CriteriaBuilder.
No exemplo abaixo, usamos a funo upper para passar o modelo do veculo para
maisculo e fazer uma comparao case-insensitive.

Predicate predicate = builder.equal(builder.upper(
veiculo.<String>get("modelo")), "i30".toUpperCase());
criteriaQuery.where(predicate);
}
J no prximo exemplo, programamos uma consulta que retorna uma lista de

strings, com o fabricante e modelo concatenados e separados pelo caractere -.
CriteriaQuery<String> criteriaQuery = builder.createQuery(String.class);
www.algaworks.com
165

Expression<String> expression = builder.concat(builder.concat(
veiculo.<String> get("fabricante"), " - "),
veiculo.<String> get("modelo"));
criteriaQuery.select(expression);
TypedQuery<String> query = manager.createQuery(criteriaQuery);
List<String> veiculos = query.getResultList();
for (String v : veiculos) {
System.out.println(v);
}
7.7. Ordenao de resultado

Para ordenar o resultado de uma consulta, podemos usar o mtodo orderBy, de
CriteriaQuery. Precisamos passar como parmetro para esse mtodo um objeto
do tipo Order, que instanciado usando CriteriaBuilder.desc, para ordenao
decrescente. Poderamos usar asc para ordenao crescente.

Order order = builder.desc(veiculo.<String>get("anoFabricacao"));
criteriaQuery.orderBy(order);
System.out.println(v.getModelo() + " - " + v.getAnoFabricacao());
}
www.algaworks.com
166
7.8. Join e fetch

Para fazer join entre duas entidades, podemos usar seus relacionamentos
mapeados. No exemplo abaixo, chamamos o mtodo join de um objeto do tipo
From. Depois, filtramos a consulta a partir da entidade usada pelo join.

Join<Veiculo, Proprietario> proprietario = veiculo.join("proprietario");
criteriaQuery.where(builder.equal(proprietario.get("nome"), "Joo"));
System.out.println(v.getModelo() + " - " + v.getProprietario().getNome());
}
Fetch
Para evitar o Problema N+1
N+1, que j estudamos anteriormente, podemos fazer um
fetch no relacionamento da entidade Veiculo.

Join<Veiculo, Proprietario> proprietario = (Join) veiculo.fetch(
"proprietario");
criteriaQuery.where(builder.equal(proprietario.get("nome"), "Joo"));
www.algaworks.com
167
System.out.println(v.getModelo() + " - "

+ v.getProprietario().getNome());
}
Todos os dados necessrios so retornados por apenas uma consulta SQL:

Hibernate:
select
veiculo0_.cod_proprietario as cod_prop9_2_0_,
from
veiculo veiculo0_
inner join
on veiculo0_.cod_proprietario=proprietar1_.codigo
where
proprietar1_.nome_proprietario=?
7.9. Subqueries
Subqueries podem ser usadas pela Criteria API nas clusulas select, where, order,
group
by
having.
Para
criar
uma
subquery,
chamamos
mtodo
CriteriaQuery.subquery.
No exemplo abaixo, consultamos os veculos que possuem valores a partir do

valor mdio de todos os veculos armazenados.
www.algaworks.com
168
Subquery<Double> subquery = criteriaQuery.subquery(Double.class);

Root<Veiculo> veiculoA = criteriaQuery.from(Veiculo.class);
Root<Veiculo> veiculoB = subquery.from(Veiculo.class);
subquery.select(builder.avg(veiculoB.<Double>get("valor")));
criteriaQuery.select(veiculoA);
criteriaQuery.where(builder.greaterThanOrEqualTo(
veiculoA.<Double>get("valor"), subquery));
System.out.println(v.getModelo() + " - " + v.getProprietario().getNome());
}

select
from
veiculo veiculo0_
where
veiculo0_.valor>=(
select
avg(veiculo1_.valor)
from
veiculo veiculo1_
)
www.algaworks.com
169
7.10. Metamodel
A JPA define um metamodelo que pode ser usado em tempo de execuo para
obter informaes sobre o mapeamento ORM feito. Esse metamodelo inclui a
lista das propriedades mapeadas de uma entidade, seus tipos e cardinalidades.
O metamodelo pode ser usado com Criteria API, para substituir as strings que
referenciam propriedades.
O uso de metamodelo evita erros em tempo de execuo, pois qualquer alterao
no cdigo-fonte de mapeamento altera tambm o metamodelo.
Podemos gerar o metamodel automaticamente. Para isso, precisamos configurar o
Hibernate Metamodel Generator
Generator.
No Eclipse, acesse as propriedades do projeto, encontre Java Compiler e depois
Annotation Processing
Processing. Deixe as opes como a tela abaixo:
Abra o menu Annotation Processing e clique em Factory Path

Path. Adicione o
arquivo JAR hibernate-jpamodelgen-x.x.x.Final.jar, depois, clique em OK
OK. Esse
arquivo distribudo junto com o Hibernate ORM e fica na pasta lib/jpametamodel-generator.
www.algaworks.com
170
Agora, podemos referenciar as propriedades das entidades atravs das classes

geradas. Por exemplo, podemos usar as classes Veiculo_ e Proprietario_.

Join<Veiculo, Proprietario> proprietario = veiculo.join(
Veiculo_.proprietario);
criteriaQuery.where(builder.equal(proprietario.get(Proprietario_.nome),
"Joo"));
Tente alterar o nome de uma propriedade que est sendo usada na consulta,
diretamente na classe da entidade, e veja que um erro de compilao ir aparecer,
deixando evidente que existe um problema na consulta.
www.algaworks.com
171
Captulo 8
Concluso
Chegamos ao final desse livro!
Ns esperamos que voc tenha praticado e aprendido vrios truques sobre JPA e
Hibernate.
Se voc gostou desse livro, por favor, nos ajude a manter esse trabalho.
Recomende o livro para seus amigos de trabalho, faculdade e/ou compartilhe no
Facebook e Twitter.
8.1. Prximos passos

Embora a gente tenha dedicado bastante para escrever esse livro, o contedo que
voc aprendeu nele s a ponta do iceberg!
claro que voc no perdeu tempo com o que acabou de estudar, mas o que
queremos dizer que h muito mais coisas importantes para aprofundar em JPA
e Hibernate.
Caso voc tenha interesse em mergulhar fundo em contedos ainda mais
avanados, recomendo que voc d uma olhada em nosso curso online:
JPA e Hibernate alm do bsico - um projeto completo
http://www.algaworks.com/curso/jpa-e-hibernate/
www.algaworks.com
172
Alm de tudo que voc vai aprender, ns ainda oferecemos suporte para as suas
dvidas!
www.algaworks.com
173

Algaworks Ebook Jpa e Hibernate 1a Edicao 20150731

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Algaworks Ebook Jpa e Hibernate 1a Edicao 20150731

Caricato da

Copyright:

Formati disponibili

JPA e Hibernate

por Thiago Faria e Normandes Junior

2015 AlgaWorks Softwares, Treinamentos e Servios Ltda. Todos os direitos

Siga-nos nas redes sociais e fique por dentro de tudo!

Normandes Jos Moreira Junior

O que voc precisa saber?

Como obter ajuda?

Comunidade Java da AlgaWorks no Facebook

Como sugerir melhorias ou reportar erros no livro?

Ajude na continuidade desse trabalho

O que persistncia? ................................................................................. 13

Mapeamento Objeto Relacional (ORM) .................................................. 13

Porque usar ORM? ..................................................................................... 15

Java Persistence API e Hibernate ............................................................. 16

2 Primeiros passos com JPA e Hibernate

Download e configurao do Hibernate ORM ...................................... 17

Criao do Domain Model ....................................................................... 19

Implementao do equals() e hashCode() .............................................. 21

Mapeamento bsico ................................................................................... 22

O arquivo persistence.xml ........................................................................ 24

Gerando as tabelas do banco de dados ................................................... 26

Definindo detalhes fsicos de tabelas ...................................................... 27

Criando EntityManager ............................................................................ 30

Persistindo objetos ..................................................................................... 31

2.10 Buscando objetos pelo identificador ....................................................... 34

Estados e ciclo de vida .............................................................................. 42

Contexto de persistncia ........................................................................... 44

Sincronizao de dados ............................................................................. 46

Salvando objetos desanexados com merge() ......................................... 49

Chaves compostas ...................................................................................... 54

Propriedades temporais ............................................................................ 58

Propriedades transientes .......................................................................... 59

Objetos grandes .......................................................................................... 60

Objetos embutidos ..................................................................................... 64

Associaes um-para-um .......................................................................... 67

Associaes muitos-para-um ................................................................... 75

4.10 Colees um-para-muitos ......................................................................... 77

Lazy loading e eager loading ................................................................. 105

Operaes em cascata .............................................................................. 113

Excluso de objetos rfos ...................................................................... 117

Operaes em lote .................................................................................... 118

Concorrncia e locking ............................................................................ 121

Mtodos de callback e auditores de entidades .................................... 125

Cache de segundo nvel .......................................................................... 129

6 Java Persistence Query Language

Introduo JPQL ................................................................................... 134

Consultas simples e iterao no resultado ........................................... 140

Usando parmetros nomeados .............................................................. 141

Consultas tipadas ..................................................................................... 142

Paginao .................................................................................................. 142

Projees .................................................................................................... 144

Resultados complexos e o operador new ............................................. 146

Funes de agregao .............................................................................. 147

Queries que retornam um resultado nico .......................................... 148

6.10 Associaes e joins ................................................................................... 149

Introduo e estrutura bsica ................................................................. 158

Filtros e queries dinmicas ..................................................................... 159

Projees .................................................................................................... 162

Funes de agregao .............................................................................. 162

Resultados complexos, tuplas e construtores ...................................... 163

Funes ...................................................................................................... 165

Ordenao de resultado .......................................................................... 166

Join e fetch ................................................................................................. 167