Escolar Documentos
Profissional Documentos
Cultura Documentos
Hibernate
Porque JPA? uma questo fundamental para muitos desenvolvedores
Java. Por que eu preciso saber como usar essa API quando as
ferramentas de mapeamento Objeto-Relacional como o Hibernate e
Toplink esto disponveis? A resposta que JPA no uma nova
tecnologia, mas sim, que tenha colhido as melhores ideias de tecnologias
de persistncia existentes, como Hibernate, TopLink, e JDO. O resultado
uma especificao padronizada que ajuda a construir uma camada de
persistncia que independente de qualquer provedor de persistncia
particular. Java Persistence API baseia-se nas principais ideias dos
frameworks de persistncia principais e APIs como Hibernate, TopLink da
Oracle e Java Data Objects (JDO), e assim como na primeira EJB
persistncia gerenciada por recipiente.
Verso 1.0
Apostila destinada ao curso com carga horria de 32 (trinta e duas) horas
Sumrio
1. Java Persistence API (JPA)....................................................................................................3
Caractersticas da APP..........................................................................................................3
Vantagens da APP.................................................................................................................4
Modelo de Domnio................................................................................................................4
2. Design Patterns para Persistncia.........................................................................................6
Modelos de Domnio..............................................................................................................6
Design Pattern DAO............................................................................................................7
Design Pattern PathProxy...................................................................................................7
Design Pattern Composite..................................................................................................8
3. Mapeamento Objeto Relacional.............................................................................................9
Conceitos Chaves..................................................................................................................9
Atributos de mapeamento para colunas................................................................................9
Classes de mapeamento para as tabelas...........................................................................10
Utilizar uma entidade de dados para uma hierarquia de classe.....................................10
Utilizar uma entidade de dados por classe concreta.......................................................11
Utilizar uma entidade de dados por classe.....................................................................12
Mapeando Associaes, Agregao e Composio.......................................................13
Relaes de aplicao em bancos de dados relacionais....................................................13
Implementar relacionamentos muitos para muitos...........................................................13
4. JPQL.....................................................................................................................................14
Estrutura de consulta JPQL.................................................................................................14
Uma consulta minima JPQL................................................................................................15
Outros exemplos..............................................................................................................15
5. Consultas: Criteria................................................................................................................16
Construindo uma consulta Criteria.......................................................................................16
6. Validao e Integridade........................................................................................................18
Grupos de validao............................................................................................................18
7. SQL Nativo...........................................................................................................................20
8. Recursos Avanados: Cache e Locks..................................................................................22
Concorrncia Otimista..........................................................................................................23
Concorrncia pessimista......................................................................................................23
9. Hibernate..............................................................................................................................24
10. Erros Comuns....................................................................................................................26
Dados modelo de definio: O problema com os metadados.............................................26
Dados definio do objeto: A mania Setter e Getter............................................................26
Usar a identidade do aplicativo pode causar um comportamento estranho.......................27
Erros de conexo ao retornar instncias persistentes de um Session Bean......................27
Relaes se perdem aps um Commit................................................................................27
Consideraes Finais...........................................................................................................28
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
2 de 28
A linguagem de consulta
JDO JPA
Objetos Java
Sim
No
Sim
Sim
Sim
Sim Sim
Conceitos avanados de OO
Sim
No
Sim
Sim
No
Sim Sim
Integridade Transacional
No
Sim
Sim
Sim
Sim
Sim Sim
Concorrncia
No
Sim
Sim
Sim
Sim
Sim Sim
No
Sim
Sim
Sim
Sim
Sim Sim
Existncia de Esquemas
No
Sim
Sim
No
Sim
Sim Sim
Relacional e No-Relacional
No
No
No No
Sim
Sim No
Consultas
No
Sim
Sim
Sim
Sim
Sim Sim
Sim
No
No No
Sim
Sim Sim
Simplicidade
Sim
Sim
Sim
No
Sim Sim
Sim
Caractersticas da APP
JPA um framework leve baseado em POJO para mapeamento objeto-relacional.
Anotaes da linguagem Java ou metadados XML do descritor de implantao usado para
o mapeamento entre os objetos Java e um banco de dados relacional. Permite que a
linguagem de consulta SQL funcione tanto de maneira esttica como em consultas
dinmicas. Permite tambm que o uso da API persistncia conectvel. Java Persistence API
so depende, principalmente, anotaes de metadados. API inclui:
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
3 de 28
Anotaes de metadados
Vantagens da APP
JPA se aproveita das melhores ideias de tecnologias como a persistncia TopLink, JDO e
Hibernate. compatvel com o ambiente Java SE, bem como Java EE e permite aos tirar
vantagens da API de persistncia padro.
Persistncia de dados no to fcil para a maioria das aplicaes empresariais, porque
para isso necessitam do acesso ao banco de dados relacional, como por exemplo, Oracle
10g. de sua responsabilidade atualizar e recuperar o banco de dados e escrever o cdigo
usando SQL e JDBC. Enquanto vrios frameworks objeto-relacional (OR) como JBoss
Hibernate e OracleTopLink fazem com que a persistncia se torne mais simples e popular.
Permitem que o desenvolvedor Java seja livre de escrever cdigo JDBC e se concentre
apenas na lgica de negcios. No EJB 2.x, era necessrio Gerenciar a Persistncia do
Recipiente (CMP Container Manage Persistence) para resolver os desafios de
persistncia, que nem sempre isso era completamente bem sucedido.
A camada de aplicao de persistncia pode ser desenvolvida de vrias maneiras, mas a
plataforma Java no segue nenhum padro que deve ser utilizado tanto pela plataforma
Java EE e Java SE. A JPA parte da especificao EJB 3.0 (JSR-220) e realiza a persistncia
padro API para a plataforma Java. Fornecedores de mapeamento O/R como o Hibernate e
TopLink, bem como fornecedores JDO e outros fornecedores de servidores lderes de
aplicao esto recebendo a JSR-220.
Processo de trabalho de uma aplicao EJB usando JPA:
Modelo de Domnio
Ao desenvolver um aplicativo corporativo, o primeiro projeto do modelo de objeto de domnio
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
4 de 28
Define uma forma declarativa conhecida como mapeamento O-R de metadados para
realizar o mapeamento O-R. A maioria do quadro de usar XML para armazenar
metadados do mapeamento O-R.
Uma API necessrio para manipular como para efetuar CRUD (CRUD significa criar,
ler, atualizar e excluir) operaes. A API permite persistir, remover, atualizar ou
recuperar o objeto do banco de dados. O framework O-R executa operaes usando
a API e o mapeamento O-R de metadados em seu nome.
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
5 de 28
Que critrios deve-se usar para selecionar a ferramenta certa para seu projeto?
A resposta para todas estas perguntas examinar os Design Patterns (Padres de Projeto)
subjacentes da persistncia.
Modelos de Domnio
Quando se pensa qual o caminho para estruturar e representar a Lgica de Negcios em
seu sistema, possumos uma gama de escolhas. A partir da descrio formal, um Modelo de
Domnio um modelo de objeto do domnio que incorpora tanto o comportamento como os
dados.
Por exemplo, o projeto atual envolve Customer Relationship Management (CRM). Os objetos
de entidade contm dados e implementa regras de negcios envolvendo esses dados. Um
modelo de domnio pode variar em um modelo anmico que simplesmente um conjunto
de estruturas de dados para um modelo muito rico que guarda zelosamente os dados
brutos por trs uma interface restrita (Desenvolvimento Domain-Driven). Onde o seu modelo
de domnio cai nessa faixa em grande parte uma questo de quo complicada a lgica de
negcios em seu sistema realmente e como os relatrios prevalente ou a entrada de
dados esto em seus requisitos de sistema.
Antes de comear, vamos rever as duas principais formas de perceber o papel do cdigo de
acesso de banco de dados e dados em seu sistema:
6 de 28
7 de 28
reutilizar o mesmo mecanismo e outra vez tambm uma enorme economia de tempo.
Interface Component
Classe Leaf
Classe Composite
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
8 de 28
Ao mapear objetos para bancos de dados relacionais o lugar para comear com os
atributos de dados de uma classe. Um atributo ser mapeado para zero ou mais colunas em
um banco de dados relacional. Nem todos os atributos so persistentes, alguns so usados
para clculos temporrios. Por exemplo, um objeto de Aluno pode ter um atributo mdia
que necessrio dentro da aplicao, mas no armazenado na base de dados, porque
calculado dinamicamente. Como alguns atributos de um objeto so de direito prprio, um
objeto Cliente tem um objeto da classe Endereo como um atributo - isso realmente
reflete uma associao entre as duas classes que provavelmente precisam ser mapeadas, e
os atributos da classe Endereo precisam ser mapeados. O importante que esta uma
definio recursiva: Em algum momento o atributo ser mapeado para zero ou mais colunas.
Conceitos Chaves
Mapeamento. O ato de determinar como os objetos e seus relacionamentos so mantidos
em armazenamento de dados permanente, neste caso, bancos de dados relacionais.
Mapping. A definio de como a propriedade de um objeto ou um relacionamento mantido
no armazenamento permanente.
Propriedade. Um atributo de dados, quer implementado como um atributo fsico, tais como,
Nome, ou como um atributo virtual implementado atravs de uma operao tal como o
mtodo obterTotal(), que retorna o total de uma ordem.
Mapeamento da Propriedade. Um mapeamento que descreve como manter a propriedade
de um objeto.
Relao de Mapeamento. Um mapeamento que descreve como manter um relacionamento
(associao, agregao ou composio) entre dois ou mais objetos.
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
9 de 28
Alm disso, alguns atributos de objetos so objetos de direito prprio, por exemplo, um
objeto da classe Curso tem uma instncia de LivroDidtico como um atributo, que mapeia
as vrias colunas no banco de dados (na verdade, as chances so de que a classe
LivroDidtico ser mapeado para um ou mais tabelas em seu prprio direito).
O importante que esta uma definio recursiva: em algum momento o atributo ser
mapeado para zero ou mais colunas. tambm possvel que vrios atributos pode mapear
para uma nica coluna de uma mesa. Por exemplo, uma classe que representa um CEP
podem ter trs atributos numricos, uma representando cada uma das seces de um
cdigo total, enquanto que o CodigoPostal pode ser armazenada como uma nica coluna
em uma tabela de endereos.
O conceito de herana joga em vrias reviravoltas interessantes ao salvar objetos em um
banco de dados relacional. A questo basicamente se resume a descobrir como organizar os
atributos herdados dentro de seu modelo de persistncia. A modo de resolver este desafio
pode ter um grande impacto em seu projeto do sistema. H trs solues fundamentais para
o mapeamento de herana em um banco de dados relacional, e entend-las tais como
discutir os trade-offs para mapear o Diagrama de Classes apresentado na seguinte figura:
10 de 28
para as entidades.
A maior vantagem desta abordagem que ainda bastante fcil de executar os relatrios
ad hoc, uma vez que todos os dados necessrios esto sobre uma nica classe
armazenada em uma nica entidade.
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
11 de 28
As desvantagens so:
Sempre que um objeto muda seu papel por exemplo, um Estudante ser contratado
como um Professor necessrio copiar todos os dados para a entidade apropriada
e atribuir um novo OID.
difcil suportar mltiplos papis e ainda manter uma integridade dos dados. Por
exemplo, onde armazenaramos o nome de algum que ao mesmo tempo um
Estudante e um Professor?
A principal vantagem dessa abordagem que est de acordo com os conceitos Orientados a
Objeto. Suporta o polimorfismo muito bem de modo que temos registros nas tabelas
apropriadas para cada papel que um objeto pode ter. tambm muito fcil de modificar as
superclasses e adicionar subclasses novas, porque voc s precisa modificar ou adicionar
uma tabela.
As desvantagens so:
A existncia de muitas tabelas no banco de dados - uma para cada classe, de fato
(mais tabelas para manter relacionamentos).
Mais tempo para ler e gravar dados utilizando esta tcnica pois necessrio acessar
vrias tabelas. Este problema pode ser aliviado ao organizar o banco de dados,
colocando cada tabela dentro de uma hierarquia de classes em diferentes fsicas da
unidade de disco (Isso pressupe que cada um dos chefes da unidade de disco
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
12 de 28
Relatrios ad hoc em seu banco de dados difcil, a menos que seja adicionado
vises para simular as tabelas desejadas.
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
13 de 28
4. JPQL
Java Persistence Query Language (JPQL) uma plataforma independente de linguagem de
consulta orientada a objeto, foi definida como parte da especificao Java Persistence API.
JPQL usado para fazer consultas com entidades armazenados em um banco de dados
relacional. fortemente inspirada pelo SQL e suas consultas assemelham as consultas SQL
na sintaxe, mas operam em objetos de entidade JPA ao invs de diretamente com as tabelas
de banco de dados.
JPQL usado para definir as pesquisas nas entidades persistentes e so independentes do
mecanismo usado para armazenar essas entidades. Como tal, JPQL "porttil", e no
restrito a nenhum armazenamento de dados particular. JPQL uma extenso de EJB-QL
(Enterprise JavaBeans Query Language), acrescentando as operaes como excluir e
atualizar, operaes de juno, agregaes, projees, e subconsultas. Alm disso, JPQL
pode ser declarado estaticamente em metadados, ou podem ser dinamicamente construdo
em cdigo.
Alm de algumas poucas excees, JPQL diferencia maisculas de minsculas. Palavraschave JPQL, por exemplo, pode aparecer nos comandos quer no caso superior (por
exemplo, SELECT) ou em letras minsculas (por exemplo, select).
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
14 de 28
Porque SELECT e FROM so obrigatrias, isto demonstra uma consulta mnima JPQL.
A clusula FROM declara uma ou mais variveis de consulta (tambm conhecidas como
variveis de identificao). Variveis de consulta so semelhantes s variveis de lao em
linguagens de programao. Cada varivel de consulta representa a iterao sobre os
objetos no banco de dados. Uma varivel de consulta est ligado a uma classe de entidade
referido como uma varivel de intervalo.
Variveis de intervalo definir a iterao sobre todos os objetos de banco de dados de uma
classe de entidade de ligao e suas classes descendentes. Na consulta anterior, p uma
varivel de intervalo que vinculado classe da entidade Pas e define a iterao sobre
todos os objetos no banco de dados. A clusula SELECT define os resultados da consulta. A
consulta acima simplesmente retorna todos os objetos do campo a partir da iterao do
intervalo varivel p, que neste caso efetivamente todos os objetos do campo no banco de
dados.
Outros exemplos
Retornar todas as pessoas que moram no DF (Distrito Federal), GO (Gois) ou BA (Bahia):
SELECT p FROM Pessoa p WHERE p.endereco.uf IN ("DF","GO", "BA")
Retornar objetos de Autor que publicaram suas obras pela editora XYZ:
SELECT DISTINCT a FROM Autor a INNER JOIN a.livro l WHERE l.editora.nome = 'XYZ'
Retornar a moeda e a populao dos objetos de Pas que esto no continente Europeu:
SELECT p.moeda, SUM(p.populacao) FROM Pais p WHERE 'Europa' MEMBER OF p.continente
GROUP BY p.moeda HAVING COUNT(p) > 1
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
15 de 28
5. Consultas: Criteria
A especificao da JPA 2.0 define uma nova API para as consultas dinmicas atravs da
construo de uma instncia da classe javax.persistence.CriteriaQuery baseada em
objeto, em vez de uma abordagem baseada em strings usado em JPQL (Java Persistence
Query Language). Esta capacidade de definio de consulta dinmica referida como
Criteria API, e baseia-se no esquema persistente das entidades, seus objetos incorporados
e suas relaes.
A sintaxe projetada para construir uma rvore de comando cujos os ns representam os
elementos de consulta semntica, tais como projees, predicados condicionais de clusula
WHERE ou GROUP BY elementos.
Um domnio de consulta pode ser refinado para unir outros objetos de domnio. Por exemplo,
para a definio acima operar sobre os Clientes e suas Ordens de Servio, podemos utilizar
o metodo join():
Root<OrdemServico> os = cliente.join(cliente.get(Cliente_.ordens));
16 de 28
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
17 de 28
6. Validao e Integridade
Com a implementao da JSR-303 podemos utilizar a estrutura de validao no lado do
servidor (EJB Session Bean) e no Managed Bean das aplicaes Web JSF. Isto evita a
perde de tempo na tomada das Regras de Negcio, que no necessitaro mais de
validadores nos componentes JSF UI.
Para tornar isso mais interessante podemos combinar com o Apache MyFaces Extensions
Validator (ExtVal). Esta estrutura pode ser usada com a JSF (existe uma biblioteca genrica
e um especial para Trinidad) e suporta a validao atravs do uso dos Bean Validation.
ExtVal tambm tem alguns recursos extras.
Validao do modelo
Validao do cliente
A validao de dados uma tarefa comum que ocorre em todas as camadas de uma
aplicao, incluindo persistncia. JPA 2.0 oferece um suporte para a API Bean Validation
para que a validao de dados possa ser realizada em tempo de execuo.
A API Bean Validation fornece uma validao transparente em todas as tecnologias da
plataforma Java EE e Java SE. Alm de JPA 2.0, estas tecnologias incluem JavaServer
Faces (JSF) 2.0 e Java EE Connector Architecture (JCA) 1.6.
H trs conceitos fundamentais para Bean Validation: restries, manipulao de violao
de restrio e do validador. Ao executar aplicaes em um ambiente integrado como APP,
no h necessidade de interagir diretamente com o Validador.
Restries de validao so anotaes ou cdigo XML que so adicionados a uma aula de
campo, ou mtodo de um componente JavaBeans. As restries podem ser construdas ou
definido pelo usurio. So utilizados para as definies de restrio regulares e para a
composio de restries. As restries internas so definidas pela especificao da Bean
Validation e esto disponveis com cada provedor de validao.
Grupos de validao
Bean Validation usa grupos de validao para determinar o tipo de validao e quando a
validao ocorre. No existem interfaces especiais para implementar ou anotaes para
criar um grupo de validao. Um grupo de validao denotada por uma definio de
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
18 de 28
classe.
Quando no uso de grupos, utilizar interfaces simples. Usando uma interface simples torna
mais utilizvel grupos de validao em vrios ambientes. Considerando que, se uma
definio de classe ou entidade usado como um grupo de validao, pode poluir o modelo
de objeto de outro aplicativo, trazendo em classes de domnio e lgica que no realiza
qualquer sentido para a aplicao.
Por padro, se um grupo de validao ou vrios grupos no especificado em uma restrio
individual, que validado utilizando o grupo javax.validation.groups.Default. Criar um
grupo personalizado to simples como criar uma definio de uma nova interface.
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
19 de 28
7. SQL Nativo
JPA pode executar consultas SQL simples. Esse tipo de Consulta denominada JPA Native
Query e possui as seguintes propriedades:
interessante notar que no estamos limitado a JPQL ao definir que as consultas sejam
firmadas com a API Query. Pode-se surpreender ao saber que a API EntityManager oferece
mtodos para criar instncias de consulta para a execuo de comandos SQL nativos.
Aqui est um exemplo simples de uma consulta SQL dinmico nativo:
A. Entidade: Estudante
CREATE TABLE `estudante` (
`id` int(11) NOT NULL auto_increment,
`nome` varchar(100) NOT NULL,
`curso` varchar(10) NOT NULL,
PRIMARY KEY (`id`)
)
javax.persistence.Column;
javax.persistence.Entity;
javax.persistence.GeneratedValue;
javax.persistence.Id;
javax.persistence.NamedQueries;
javax.persistence.NamedQuery;
javax.persistence.Table;
@Entity
@Table(name="estudante")
public class Student {
@Id
@GeneratedValue
private int id;
@Column(name="nome", length=100, nullable=false)
private String nome;
@Column(name="curso", length=10, nullable=false)
private String curso;
public int getId() {
return id;
}
public void setId(int id) {
this.id = id;
}
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
20 de 28
java.util.Iterator;
java.util.List;
javax.persistence.EntityManager;
javax.persistence.EntityManagerFactory;
javax.persistence.EntityTransaction;
javax.persistence.Persistence;
javax.persistence.Query;
A coisa mais importante a compreender sobre as consultas SQL nativas que so criadas
com mtodos EntityManager que eles, como consultas JPQL, retornam instncias da
entidade, ao invs de registros da tabela de banco de dados.
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
21 de 28
22 de 28
Concorrncia Otimista
O bloqueio otimista permite processar transaes simultaneamente, mas detecta e evita
colises, isso funciona melhor para aplicaes onde a maioria das transaes concorrentes
no entram em conflito. O bloqueio JPA otimista permite a qualquer pessoa ler e atualizar
uma entidade, no entanto, uma verificao de verso feito aps confirmao e uma
exceo lanada se a verso foi atualizada no banco de dados uma vez que a entidade foi
lida. Deve existir a anotao com @Version, conforme mostrado abaixo:
public class Funcionario {
@ID int id;
@Version int versao;
Concorrncia pessimista
O bloqueio pessimista promove um lock na linha do banco de dados quando os registros
so lidos, equivalente a um comando:
SELECT ... FOR UPDATE [NOWAIT]
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
23 de 28
9. Hibernate
Hibernate, criado por Gavin King, conhecido como o objeto e melhor dominada ferramenta
de Persistncia Objeto Relacional (ORM) para desenvolvedores Java. Fornece muitas
maneiras elegantes e inovadoras para simplifica a tarefa de movimentao de dados
relacional em Java.
JPA 2 define critrios de consulta que podem ser construdas de uma maneira fortemente
tipada, usando os objetos do metamodelo para fornecer uma segurana de tipos. Em vez de
usar o arquivo especfico de configurao do Hibernate, hibernate.cfg.xml, JPA, define um
processo de inicializao diferente, que usa seu prprio arquivo de configurao chamado
persistence.xml. Como isso funciona, bootstrapping definida pela especificao JPA. Em
ambientes Java o provedor de persistncia (Hibernate, neste caso) necessrio para
localizar todos os arquivos de configurao do JPA por pesquisa classpath do nome do
recurso META-INF/persistence.xml.
<persistence xmlns="http://java.sun.com/xml/ns/persistence"
xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
xsi:schemaLocation="http://java.sun.com/xml/ns/persistence
http://java.sun.com/xml/ns/persistence/persistence_2_0.xsd"
version="2.0">
<persistence-unit name="org.hibernate.tutorial.jpa">
...
</persistence-unit>
</persistence>
O arquivo persistence.xml fornece um nome nico para cada unidade de persistncia. Este
nome feito para os aplicativos referncia a configurao ao obter uma referncia
javax.persistence.EntityManagerFactory.
Aqui as variedades javax.persistence-prefixed so usadas quando possvel. Para os
restantes especficaes do Hibernate os nomes de parmetros de configurao notam que
esto agora prefixado.
protected void setUp() throws Exception {
entityManagerFactory =
Persistence.createEntityManagerFactory("org.hibernate.tutorial.jpa");
}
24 de 28
entityManager = entityManagerFactory.createEntityManager();
entityManager.getTransaction().begin();
List<Event> result = entityManager.createQuery("para o Evento", Event.class)
.getResultList();
for (Event event: result) {
System.out.println("Evento (" + event.getDate() + ") :" + event.getTitle());
}
entityManager.getTransaction().commit();
entityManager.close();
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
25 de 28
26 de 28
dados a fim de preencher objetos de negcios, voc vai encontrar filas interminveis de
cdigo onde os valores de propriedade so copiados de um objeto Java para outro. Ento,
qual o ponto em que todos esses mtodos GET e SET em primeiro lugar?
Com os Dynamic Beans s existe um GET e SET genrico para cada entidade que ambos
j foram implementadas. A quantidade de classes podem ficar na mesma, como tambm
recomendou a criao de uma classe de objeto de dados individuais para cada entidade do
banco de dados - embora isso no necessrio quando se utiliza um objeto DBRecord
genrico.
Isso recomendvel por duas razes:
Um novo tipo de segurana, desde que queira que o seu cdigo interno conte com
determinadas entidades.
Mas mesmo assim, devido ausncia de todos esses campos de membros e sua
correspondente e mtodos GET e SET vai acabar com muito menos cdigo para manter.
Ainda assim podemos adicionar GET e SET especiais para as colunas individuais se for
necessrio ou conveniente.
27 de 28
lados da relao. Kodo no executa nenhuma "mgica" para manter relaes consistentes
por padro, o aplicativo deve sempre garantir que o modelo de objeto Java consistente.
possvel, no entanto, configura-lo para gerir as relaes bidirecionais.
Consideraes Finais
De modo a otimizar a JPA recomendamos a leitura do artigo que pode ser obtido no seguinte
endereo: http://java-persistence-performance.blogspot.com.br/2011/06/how-to-improve-jpaperformance-by-1825.html
S G A S 9 1 0 , B l o c o D , sa l a s , 2 3 7 a 2 4 3 , M i x Pa r k S u l A s a S u l , B ra s l i a / D F
C E P : 7 0 . 3 9 0 - 1 0 0 Fo n e / Fa x : ( 6 1 ) 3 2 4 4 - 2 5 1 0 3 2 4 2 - 4 3 3 9
28 de 28